C# Generics, interfaces and inheritance

Question

I've two interfaces:

public interface IAmA
{
}

public interface IAmB<T> where T : IAmA
{
}

And two classes implementing these interfaces like this:

public class ClassA : IAmA
{
}

public class ClassB : IAmB<ClassA>
{
}

When trying to use these classes as shown:

public class Foo
{
    public void Bar()
    {
        var list = new List<IAmB<IAmA>>();
        list.Add(new ClassB());
    }
}

I get this compiler error:

cannot convert from 'ClassB' to 'IAmB<IAmA>'

I know I can make the compiler happy using:

public class ClassB : IAmB<IAmA>
{
}

But I need to be able to be the Type parameter for IAmB<> in ClassB an implementation of IAmA.

Answer 1

The quick answer is that you can do what you ask by declaring the type parameter of IAmB<T> as covariant, only if the type is used as a return type:

public interface IAmB<out T> where T : IAmA
{
    T SomeMethod(string someparam);
}

out T means that you can use a more specific type than then one specified in the constraints.

You won't be able to use T as a parameter. The following won't compile:

public interface IAmB<out T> where T : IAmA
{
    void SomeMethod(T someparam);
}

From the documentation

You can use a covariant type parameter as the return value of a method that belongs to an interface, or as the return type of a delegate. You cannot use a covariant type parameter as a generic type constraint for interface methods.

This isn't a compiler quirk. Assuming you could declare a covariant method parameter, your list would end up containing some objects that couldn't handle an IAmB<IAmA> parameter - they would expect an input of ClassA or more specific. Your code would compile but fail at runtime.

Which begs the question - why do you want to use IAmB<ClassA> ?

You should think about before using this though, as there may be other, more suitable ways to address your actual problem. It's unusual to use a generic interface implementing a concrete type but trying to use it as if it were implementing another interface.

You can check the MSDN documentation's section on Covariance and Contravariance as well as Eric Lippert's an Jon Skeet's answers to this SO question: Difference between Covariance and Contravariance