Why can't a deriving class override a property in its base class with a type derived from the original type?

Question

Effectively, I'd like to understand why this is not possible in C#:

class Foo{
    public Bar Property {get;set;}
}

class Boo : Foo{
    public override Baz Property {get;set;}
}

class Bar{
    //some internal stuff
}

class Baz : Bar{
    //more stuff
}

To me, it seems like this would have pretty clearly defined behavior in most cases, so long as the Baz class doesn't hide a member from the Bar class (with new or something). The compiler would know if this was going to happen though, so it seems like a kind of non-issue.

I also understand that this can be achieved with abstract classes, but I specifically would like to get a better understanding of why this is disallowed in the case of non-abstract classes.

This isn't allowed any more with abstract classes than it is with regular classes. Perhaps you're thinking of generic classes? — ProgrammingLlama, Aug 27 '20 at 07:46
The duplicate question has an answer which demonstrates a workaround, but it doesn't answer the OP's question of "WHY is this not allowed?" — Matthew Watson, Aug 27 '20 at 07:54
[Related GitHub Issue](https://github.com/dotnet/csharplang/issues/2844) — ProgrammingLlama, Aug 27 '20 at 07:56
Reading the issue, it seems to be [proposed for C# 9](https://github.com/dotnet/csharplang/blob/master/proposals/csharp-9.0/covariant-returns.md). — ProgrammingLlama, Aug 27 '20 at 08:00
@JohnathanBarclay It wouldn't make sense to allow it for property setters since you couldn't ensure type safety. — ProgrammingLlama, Aug 27 '20 at 08:22
@John Exactly. I only mention because the properties in the question have setters. — Johnathan Barclay, Aug 27 '20 at 08:24

MakePeaceGreatAgain · Accepted Answer · 2020-08-27T08:09:09.060

4

Imagine someone uses your code:

Foo f = new Boo();

As the reference is of type Foo we can only assume Property to be of type Bar. So we can also write this now:

f.Property = new Boz(); // assuming Boz also derives from Bar

which will pretty sure not be what you actually wanted.

edited Aug 27 '20 at 08:09

answered Aug 27 '20 at 07:56

MakePeaceGreatAgain

35,491
6
60
111

Yeah thanks that makes sense. I can't help but think there should be some way around it, in terms of compiler errors or something, but thanks! – PhonicCanine Aug 27 '20 at 08:36

score 2 · Answer 2 · answered Aug 27 '20 at 08:09

You can use the following workaround for that, but making Foo generic interface and implement it in Boo class

interface IFoo<T> where T : Bar
{
    public T Property { get; set; }
}

class Boo : IFoo<Baz>
{
    public Baz Property { get; set; }
}

There is also a covariant return types, planned in C# 9. But it'll work with readonly properties only

Why can't a deriving class override a property in its base class with a type derived from the original type?

2 Answers2