Question

I think I must be missing something, why can’t I compile this:

class Foo<T> where T : Bar
{
    T Bar;
}

abstract class Bar
{ }

class MyBar : Bar
{ }

static void Main(string[] args)
{
    var fooMyBar = new Foo<MyBar>();
    AddMoreFoos(fooMyBar);
}

static void AddMoreFoos<T>(Foo<T> FooToAdd) where T : Bar
{
    var listOfFoos = new List<Foo<Bar>>();
    listOfFoos.Add(FooToAdd); //Doesn't compile
    listOfFoos.Add((Foo<Bar>)FooToAdd); //doesn't compile
}

Answer 1

You’re make things a little bit more confusing than they need to be by using a list here… it’s easiest to see the effect this way:

// This won't compile
Foo<Bar> fooBar = new Foo<MyBar>();

Given that this doesn’t compile, it’s then not surprising that you can’t add a Foo<MyBar> to a List<Foo<Bar>>

So why isn’t a Foo<MyBar> a Foo<Bar>? Because generic classes aren’t covariant.

Generic variance was only introduced in C# 4 – and it only works for interfaces and delegates. So you could (in C# 4) do:

IEnumerable<MyBar> x = new List<MyBar>();
IEnumerable<Bar> y = x;

but you couldn’t do:

IList<MyBar> x = new List<MyBar>();
IList<Bar> y = x;

I have a whole talk about variance which you can download from the NDC 2010 video site – just search for “variance”.