协方差和逆变现实世界的例子

Question

我在理解如何在现实世界中使用协方差和逆变时遇到一些麻烦。

到目前为止，我见过的唯一例子是同样的旧数组示例。

object[] objectArray = new string[] { "string 1", "string 2" };

很高兴看到一个允许我在开发过程中使用它的例子，如果我能看到它在其他地方使用的话。

Answer 1

// Contravariance
interface IGobbler<in T> {
    void gobble(T t);
}

// Since a QuadrupedGobbler can gobble any four-footed
// creature, it is OK to treat it as a donkey gobbler.
IGobbler<Donkey> dg = new QuadrupedGobbler();
dg.gobble(MyDonkey());

// Covariance
interface ISpewer<out T> {
    T spew();
}

// A MouseSpewer obviously spews rodents (all mice are
// rodents), so we can treat it as a rodent spewer.
ISpewer<Rodent> rs = new MouseSpewer();
Rodent r = rs.spew();

为了完整......

// Invariance
interface IHat<T> {
    void hide(T t);
    T pull();
}

// A RabbitHat…
IHat<Rabbit> rHat = RabbitHat();

// …cannot be treated covariantly as a mammal hat…
IHat<Mammal> mHat = rHat;      // Compiler error
// …because…
mHat.hide(new Dolphin());      // Hide a dolphin in a rabbit hat??

// It also cannot be treated contravariantly as a cottontail hat…
IHat<CottonTail> cHat = rHat;  // Compiler error
// …because…
rHat.hide(new MarshRabbit());
cHat.pull();                   // Pull a marsh rabbit out of a cottontail hat??

Answer 2

这是我放在一起帮助我理解差异的原因

--with-mcrypt=/home/mybin/lib

tldr

--with-mcrypt=/home/mybin

Answer 3

假设你有一个类Person和一个派生自它的类，教师。您有一些以IEnumerable<Person>为参数的操作。在您的School类中，您有一个返回IEnumerable<Teacher>的方法。协方差允许您直接将该结果用于采用IEnumerable<Person>的方法，将更多派生类型替换为较少派生（更通用）类型。反直觉，反直觉，允许您使用更通用的类型，其中指定更多派生类型。

另见Covariance and Contravariance in Generics on MSDN。

<强>类：

public class Person 
{
     public string Name { get; set; }
} 

public class Teacher : Person { } 

public class MailingList
{
    public void Add(IEnumerable<out Person> people) { ... }
}

public class School
{
    public IEnumerable<Teacher> GetTeachers() { ... }
}

public class PersonNameComparer : IComparer<Person>
{
    public int Compare(Person a, Person b) 
    { 
        if (a == null) return b == null ? 0 : -1;
        return b == null ? 1 : Compare(a,b);
    }

    private int Compare(string a, string b)
    {
        if (a == null) return b == null ? 0 : -1;
        return b == null ? 1 : a.CompareTo(b);
    }
}

<强>用法：

var teachers = school.GetTeachers();
var mailingList = new MailingList();

// Add() is covariant, we can use a more derived type
mailingList.Add(teachers);

// the Set<T> constructor uses a contravariant interface, IComparer<T>,
// we can use a more generic type than required.
// See https://msdn.microsoft.com/en-us/library/8ehhxeaf.aspx for declaration syntax
var teacherSet = new SortedSet<Teachers>(teachers, new PersonNameComparer());

Answer 4

in和out关键字使用通用参数控制编译器的接口和委托的转换规则：

interface IInvariant<T> {
    // This interface can not be implicitly cast AT ALL
    // Used for non-readonly collections
    IList<T> GetList { get; }
    // Used when T is used as both argument *and* return type
    T Method(T argument);
}//interface

interface ICovariant<out T> {
    // This interface can be implicitly cast to LESS DERIVED (upcasting)
    // Used for readonly collections
    IEnumerable<T> GetList { get; }
    // Used when T is used as return type
    T Method();
}//interface

interface IContravariant<in T> {
    // This interface can be implicitly cast to MORE DERIVED (downcasting)
    // Usually means T is used as argument
    void Method(T argument);
}//interface

class Casting {

    IInvariant<Animal> invariantAnimal;
    ICovariant<Animal> covariantAnimal;
    IContravariant<Animal> contravariantAnimal;

    IInvariant<Fish> invariantFish;
    ICovariant<Fish> covariantFish;
    IContravariant<Fish> contravariantFish;

    public void Go() {

        // NOT ALLOWED invariants do *not* allow implicit casting:
        invariantAnimal = invariantFish; 
        invariantFish = invariantAnimal; // NOT ALLOWED

        // ALLOWED covariants *allow* implicit upcasting:
        covariantAnimal = covariantFish; 
        // NOT ALLOWED covariants do *not* allow implicit downcasting:
        covariantFish = covariantAnimal; 

        // NOT ALLOWED contravariants do *not* allow implicit upcasting:
        contravariantAnimal = contravariantFish; 
        // ALLOWED contravariants *allow* implicit downcasting
        contravariantFish = contravariantAnimal; 

    }//method

}//class

