IComparer 和 IEqualityComparer 接口中逆变的好处

On the msdn页面 http://msdn.microsoft.com/en-us/library/dd465120.aspx关于逆变，我发现一个非常有趣的例子，它显示了“IComparer 中逆变的好处”

首先，他们使用相当奇怪的基类和派生类：

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class Employee : Person { }

我已经可以说这是一个糟糕的例子，因为没有任何类会仅仅继承基类而不至少添加一些自己的东西。

然后他们创建一个简单的 IEqualityComparer 类

class PersonComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {            
        ..
    }
    public int GetHashCode(Person person)
    {
       ..
    }
}

接下来是有问题的例子。

List<Employee> employees = new List<Employee> {
               new Employee() {FirstName = "Michael", LastName = "Alexander"},
               new Employee() {FirstName = "Jeff", LastName = "Price"}
            };

IEnumerable<Employee> noduplicates = 
employees.Distinct<Employee>(new PersonComparer());

现在我的问题 - 首先在这种情况下 Employee 是一个不需要的类，它确实可以在这种情况下使用 PersonComparer 因为它实际上只是一个 person 类！

然而在现实世界中Employee将至少有一个新字段，比方说JobTitle。鉴于很明显，当我们想要不同的员工时，我们需要考虑 JobTitle 字段进行比较，并且很明显，逆变比较器（例如人员比较器）不适合该工作，因为它无法知道任何新成员员工已定义。

当然，现在任何语言功能，即使是非常奇怪的功能，都可以有其用途，即使它在某些情况下不合逻辑，但在这种情况下，我认为它不会经常成为默认行为。事实上，在我看来，我们有点破坏了类型安全，当一个方法需要 Employee 比较器时，我们实际上可以放入一个人甚至对象比较器，并且它会毫无问题地编译。虽然很难想象我们的默认场景会将 Employee 视为一个对象……或基本的 Person。

那么对于这些​​接口来说，默认值真的是一个很好的逆变吗？

EDIT:我明白了什么是逆变和协变。我问为什么那些比较接口在默认情况下被更改为逆变。

逆变的定义如下。一张地图F从类型到类型的映射T to F<T>是逆变的T如果每当U and V是类型，使得每个类型的对象U可以分配给类型的变量V, 每个类型的对象F<V>可以分配给类型的变量F<U> (F反转赋值兼容性）。

特别是，如果T -> IComparer<T>然后注意类型变量IComparer<Derived>可以接收一个对象实现IComparer<Base>。这就是逆变。

我们这么说的原因IComparer<T>是逆变的T是因为你可以说

class SomeAnimalComparer  : IComparer<Animal> { // details elided }

进而：

IComparer<Cat> catComparer = new SomeAnimalComparer();

编辑：你说：

我明白了什么是逆变和协变。我问为什么那些比较接口在默认情况下被更改为逆变。

改变了？我是说，IComparer<T>是“自然”逆变的。的定义IComparer<T> is:

 public interface IComparer<T> {
     int Compare(T x, T y);
 }

注意T仅出现在该界面的“in”位置。也就是说，没有返回实例的方法T. Any这样的接口“自然”是逆变的T.

鉴于此，您有什么理由不想使其逆变呢？如果您有一个知道如何比较实例的对象U, and V赋值是否兼容U，为什么你不应该能够将此对象视为知道如何比较实例的对象V？这就是逆变所允许的。

在逆变之前，您必须换行：

 class ContravarianceWrapperForIComparer<U, V> : IComparer<V> where V : U {
      private readonly IComparer<U> comparer;
      public ContravarianceWrapperForIComparer(IComparer<U> comparer) {
          this.comparer = comparer;
      }
      public int Compare(V x, V y) { return this.comparer.Compare(x, y); }
 }

然后你可以说

class SomeUComparer : IComparer<U> { // details elided }

IComparer<U> someUComparer = new SomeUComparer();
IComparer<V> vComparer = 
    new ContravarianceWrapperForIComparer<U, V>(someUComparer);

逆变允许您跳过这些咒语，只需说

IComparer<V> vComparer = someUComparer;

当然，以上只是当V : U。通过逆变，您可以随时执行此操作U赋值是否兼容V.