Cannot cast between generic types

Question

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.

What is a good work around to getting this cast to work? How do I solve this problem?

Some related reading: http://stackoverflow.com/questions/245607/how-is-generic-covariance-contra-variance-implemented-in-c-4-0/246101#246101 — drharris, Aug 11 '11 at 15:14
A `Foo` simply *isn't* a `Foo`, and can't be made to be so. You haven't said what you're trying to achieve, which makes it very hard to help you towards a solution. — Jon Skeet, Aug 11 '11 at 15:16
@Jon: The real example is substantially more complex, but this simple code I have provided is the bare bones of the problem. It all comes down to using generics to represent a base type, and those classes perform operations on those base types and NEVER need to downcast them, so the typical danger in this is moot since I will not be downcasting IA to an A (or a B, or C, or whatever it is). — void.pointer, Aug 11 '11 at 15:26
@Robert: But without seeing the code within Foo, we can't tell anything about the safety involved, or the best way of working around it. — Jon Skeet, Aug 11 '11 at 16:10

score 3 · Accepted Answer · edited May 21 '19 at 21:54

3

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>

edited May 21 '19 at 21:54

Servy

202,030
26
332
449

answered Aug 11 '11 at 15:20

CodesInChaos

106,488
23
218
262

Boris Modylevsky · Answer 2 · 2011-08-11T15:22:35.233

1

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>;
        }
    }

edited Aug 11 '11 at 15:22

answered Aug 11 '11 at 15:15

Boris Modylevsky

3,029
1
26
42

score 1 · Answer 3 · answered Aug 11 '11 at 15:46

1

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.

answered Aug 11 '11 at 15:46

Joel C

5,547
1
21
31

score 0 · Answer 4 · answered May 11 '12 at 04:58

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...

Cannot cast between generic types

4 Answers4

Linked

Related