[C#] 공분산과 역 분산의 차이

문제는 “공분산과 공분산의 차이점은 무엇입니까?”입니다.

공분산 및 반공 분산은 집합의 한 멤버를 다른 멤버와 연결하는 매핑 함수의 속성입니다 . 보다 구체적으로, 맵핑은 그 세트에 대한 관계 와 관련하여 공변량 또는 반 변형 일 수있다 .

모든 C # 유형 집합의 다음 두 가지 하위 집합을 고려하십시오. 먼저:

{ Animal, 
  Tiger, 
  Fruit, 
  Banana }.

둘째, 이것은 분명히 관련이 있습니다.

{ IEnumerable<Animal>, 
  IEnumerable<Tiger>, 
  IEnumerable<Fruit>, 
  IEnumerable<Banana> }

가 사상 두 번째 세트 첫 세트에서 작업을. 즉, 첫 번째 세트의 각 T에 대해 두 번째 세트의 해당 유형은 IEnumerable<T>입니다. 또는 간단히 말해서 매핑은 T → IE<T>입니다. 이것은 “가는 화살표”입니다.

지금까지 나와 함께?

이제 관계를 고려해 봅시다 . 가 할당 호환성 관계 첫 번째 세트의 유형 쌍 사이는. type의 값은 type Tiger의 변수에 할당 될 수 Animal있으므로 이러한 유형은 “할당 지정”이라고합니다. 더 짧은 X형식으로 Y” 유형의 값을 유형 의 변수에 할당 할 수 있습니다 “라고 작성하겠습니다 X ⇒ Y. 이것은 “뚱뚱한 화살표”입니다.

첫 번째 하위 집합에는 다음과 같은 모든 할당 호환성 관계가 있습니다.

Tiger  ⇒ Tiger
Tiger  ⇒ Animal
Animal ⇒ Animal
Banana ⇒ Banana
Banana ⇒ Fruit
Fruit  ⇒ Fruit

특정 인터페이스의 공변량 할당 호환성을 지원하는 C # 4에서는 두 번째 세트의 유형 쌍간에 할당 호환성 관계가 있습니다.

IE<Tiger>  ⇒ IE<Tiger>
IE<Tiger>  ⇒ IE<Animal>
IE<Animal> ⇒ IE<Animal>
IE<Banana> ⇒ IE<Banana>
IE<Banana> ⇒ IE<Fruit>
IE<Fruit>  ⇒ IE<Fruit>

매핑 T → IE<T> 은 할당 호환성의 존재와 방향을 유지합니다 . 즉 X ⇒ Y, 그렇다면 IE<X> ⇒ IE<Y>.

뚱뚱한 화살표의 양쪽에 두 가지가 있으면 양쪽을 해당 얇은 화살표의 오른쪽에있는 것으로 바꿀 수 있습니다.

특정 관계에 대해이 속성을 갖는 매핑을 “공변량 매핑”이라고합니다. 이것은 일련의 동물이 필요한 곳에서 일련의 호랑이를 사용할 수 있지만 그 반대는 사실이 아닙니다. 일련의 호랑이가 필요한 곳에 일련의 동물을 반드시 사용할 수는 없습니다.

공분산입니다. 이제 모든 유형 세트의이 서브 세트를 고려하십시오.

{ IComparable<Tiger>, 
  IComparable<Animal>, 
  IComparable<Fruit>, 
  IComparable<Banana> }

이제 첫 번째 세트에서 세 번째 세트로의 맵핑이 있습니다 T → IC<T>.

C # 4에서 :

IC<Tiger>  ⇒ IC<Tiger>
IC<Animal> ⇒ IC<Tiger>     Backwards!
IC<Animal> ⇒ IC<Animal>
IC<Banana> ⇒ IC<Banana>
IC<Fruit>  ⇒ IC<Banana>     Backwards!
IC<Fruit>  ⇒ IC<Fruit>

즉, 매핑 T → IC<T>은 존재 를 유지하지만 할당 호환성 방향 을 반대로했습니다 . 즉 X ⇒ Y, 그렇다면 IC<X> ⇐ IC<Y>.

관계 를 유지하지만 반대로 하는 매핑을 반 변형 매핑 이라고합니다 .

다시 말하지만 이것은 분명해야합니다. 두 동물을 비교할 수있는 장치는 두 호랑이를 비교할 수 있지만 두 호랑이를 비교할 수있는 장치는 두 동물을 반드시 비교할 수는 없습니다.

이것이 C # 4의 공분산과 공분산의 차이입니다. 공분산 은 할당의 방향을 유지 합니다. 불균형은 반대로 됩니다.

답변

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

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();

class Flower {  }
class Rose: Flower { }
class Daisy: Flower { }

interface FlowerShop<out T> where T: Flower {
    T getFlower();
}

class RoseShop: FlowerShop<Rose> {
    public Rose getFlower() {
        return new Rose();
    }
}

class DaisyShop: FlowerShop<Daisy> {
    public Daisy getFlower() {
        return new Daisy();
    }
}

static FlowerShop<Flower> tellMeShopAddress() {
    return new RoseShop();
}

interface PrettyGirl<in TFavoriteFlower> where TFavoriteFlower: Flower {
    void takeGift(TFavoriteFlower flower);
}

class AnyFlowerLover: PrettyGirl<Flower> {
    public void takeGift(Flower flower) {
        Console.WriteLine("I like all flowers!");
    }
}

PrettyGirl<Rose> girlfriend = new AnyFlowerLover();
girlfriend.takeGift(new Rose());