상속 계층 구조를 사용하는 간단한 예는 다음과 같습니다.

간단한 클래스 계층이 주어지면 :

그리고 코드에서 :

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

불일치 (예 : 또는 키워드로 장식 되지 않은 일반 유형 매개 변수 )inout

겉보기에는 이와 같은 방법

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있어야 하는 컬렉션 (IList를 구현하는) 만 허용 합니다 LifeForm.

의 메소드 구현 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<>의 서브 클래스의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“대부분의”에있을 수 Action<Zebra>의 수퍼 미만 유도는 Zebra도 가능하다.

처음에는 직관적이지 않을 수도 있지만 (예 : ?를 Action<object>요구하는 매개 변수로 전달 하는 방법 Action<Zebra>) 단계를 풀면 호출 된 함수 ( PerformZebraAction) 자체가 데이터 전달 (이 경우 Zebra인스턴스)을 담당합니다. )를 함수에-데이터가 호출 코드에서 나오지 않습니다.

이러한 방식으로 고차 함수를 사용하는 역 접근 방식 때문에 함수 Action가 호출 될 때 함수 자체가 덜 파생 된 유형을 사용하더라도 함수 Zebra에 대해 호출되는 것이 더 파생 된 인스턴스입니다 zebraAction(파라미터로 전달됨).

답변

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>'
}

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");
}

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;
}