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.

What does "pass an implementation of IAmA" mean? ClassB does not inherit anything from ClassA, it still has to implement every member of IAmB. Why do you have to inherit from IAmB<ClassA> instead of IAmB<IAmA> ? What is the actual problem you are trying to solve? — Panagiotis Kanavos
– Panagiotis Kanavos, Commented Sep 10, 2015 at 7:24
the update didn't explain anything - it's clear from the start you want to use the concrete class - the question is why? — Panagiotis Kanavos
– Panagiotis Kanavos, Commented Sep 10, 2015 at 7:26
While you can declare T as a covariant parameter (out T), you will only be able to use it in return parameters. What is the actual problem you are trying to solve? — Panagiotis Kanavos
– Panagiotis Kanavos, Commented Sep 10, 2015 at 7:44
Well, duh - ClassB is not IAmB<IAmA>. Why would you want to treat it that way? Do you think it would be reasonable if you could just implicitly pass an object as a string argument to a method? Because that's exactly what you're doing here. — Luaan
– Luaan, Commented Sep 10, 2015 at 7:49

Community · Accepted Answer · 2017-05-23 10:26:41Z

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

Raphaël Althaus · Accepted Answer · 2015-09-10 07:30:00Z

3

Fast answer : make the generic type covariant (see msdn) in your interface

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

this will resolve the compiler problem.

But this won't answer the why asked by Panagiotis Kanavos !

answered Sep 10, 2015 at 7:30

Raphaël Althaus

60.6k6 gold badges106 silver badges127 bronze badges

Comments

lc. · Accepted Answer · 2015-09-10 07:32:51Z

2

The trick is making the type constraint T on IAmB<T> covariant, with the out keyword:

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

This allows you to use a more specific type than originally specified, in this case allowing you to assign an IAmB<ClassA> to a variable of type IAmB<IAmA>.

For more information, see the documentation.

answered Sep 10, 2015 at 7:32

lc.

117k21 gold badges163 silver badges190 bronze badges

Comments

Jiang YD · Accepted Answer · 2015-09-10 07:40:16Z

0

I just tell why this error reported.

if your IAmB has a method

public interface IAmB<T> where T : IAmA
{
    void foo(T p);
}

public class ClassB : IAmB<ClassA>
{
    void foo(ClassA p)
    {
        p.someIntField++;
    }
}

and we have another class

public class ClassC : IAmB<ClassA2>
{
    void foo(ClassA2 p)
    {
        p.someOtherIntField++;
    }
}

and we assume List<IAmB<IAmA>>.Add(T p) implement like this

IAmA mParam = xxxx;
void Add(IAmB<IAmA>> p){
    p.foo(mParam);
}

thinking all compile OK. you pass a ClassB instance to List.Add, it becomes

void Add(IAmB<IAmA>> p){
    //p is ClassB now
    p.foo(mParam);//COMPILER CAN NOT MAKE SURE mParam fit ClassB.foo
}

answered Sep 10, 2015 at 7:40

Jiang YD

3,3091 gold badge17 silver badges22 bronze badges

1 Comment

Panagiotis Kanavos Over a year ago

This isn't an actual answer.

user3844214 · Accepted Answer · 2015-09-10 07:47:25Z

0

It can be solved using Contravariance and Covariance.

public interface IAmA
{
}

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


public class ClassA : IAmA
{
}

public class ClassB : IAmB<ClassA>
{
}


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

Now you don't get compiler error. Compiler is happy.

answered Sep 10, 2015 at 7:47

user3844214

234 bronze badges

1 Comment

Panagiotis Kanavos Over a year ago

Not quite - covariance only allows T to be used as a return type.

Collectives™ on Stack Overflow

C# Generics, interfaces and inheritance

5 Answers 5

Comments

Comments

Comments

1 Comment

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

Comments

Comments

1 Comment

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related