// .NET Framework Examples:
public interface IList<T> : ICollection<T>, IEnumerable<T>, IEnumerable { }
public interface IEnumerable<out T> : IEnumerable { }


class Delegates {

    // When T is used as both "in" (argument) and "out" (return value)
    delegate T Invariant<T>(T argument);

    // When T is used as "out" (return value) only
    delegate T Covariant<out T>();

    // When T is used as "in" (argument) only
    delegate void Contravariant<in T>(T argument);

    // Confusing
    delegate T CovariantBoth<out T>(T argument);

    // Confusing
    delegate T ContravariantBoth<in T>(T argument);

    // From .NET Framework:
    public delegate void Action<in T>(T obj);
    public delegate TResult Func<in T, out TResult>(T arg);

}//class

Answer 5

class A {}
class B : A {}

public void SomeFunction()
{
    var someListOfB = new List<B>();
    someListOfB.Add(new B());
    someListOfB.Add(new B());
    someListOfB.Add(new B());
    SomeFunctionThatTakesA(someListOfB);
}

public void SomeFunctionThatTakesA(IEnumerable<A> input)
{
    // Before C# 4, you couldn't pass in List<B>:
    // cannot convert from
    // 'System.Collections.Generic.List<ConsoleApplication1.B>' to
    // 'System.Collections.Generic.IEnumerable<ConsoleApplication1.A>'
}

基本上每当你有一个带有一个类型的Enumerable的函数时，如果没有显式地转换它，你就无法传入一个派生类型的Enumerable。

只是为了警告你一个陷阱：

var ListOfB = new List<B>();
if(ListOfB is IEnumerable<A>)
{
    // In C# 4, this branch will
    // execute...
    Console.Write("It is A");
}
else if (ListOfB is IEnumerable<B>)
{
    // ...but in C# 3 and earlier,
    // this one will execute instead.
    Console.Write("It is B");
}

无论如何这都是可怕的代码，但它确实存在，如果使用这样的结构，C＃4中不断变化的行为可能会引入微妙且难以发现的错误。

Answer 6

这是一个使用继承层次结构的简单示例。

给出简单的类层次结构：

在代码中：

public abstract class LifeForm  { }
public abstract class Animal : LifeForm { }
public class Giraffe : Animal { }
public class Zebra : Animal { }

不变性（即通用类型参数 * not * 使用in或out个关键字修饰）

貌似，这样的方法

public static void PrintLifeForms(IList<LifeForm> lifeForms)
{
    foreach (var lifeForm in lifeForms)
    {
        Console.WriteLine(lifeForm.GetType().ToString());
    }
}

