Question

This is what I want my classes to look like, but this code won’t compile. How do I make it work?

public interface ISomeInterface
{
    string AMember { get; }
}
public abstract class BaseClass
{
    public abstract ISomeInterface AObject { get; }
    public abstract IEnumerable<ISomeInterface> AMethod();
}

public class DerivedClass<T> : BaseClass where T : ISomeInterface
{
    public T AObject { get; private set; }
    public IEnumerable<T> AMethod()
    {
        return null;
    }
}

Compiler errors

‘Delfin.Accountancy.DerivedClass’ does not implement inherited abstract member ‘Delfin.Accountancy.BaseClass.AObject.get’

‘Delfin.Accountancy.DerivedClass’ does not implement inherited abstract member ‘Delfin.Accountancy.BaseClass.AMethod()’

Running on c# 5.0.

Notes

I’ve tried most obvious implementations, but any of them allow me to implement the base class and expose the strongly typed members at once.

I don’t want to make the base class generic, because I’ll create static methods on the base class, and also create extension methods that might work in every case of derived classes.

I also need the derived class to be generic, because T has more members than ISomeInterface in the real world case.

Thanks!

Answer 1

What you are asking for is called return type covariance and C# does not support this (see this answer for more details). You have to modify your classes in some way but you haven’t indicated what is acceptable. Here is a way that does not change the public API, but changes the abstract methods to protected methods.

public interface ISomeInterface
{
    string AMember { get; }
}

public abstract class BaseClass
{
    public ISomeInterface AObject { get { return GetAObjectImpl(); } }     
    public IEnumerable<ISomeInterface> AMethod() { return AMethodImpl(); }

    protected abstract ISomeInterface GetAObjectImpl();
    protected abstract IEnumerable<ISomeInterface> AMethodImpl();
}

public class DerivedClass<T> : BaseClass where T : ISomeInterface
{
    public new T AObject { get; private set; }

    public new IEnumerable<T> AMethod() { return Enumerable.Empty<T>(); }

    protected override ISomeInterface GetAObjectImpl() 
    {
        return AObject;
    }

    protected override IEnumerable<ISomeInterface> AMethodImpl()
    {
        return AMethod();
    }
}