使用内部类型作为接口转换泛型

Question

.NET Fiddle

using System;

interface Interface { }
class Outer<T> : Interface
    where T : Interface { }
class Inner : Interface { }

public class Program
{
    public static void Main()
    {
        Type outer = typeof(Outer<>);
        Type inner = typeof(Inner);
        Type expectedType = typeof(Outer<Interface>);
        Type final = outer.MakeGenericType(inner);

        // This works
        Inner innerInstance = (Inner)Activator.CreateInstance(inner);

        // This works
        Outer<Inner> outerInstance = (Outer<Inner>)Activator.CreateInstance(final);

        // We can cast the real type
        Interface interfaceInstance = innerInstance;

        // But we cant cast with the interface as the inner type
        Outer<Interface> casted = (Outer<Interface>)outerInstance;
    }
}

This cast will fail (Outer<Interface>)outerInstance; as it doesn't recognise the inner type as Interface.
Is there any way to force or conver it into the type Outer<Interface> rather than Outer<Inner> ?

Answer 1

To reduce this to what's minimally needed I renamed the types (because types named Interface , Inner , and Outer<T> scramble my brain.

interface IFoo { }

class Bar<T> : IFoo where T : IFoo
{ }

class Foo : IFoo { }

And when we simplify it, the question is why won't the compliler let us do this?

Bar<IFoo> casted = new Bar<Foo>(); 

Every Foo is an IFoo , so why can't we do this?

There's always something that the compiler is protecting us from. Sometimes it's hard to figure out what that something is.

It becomes clearer if we add a little bit to Bar<T> and another class:

class Bar<T> : IFoo
    where T : IFoo
{
    private List<T> _foos = new List<T>();

    public void Add(T foo)
    {
        _foos.Add(foo);
    }
}

class OtherFoo : IFoo {}

If we have an instance of Bar<Foo> then the inner list contains items of types Foo . Every item we add to the list must be of type Foo .

If we could cast this as Bar<IFoo> then we could do this:

var x = new Bar<Foo>();
Bar<IFoo> y = (Bar<IFoo>)barOfFoo;
y.Add(new OtherFoo())

Now we can see what the compiler is preventing. x is a Bar<Foo> . Every item in the _foos list must be a Foo .

But by casting the object as Bar<IFoo> we would make it possible to add an OtherFoo to the list. That wouldn't make any sense. It's a List<Foo> , so how could we add something to the list that isn't a Foo ?

---

Here's an even simpler version that illustrates the same principle with less noise:

var listOfFoo = new List<Foo>();
var listOfIFoo = (List<IFoo>)listOfFoo; // we can't do this!
listOfIFoo.Add(new OtherFoo());

We may have tried to do this at some point. The compiler doesn't allow it for exactly the same reason. It would allow us to create a List<Foo> and then add something to it that's not a Foo .