Question

Given the following hypothetical situation:

class ClassParent { }
interface IClassProvider { ClassParent Get(); }

Why is this then illegal IClassProvider implementation:

class ClassChild : ClassParent, IClassProvider
{
    ClassChild Get() { return this; }
}

It also doesn’t work for inheriting properties and implementing base class instead of an interface like in the example.

ClassChild is ClassParent. Why does it not compile then? The compiler is clearly aware of a compile-time type of a class, that’s why the following works:

void DoSomething(object o) { ... };
void DoSomething(ConcreteClass c) { ... };

DoSomething(new ConcreteClass()); //Calls the second overload of the method because of static type resolving

In layered scenarios this forces me to have a bunch of proxy-methods and needlessly clutter my code when the underlying situation is clear. Frankly I can’t think of any problems or ambiguities if that was supported. I would be happy with compile-time (static) resolution, like it works with overloads in the second example.

Edit: I know that the compiler expects the following:

class ClassChild : ClassParent, IClassProvider
{
    ClassParent Get() { return this; }
}

and I know that it would work, I’m asking for an explanation why is it not supported or a scenario in which it would cause either a) problems or b)ambiguities worse than with overloads, which are supported.

Edit 2:
This is as it seems another duplicate of a same old question as answered by apparently MS himself in this SO question. I’m marking @Euphoric ‘s post as answer because he provided a name for the feature which helped finding the “solution”.

Answer 1

I think feature you are looking for is name Covariant Return Type

As to “why” is it not implemented, noone knows. IMO this feature is not so needed, so it is simply not implemented.

And especialy in your case it can be easily solved using Explicit Interface Implementation