Covariant returns for interfaces

[macsux]

C# 9 has allowed covariant return types for classes. It would be very useful to have the same extend to interfaces, as the use of this feature is often blocked when implementing an interface.

Currently, the following is allowed

abstract class Base 
{
    public abstract Base MyMethod();
}

class Derived : Base
{
    public override Derived MyMethod()
    {
        throw new NotImplementedException();
    }
}

but doing this is not:

abstract class Base : IBase
{
    public abstract Base MyMethod();
}

class Derived : Base, IDerived
{
    public override Derived MyMethod()
    {
        throw new NotImplementedException();
    }
}

public interface IBase
{
    IBase MyMethod();
}

public interface IDerived : IBase
{
    IDerived MyMethod();
}

In the above, the IDerived doesn't actually "override" parent interface - it adds an additional method.

Additionally, Covariant return for concrete types does not work with Generics. The following is currently invalid:

abstract class Base<T>
{
    public abstract Base<T> MyMethod();
}

class Derived<T> : Base<T>
{
    public override Derived<T> MyMethod()
    {
        throw new NotImplementedException();
    }
}

[msedi]

I absolutely agree but wouldn't make more sense to put it in as a proposal?

[YairHalberstadt]

I think the issue here is simply that the runtime didn't add support for it. I think it would be worth raising with the runtime team why that is and whether there are any plans to change that.

[canton7]

Interestingly, it's in the proposal. That does include the line

Due to this breaking change, we might consider not supporting covariant return types on implicit implementations.

So I wonder whether that was an explicit decision in order to keep backwards compat, but I've failed to find any discussion on that.

[macsux]

The proposal explored using the word "new" to define a new member. If a derived interface is trying to redefine a member with a more specific signature, it makes more sense to allow for the "override" keyword to be used instead. This also solves problems with default interface implementations, where derived interfaces might want to redefine the behavior. Currently, the way to do it is to define the member as "new" on the child interface, and implement default on base like this:

public interface IBase
{
    IBase MyMethod();
}

public interface IDerived : IBase
{
    IBase IBase.MyMethod() => MyMethod();
    new IDerived MyMethod();
}

But the above expose the ability of any concrete classes to implement IBase directly, wiping out the redirection and causing a break in the intended usage pattern.

What would make sense is something like this:

public interface IBase
{
    IBase MyMethod();
}

public interface IDerived : IBase
{
    override IDerived MyMethod();
}