Cannot cast between generic types

I'm trying to do this:

interface IA
{
}

class A : IA
{
}

class Foo<T> where T: IA
{
}

class Program
{
    static void Main( string[] args )
    {
        Foo<A> fooA = new Foo<A>();
        Foo<IA> fooIA = fooA as Foo<IA>;
    }
}

However, the cast from Foo<A> to Foo<IA> does not compile. I recall seeing covariance issues like this when casting between List<T>'s, but I didn't think it applied to simple generics like this.

W开发者_Go百科hat is a good work around to getting this cast to work? How do I solve this problem?

All generic classes are invariant. Interfaces (and delegates) on the other hand can support co- and contra-variance, but only in the cases where it's possible safely. And they need to opt-in explicitly.

For example via IFoo<out T> or IFoo<in T>

interface IA
    {
    }

    class A : IA
    {
    }

    interface IFoo<T> where T : IA
    {
    }

    class Foo<T> : IFoo<T> where T : IA
    {
    }

    class Program
    {
        static void Main(string[] args)
        {
            IFoo<A> fooA = new Foo<A>();
            Foo<IA> fooIa = fooA as Foo<IA>;
        }
    }

those classes perform operations on those base types and NEVER need to downcast them

Then why do you need a Foo<A> to begin with? Declare it as Foo<IA> and add A's to it.

Sorry this is in java but you could do something like this:

interface Alpha
{
}

class Beta implements Alpha
{
}  

class Foo<T>
{
}

class Program
{
    static void main(string[] args)
    {
        Foo<Beta> fooBeta = new Foo<Beta>();
        Foo<? implements Alpha> fooAlpha = fooBeta;
    }
}

This doesn't solve the issue completely but you get you can at least get access to all of the Alpha methods without knowing about Beta...