在逆变位置使用协变类型会导致哪些违规行为？

Question

考虑具有协变类型T 的接口。我正在研究使用T 的该接口的所有派生类中的属性都是只读的，如果是泛型类则为协变的情况。假设这个接口定义了一个使用T 作为参数类型的方法。它允许哪些违规行为？

例如，考虑：

interface ICov<out T> {
  void maybe_safe_set(T v);
}
class ImplCov<T> : ICov<T> {
  public readonly T a;
  public readonly IEnumerable<T> b;
  public readonly IEnumerable<IEnumerable<T>> c;
  // public readonly IList<T> d; // but not this

  public void maybe_safe_set(T v) {
    // do things that can't modify state: the type of our 
    // readonly, covariant IEnumerable members can't be modified
  }
}

在 C# 中，我收到错误：

无效方差：类型参数“T”必须在“ConsoleApplication.ICov.maybe_safe_set(T)”上逆变有效。 'T' 是协变的。

这并不奇怪，因为T 处于逆变位置。但是，我想不出这里可能发生的违规行为。

Answer 1

你：

interface ICov<out T>    // BAD!
{
  void maybe_safe_set(T v);
}

问题来了。像往常一样，我们有：

class Animal { /* ... */ }
class Dog : Animal { public void Woof() { }  /* ... */ }
class Cat : Animal { /* ... */ }

然后考虑：

class Impl : ICov<Dog>
{
  public void maybe_safe_set(Dog v)
  {
    v.Woof(); // our 'Dog' v can really bark
  }
}

编译得很好。

然后这个：

var impl1 = new Impl();
ICov<Dog> impl2 = impl1;    // OK, implements that
ICov<Animal> impl3 = impl2; // OK, you claim interface is covariant ('out')! 

var badAnimal = new Cat();
impl3.maybe_safe_set(badAnimal);  // ICov<Animal> takes in Animal, right?

// oh my God, you mad a 'Cat' bark!

当人们询问协变和逆变时，总是同样的例子。

Answer 2

我不了解其他人，但我也觉得这些东西很混乱。为了理解它，我需要创建一个示例来查看编译器正在防止哪些违规行为。

我们先看看没有接口中的方法。这都是有效的：

interface ICov<out T> {}

public class BaseClass { }
public class InheritedClass: BaseClass { } 

ICov<BaseClass> x = new MyCov<InheritedClass>();

因为T 是协变的，所以ICov<BaseClass> 类型的变量可以引用MyCov<T> 的实例，其中T 派生自BaseClass。

现在，如果我们可以在接口中添加一个对 T 类型进行操作的方法（编译器阻止了什么？）

interface ICov<out T>
{
    List<T> ListOfT { get; set; }
    // ^^^ compiler doesn't like this.
}

public class BaseClass { }
public class InheritedClass: BaseClass { } 

public class MyCov<T> : ICov<T> {
    public List<T> ListOfT { get; set; } = new List<T>();
}

现在我们可以确切地看到这会产生的问题：

var usesInheritedClass = new MyCov<InheritedClass>();

//This is legal, because the type parameter in ICov is covariant
ICov<BaseClass> usesBaseClass = usesInheritedClass;

//Here's where it goes bad.
usesBaseClass.ListOfT.Add(new BaseClass());

usesInheritedClass 包含InheritedClass 的列表。但是因为我可以将其转换为ICov<BaseClass>，所以现在我可以将BaseClass 添加到InheritedClass 的列表中，这是行不通的。

因此，尽管编译器错误令人困惑，但它在正确的位置。它不会尝试整理和修复我的下游错误。它通过防止这些类型可能混淆的情况来完全防止这些下游错误。