...应该接受异构集合:(它确实如此）

var myAnimals = new List<LifeForm>
{
    new Giraffe(),
    new Zebra()
};
PrintLifeForms(myAnimals); // Giraffe, Zebra

但是，传递更多派生类型的集合会失败！

var myGiraffes = new List<Giraffe>
{
    new Giraffe(), // "Jerry"
    new Giraffe() // "Melman"
};
PrintLifeForms(myGiraffes); // Compile Error!

  

cannot convert from 'System.Collections.Generic.List<Giraffe>' to 'System.Collections.Generic.IList<LifeForm>'

为什么呢？因为通用参数IList<LifeForm>不是协变的 -  IList<T>是不变的，因此IList<LifeForm>只接受参数化类型T必须为LifeForm的集合（实现IList）。

如果PrintLifeForms的方法实现是恶意的（但具有相同的方法签名），编译器阻止传递List<Giraffe>的原因变得显而易见：

 public static void PrintLifeForms(IList<LifeForm> lifeForms)
 {
     lifeForms.Add(new Zebra());
 }

由于IList允许添加或删除元素，因此LifeForm的任何子类都可以添加到参数lifeForms中，并且会违反传递给它的任何派生类型集合的类型方法。 （此处，恶意方法会尝试将Zebra添加到var myGiraffes）。幸运的是，编译器可以保护我们免受这种危险。

协方差（通用参数化类型用out修饰）

协方差广泛用于不可变集合（即无法在集合中添加或删除新元素的地方）

上述示例的解决方案是确保使用协变泛型集合类型，例如， IEnumerable（定义为IEnumerable<out T>）。 IEnumerable没有方法可以更改为集合，并且由于out协方差，任何子类型为LifeForm的集合现在都可以传递给方法：

public static void PrintLifeForms(IEnumerable<LifeForm> lifeForms)
{
    foreach (var lifeForm in lifeForms)
    {
        Console.WriteLine(lifeForm.GetType().ToString());
    }
}

现在可以使用PrintLifeForms，Zebras以及Giraffes

的任何子类的任何IEnumerable<>来调用{p> LifeForm

反差异性（通用参数化类型用in修饰）

当函数作为参数传递时，经常使用逆变量。

这是一个函数的示例，它以Action<Zebra>作为参数，并在已知的Zebra实例上调用它：

public void PerformZebraAction(Action<Zebra> zebraAction)
{
    var zebra = new Zebra();
    zebraAction(zebra);
}

正如预期的那样，这很好用：

var myAction = new Action<Zebra>(z => Console.WriteLine("I'm a zebra"));
PerformZebraAction(myAction); // I'm a zebra

直观地说，这将失败：

var myAction = new Action<Giraffe>(g => Console.WriteLine("I'm a giraffe"));
PerformZebraAction(myAction); 

  

cannot convert from 'System.Action<Giraffe>' to 'System.Action<Zebra>'

然而，这成功了

var myAction = new Action<Animal>(a => Console.WriteLine("I'm an animal"));
PerformZebraAction(myAction); // I'm an animal

甚至这也成功了：

var myAction = new Action<object>(a => Console.WriteLine("I'm an amoeba"));
PerformZebraAction(myAction); // I'm an amoeba

为什么呢？因为Action被定义为Action<in T>，即它是contravariant，这意味着对于Action<Zebra> myAction，myAction可能位于＆＃34;大多数＆＃34}。 Action<Zebra>，但Zebra的派生超类也可以接受。

虽然起初这可能不直观（例如，如何将Action<object>作为需要Action<Zebra>的参数传递？），如果解压步骤，您会注意到被调用的函数（ PerformZebraAction）本身负责将数据（在本例中为Zebra实例）传递给函数 - 数据不会来自调用代码。

由于以这种方式使用高阶函数的反向方法，在调用Action时，它是针对Zebra调用的派生更多的zebraAction实例function（作为参数传递），尽管函数本身使用较少派生的类型。

Answer 7

Contravariance

在现实世界中，您总是可以使用动物收容所代替兔子收容所，因为每次动物收容所收容兔子时，它都是动物。但是，如果您使用兔子庇护所而不是动物庇护所，其工作人员可能会被老虎吞噬。

在代码中，这意味着如果您有IShelter<Animal> animals，则可以简单地写IShelter<Rabbit> rabbits = animals 如果，您承诺并在{{1}中使用T }仅用作方法参数，例如：

IShelter<T>

并用更通用的商品代替，即减少差异或引入相反差异。

协方差

在现实世界中，您总是可以使用兔子供应商来代替动物供应商，因为兔子供应商每次给您的兔子都是动物。但是，如果您使用动物供应商而不是兔子供应商，则会被老虎吃掉。

在代码中，这意味着如果您有public class Contravariance { public class Animal { } public class Rabbit : Animal { } public interface IShelter<in T> { void Host(T thing); } public void NoCompileErrors() { IShelter<Animal> animals = null; IShelter<Rabbit> rabbits = null; rabbits = animals; } } ，则可以简单地写ISupply<Rabbit> rabbits。如果，您承诺并在{{1}中使用ISupply<Animal> animals = rabbits }仅作为方法的返回值，如下所示：

T

，然后用衍生性更高的商品代替，即增加差异或引入 co <​​/ strong>差异。

总而言之，这只是您发出的可编译时检查保证，即您将以某种方式对待泛型类型以确保类型安全，而不会被任何人吃掉。

您可能想给this读一本书，以解决这个问题。

Answer 8

来自MSDN

  

以下代码示例显示了协方差和逆变支持   方法组

static object GetObject() { return null; }
static void SetObject(object obj) { }

static string GetString() { return ""; }
static void SetString(string str) { }

static void Test()
{
    // Covariance. A delegate specifies a return type as object, 
    // but you can assign a method that returns a string.
    Func<object> del = GetString;

    // Contravariance. A delegate specifies a parameter type as string, 
    // but you can assign a method that takes an object.
    Action<string> del2 = SetObject;
}

Answer 9

转换器委托帮助我可视化两个概念：

delegate TOutput Converter<in TInput, out TOutput>(TInput input);

TOutput表示协方差，其中方法返回更具体的类型。

TInput代表逆变，其中方法传递不太具体的类型。

public class Dog { public string Name { get; set; } }
public class Poodle : Dog { public void DoBackflip(){ System.Console.WriteLine("2nd smartest breed - woof!"); } }

public static Poodle ConvertDogToPoodle(Dog dog)
{
    return new Poodle() { Name = dog.Name };
}

List<Dog> dogs = new List<Dog>() { new Dog { Name = "Truffles" }, new Dog { Name = "Fuzzball" } };
List<Poodle> poodles = dogs.ConvertAll(new Converter<Dog, Poodle>(ConvertDogToPoodle));
poodles[0].DoBackflip();