Question

I’m trying to create a set of classes with different level of abstraction. I will use the Vector example here.

My goal is that the user of my classes can choose the level of abstraction to use i.e. they may or may not want to be using the more derived class.

interface IVector
{
    Vector A();
}

interface ISparseVector : IVector
{
    new SparseVector A();
}

Now, I implement the classes as such:

class Vector : IVector
{
    public Vector A() { return new Vector(); }
}

class SparseVector : Vector,ISparseVector
{
    public new SparseVector A() { return new SparseVector(); }
}

This is all fine and dandy. However, when the base class is abstract such as:

abstract class Vector : IVector
{
    public abstract Vector A();
}

class SparseVector : Vector,ISparseVector
{
    public SparseVector A() { return new SparseVector(); } // Hides abstract member.
}

I get a compile error saying that the derived method is hiding the abstract method in Vector. Any idea of how to get around this?

Answer 1

The feature you want is called “return type covariance”, and it is not a feature of C#. Return type covariance is the feature where you can have a virtual method that return an Animal, and then you override that with a method that returns a Giraffe.

Doing so is typesafe and some languages do have this feature — C++ for example — but C# does not and we have no plans to add it. Your overriding method has to be marked override, and it has to match exactly — in name, formal parameter types, and return type.