Allow methods and/or properties with a more restrictive type to implement interface methods and/or properties.

[morfanaion]

When overriding a virtual method of a base class you are allowed to specify a more restrictive return type (so a return type that has the original return type of one of its base types). For example:

internal class DerivativeClassForTesting : BaseClassForTesting
{
    public override string Proof => $"I am an instance of {nameof(DerivativeClassForTesting)}";
}

internal class BaseClass
{
    public virtual BaseClassForTesting TheMethod() => new BaseClassForTesting();
}

internal class ImplementedClass : BaseClass
{
    public override DerivativeClassForTesting TheMethod() => new DerivativeClassForTesting();
}

The fact that this is allowed sort of makes sense. DerivativeClassForTesting will always be castable to BaseClassForTesting and as such, this would not lead to a problem per se. However, the same logic does not seem to apply to interfaces. If I try to do the same with interfaces I have to do this:

internal class DerivativeClassForTesting : BaseClassForTesting
{
    public override string Proof => $"I am an instance of {nameof(DerivativeClassForTesting)}";
}

internal interface ITestInterface
{
    BaseClassForTesting TheMethod();
}

internal class ImplementedClass : ITestInterface
{
    public DerivativeClassForTesting TheMethod() => new DerivativeClassForTesting();

    BaseClassForTesting ITestInterface.TheMethod() => TheMethod();
}

In my use cases I have a library that contains the interfaces of my implementations where the implementations are in a different library. This method is done to allow other libraries to be able to handle my objects and me being able to use objects of those other libraries, without running into circular referencing. This means that I can use the actual interfaces of the other libraries in my implementations and vice versa, but the interfaces themselves have to use base interfaces from a shared library. In my implementations I will often prefer to use the return types of the actual interfaces I'm referencing, mainly for use within my own library, which forces me to do explicit implementations. Those explicit implementations in these case are relatively redundant as all they will ever do is just reference the method that returns the derivative.

As such, I would request a change that would allow a method or property with a type that is a derivative of the type of the method or property in the interface to implement that method or property, so that we can reduce the number of these explicit implementations.

[EDIT]new to this, needed to fix the code blocks :-)[/EDIT]

[HaloFour]

See: #4372

[morfanaion]

Not entirely the same thing, although it seems related. #4372 deals with extending an interface with a new interface where a method with the same name but a derived type should count as the same method in implementation. It does however still require an interface that specifies the derived return type. It is my belief that this extending interface should not even be required, rather, a method that returns a derived type of the interface method should simply qualify to implement that method.