C#协方差结构理解？

Question

• 假设

  A 级 { }

  B 类：A { }

泛型类不支持协方差。

意思-我们不能这样做：

MyConverter<B> x1= new MyConverter<B>();
MyConverter<A> x2= x1;  

很好理解。

根据我的阅读 - 我知道协方差将可用：

“如果您使用在 Generic Class 上实现的支持 Generic Interface - 这样就可以通过这些接口访问 T 类型对象实例”。

我只有一个问题。

我见过很多“转换器”类的例子，它是Stack 的一种形式。

但从未理解“如果我只想使用 A 的引用中的 1 个 B 实例怎么办？”

所以我尝试了一些代码：

创建B对象+值--->为B使用通用转换器---> 使用协方差流来获取它的A 参考---> 现在你可以使用它了 作为 A 或作为 B。

我的问题：

这是正确的做法吗（仅对 1 个对象使用协方差）？

附言 代码工作正常，编译正常。 http://i.stack.imgur.com/PJ6QO.png

我最近一直在询问/阅读很多关于这个主题的内容 - 我深入研究事物以便尽我所能理解它们。

Answer 1

您的代码可以编译并且可以工作，那么它“正确”吗？我想是的！

但是，只有一个元素的堆栈并不是很有趣；那不是真正的堆栈。让我们考虑一下如何制作真正的协变和逆变堆栈。

interface IPush<in T> { void Push(T item); }
interface IPop<out T> { T Pop(); }
class Stack<T> : IPush<T>, IPop<T>
{
    private class Link
    {
        public T Item { get; private set; }
        public Link Next { get; private set; }
        public Link(T item, Link next) { this.Item = item; this.Next = next; }
    }

    private Link head;
    public Stack() { this.head = null; }

    public void Push(T item)
    {
        this.head = new Link(item, this.head);
    }

    public T Pop()
    {
        if (this.head == null) throw new InvalidOperationException();
        T value = this.head.Item;
        this.head = this.head.Next;
        return value;
    }
}

现在您可以将堆栈协变地用于弹出，逆变器用于推送：

Stack<Mammal> mammals = new Stack<Mammal>();
IPop<Animal> animals = mammals;
IPush<Giraffe> giraffes = mammals;
IPush<Tiger> tigers = mammals;
giraffes.Push(new Giraffe());
tigers.Push(new Tiger());
System.Console.WriteLine(animals.Pop()); // Tiger
System.Console.WriteLine(animals.Pop()); // Giraffe

如果我只想从 A 的引用中使用 B 的一个实例怎么办？

您的问题是“如果我想使用 Tiger 但我有一个 Animal 参考怎么办？”答案是“你不能”，因为动物可能不是老虎！如果你想测试对 Animal 的引用是否真的是老虎，那么说：

Tiger tiger = myAnimal as Tiger;
if (tiger != null) ...

或

if (myAnimal is Tiger) ...

如果你想把C<B>类转换成C<A>呢？

这是不可能的。那里没有参考转换。 C# 4 中唯一的协变和逆变引用转换是在泛型接口和泛型委托上，使用引用类型作为类型参数构造。泛型类和结构不能协变或逆变使用。你能做的最好的事情就是让类实现一个变体接口。

Answer 2

看起来您使用转换器只是为了获取指向B 类型对象的A 类型的引用。有一种更简单的方法可以做到这一点，称为强制转换：

B b = new B();
A a = (A)b;

实际上，由于 A 是 B 的超类，所以转换是隐式的：

B b = new B();
A a = b;

您的程序可能是：

class Program
{
    static void Main(string[] args)
    {
        B b = new B { b1 = 22222 };
        A a = b;
        Console.WriteLine(a.a1);
        Console.WriteLine(((B)a).b1);
    }
}

Answer 3

IPushable<B> x1 = new MyConverter<B>();
x1.Set(b);
// I believe this is valid.
IPoppable<A> final = x2;

您可以在 this blog 上找到一些很好的示例和说明。