Контравариантность объяснена

ковариация и Контравариация-это не то, что вы можете наблюдать при создании экземпляров классов. Таким образом, неправильно говорить об одном из них, глядя на простой экземпляр класса, как в вашем примере: Animal someAnimal = new Giraffe(); //covariant operation

эти термины не классифицируют операции. термины ковариация, Контравариация и инвариантность описывают отношения между определенными аспекты классов и их подклассов.

Ковариационный означает, что аспект меняется аналогично направлению наследования. Контравариантность означает, что аспект меняется в противоположную сторону от направления наследования. Инвариантность означает, что аспект не изменяется от класса к его подклассу(подклассам).

мы вообще рассматриваем следующие аспекты, когда говорим о ков., Contrav. и инв.:

• методы
  • типы параметров
  • типы возврата
  • другие аспекты, связанные с подписью, такие как генерировать исключения.
• дженериков

давайте посмотрим на несколько примеров для лучшего понимания терминов.

class T
class T2 extends T
 
//Covariance: The return types of the method "method" have the same
//direction of inheritance as the classes A and B.
class A { T method() }
class B extends A { T2 method() }
 
//Contravariance: The parameter types of the method "method" have a
//direction of inheritance opposite to the one of the classes A and B.
class A { method(T2 t) }
class B { method(T t) }

В обоих случаях" метод " переопределяется! Далее, приведенные выше примеры являются только юридические события Cov. и Contrav. в объектно-ориентированных языках.:

• ковариация-типы возврата и операторы исключения
• Контравариантность - Вход параметры
• инвариантность - входные и выходные параметры

давайте посмотрим на некоторые встречные примеры, чтобы лучше понять приведенный выше список:

//Covariance of return types: OK
class Monkey { Monkey clone() }
class Human extends Monkey { Human clone() }
 
Monkey m = new Human();
Monkey m2 = m.clone(); //You get a Human instance, which is ok,
                       //since a Human is-a Monkey.
 
//Contravariance of return types: NOT OK
class Fruit
class Orange extends Fruit
 
class KitchenRobot { Orange make() }
class Mixer extends KitchenRobot { Fruit make() }
 
KitchenRobot kr = new Mixer();
Orange o = kr.make(); //Orange expected, but got a fruit (too general!)
 
//Contravariance of parameter types: OK
class Food
class FastFood extends Food
 
class Person { eat(FastFood food) }
class FatPerson extends Person { eat(Food food) }
 
Person p = new FatPerson();
p.eat(new FastFood()); //No problem: FastFood is-a Food, which FatPerson eats.
 
//Covariance of parameter types: NOT OK
class Person { eat(Food food) }
class FatPerson extends Person { eat(FastFood food) }
 
Person p = new FatPerson();
p.eat(new Food()); //Oops! FastFood expected, but got Food (too general).

эта тема настолько сложная, что я мог бы продолжать очень долго. Я советую вам проверить ков. и Contrav. дженериков самостоятельно. Кроме того, вам нужно знать, как работает динамическая привязка, чтобы полностью понять примеры (какие методы точно называются).

условия возникли из принципа подстановки Лискова, который определяет необходимые критерии для моделирования типа данных как подтипа другого. Вы также можете захотеть исследовать его.

Я понимаю, что это не отношения подтипов, которые являются Co/contra-variant, а скорее операции (или проекции) между этими типами (такими как делегаты и дженерики). Таким образом:

Animal someAnimal = new Giraffe();

не является ко-вариантом, а скорее это просто совместимость назначения, поскольку тип жирафа "меньше" типа животного. Co / contra-дисперсия становится проблемой, когда у вас есть некоторая проекция между этими типами, например:

IEnumerable<Giraffe> giraffes = new[] { new Giraffe(); };
IEnumerable<Animal> animals = giraffes;

это недопустимо в C#3, однако это должно быть возможно, так как последовательность жирафов-это последовательность животных. Проекция T -> IEnumerable<T> сохраняет "направление" отношения типа с Giraffe < Animal и IEnumerable<Giraffe> < IEnumerable<Animal> (обратите внимание, что для назначения требуется, чтобы тип левой стороны был по крайней мере таким же широким, как и правый).

Contra-дисперсия меняет отношение типа:

Action<Animal> printAnimal = a => {System.Console.WriteLine(a.Name)};
Action<Giraffe> printGiraffe = printAnimal;

это также не законно в C#3, но это должно быть, так как любое действие, принимающее животное, может справиться с тем, чтобы пройти жираф. Однако, поскольку Giraffe < Animal и Action<Animal> < Action<Giraffe> проекция изменила тип отношений. Это законно в C#4.

Итак, чтобы ответить на вопросы в вашем примере:

//the following are neither covariant or contravariant - since there is no projection this is just assignment compatibility
Mammal mammal1 = new Giraffe();
Mammal mammal2 = new Dolphin();

//compare is contravariant with respect to its arguments - 
//the delegate assignment is legal in C#4 but not in C#3
Func<Mammal, Mammal, bool> compare = (m1, m2) => //whatever
Func<Giraffe, Dolphin, bool> c2 = compare;

//always invalid - right hand side must be smaller or equal to left hand side
Mammal mammal1 = new Animal();

//not valid for same reason - animal cannot be assigned to Mammal
Compare(new Animal(), new Dolphin());

(редактировать в ответ на комментарии)

эта статья MSDN по теме описал ковариантность и контравариантность, так как это относится к соответствующей функции к делегату. Переменная типа делегата:

public delegate bool Compare(Giraffe giraffe, Dolphin dolphin);

может (из-за контравариантности) быть заполнен функцией:

public bool Compare(Mammal mammal1, Mammal mammal2)
{
    return String.Compare(mammal1.Name, mammal2.Name) == 0;
}

из моего чтения это не связано с вызовом функции напрямую, а с сопоставлением функций с делегатами. Я не уверен, что это возможно. сводится к уровню, который вы демонстрируете, при этом отдельные переменные или назначения объектов являются контравариантными или ковариантными. Но назначение делегата использует контравариантность или ковариацию таким образом, который имеет смысл для меня в соответствии со связанной статьей. Поскольку подпись делегата содержит больше производных типов, чем фактический экземпляр, это называется "contravariance", что-то отдельное от "ковариации", в котором возвращаемый тип делегата является менее производным, чем фактический пример.

посмотрите на это так: Если у меня есть функция func, которая имеет дело с подтипом млекопитающего, формы млекопитающее m = Func(g (млекопитающее)), Я могу поменять млекопитающее с чем-то включает в себя млекопитающие, который здесь является основой животные.

с точки зрения спортивной аналогии, чтобы понять приведенное ниже изображение, вы можете поймать мяч голыми руками, как в крикете, но также возможно (и проще) поймать мяч с помощью бейсбола перчатки.

то, что вы видите слева-это ковариация, то, что вы видите внутри часть параметра контрвариантности.

вы можете задаться вопросом: "почему левая зеленая кривая больше красной кривой? Разве подтип, который обычно делает больше, чем базовый, не должен быть больше?" Ответ: Нет. Размер скобки обозначает разнообразие разрешенных объектов, например диаграмму Венна. Набор млекопитающих меньше, чем набор животных. Аналогично, F (млекопитающее) меньше f(животное), поскольку оно поддерживает только меньший набор объектов. (я.электронная функция, которая обрабатывает млекопитающих не обрабатывать всех животных, но функция, которая обрабатывает животные всегда могут справиться с млекопитающими). Следовательно, отношение инвертируется, поскольку f (животное) может быть передано вместо f(млекопитающее), что делает его контравариантным.