Question

我正在尝试这样做：

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

但是，从Foo<A>到Foo<IA>的强制转换无法编译。我记得在List<T>之间投射时看到这样的协方差问题，但我认为它不适用于这样的简单泛型。

让这个演员阵容工作有什么好处？我该如何解决这个问题？

Answer 1

所有通用类都是不变的。另一方面，接口（和代表）可以支持协方差和反方差，但仅限于可以安全使用的情况。他们需要明确选择加入。

例如，通过IFoo<out T>或IFoo<in T>

Answer 2

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

Answer 3

这些类对这些基类型执行操作，而且从不需要向下转换它们

那你为什么要开始Foo<A>？将其声明为Foo<IA>并将A添加到其中。

Answer 4

对不起，这是在java中，但你可以这样做：

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

这并不能完全解决问题，但是你可以在不知道Beta的情况下至少可以访问所有的Alpha方法......

不能在泛型类型之间转换

4 个答案: