Can C# 4.0 variance help me call a base class constructor with an upcast?

Question

I was reading a bit on generic variance and I don't have a full understanding of it yet but I'd like to know if it makes something like the following possible?

class A<T> { }

class B { }

class C : B { }

class My1  {
    public My1(A<B> lessDerivedTemplateParameter)
    {
    }
}

class My2 : My1 {
    public My2(A<C> moreDerivedTemplateParameter)
        : base(moreDerivedTemplateParameter) // <-- compile error here, cannot convert
    {
    }
}

I am not as fluent in the generic variance as i would like to be, hence this a comment, not an answer, but i think you need to define `A` as `A` to make this compile. — psubsee2003, May 25 '12 at 19:17
@psubsee2003: I believe that is only allowed for interfaces. — Douglas, May 25 '12 at 19:20
interesting, i did your suggestion plus had to make A and interface, then it compiles...i'll keep going and see if I can get the same result I was after, thanks... — Aaron Anodide, May 25 '12 at 19:21
Generic variance does not work with classes in C#. If `A` were an interface, then you can declare it as `A`, and then you could call the base constructor the way you want. — dlev, May 25 '12 at 19:21

Chris Shain · Accepted Answer · 2012-05-25T19:25:43.060

No, because while C inherits from B, A<C> does not inherit from A<B>.

To understand why this is the case, imagine if A<T> were instead List<T>:

class B { }

class C : B { }

class D : B { }

class My1  {
    public My1(List<B> lessDerivedTemplateParameter)
    {
       // This is totally legal
       lessDerivedTemplateParameter.Add(new D());
    }
}

class My2 : My1 {
    public My2(List<C> moreDerivedTemplateParameter)
        // if this were allowed, then My1 could add a D to a list of Bs
        : base(moreDerivedTemplateParameter)
    {
    }
}

Now on the other hand, this is legal:

interface IA<out T> { 
    public T GetSome();
}

class B { }

class C : B { }

class D : B { }

class My1  {
    public My1(IA<B> lessDerivedTemplateParameter)
    {
       // This is totally legal
       var someB = lessDerivedTemplateParameter.GetSome();
    }
}

class My2 : My1 {
    public My2(IA<C> moreDerivedTemplateParameter)
        // This is allowed, because an A<C> only *produces* C's (which are also B's)
        // so the base class (which consumes B's, and doesnt care if they are C's) 
        // can use an IA<C>
        : base(moreDerivedTemplateParameter)
    {
    }
}

This is correct, but misses the point of the question. He *knows* that the current setup doesn't work, and wants to know if he can take advantage of variance to change that situation. You've just restated what he already knows. — dlev, May 25 '12 at 19:22

score 2 · Answer 2 · answered May 25 '12 at 19:26

2

You can declare A as an interface with a contravariant type parameter and it will compile:

internal interface A<out T>
    {
    }

    internal class B
    {
    }

    internal class C : B
    {
    }

    internal class My1
    {
    public My1(A<B> lessDerivedTemplateParameter)
    {
    }
}

internal class My2 : My1
{
    public My2(A<C> moreDerivedTemplateParameter)
        : base(moreDerivedTemplateParameter) 
    {
    }

}

answered May 25 '12 at 19:26

w.brian

16,296
14
69
118

1

the critical thing to note here is that this constrains A to only producing (and not consuming) type T. – Chris Shain May 25 '12 at 19:27
@ChrisShain, and that is the connection to meaning of `out` right? – Aaron Anodide May 25 '12 at 19:31

Can C# 4.0 variance help me call a base class constructor with an upcast?

2 Answers2