제네릭의 공변성(Covariance) 및 반공변성(Contravariance)

‘공변성(Covariance)’과 ‘반공변성(Contravariance)’은 원래 지정된 것보다 더 많이 파생되거나(더 구체적인) 더 적게 파생된 형식(덜 구체적인)을 사용할 수 있는 능력을 지칭하는 용어입니다. 제네릭 형식 매개 변수는 더욱 유연하게 제네릭 형식을 할당하고 사용할 수 있도록 공변성과 반공변성을 지원합니다.

형식 시스템을 참조할 때 공변성(Covariance), 반공변성(Contravariance), 불변성의 정의는 다음과 같습니다. 이 예제에서는 Base 라는 기본 클래스와 Derived라는 파생 클래스가 있는 것으로 가정합니다.

  • Covariance

    원래 지정된 것보다 더 많이 파생된 형식을 사용할 수 있습니다.

    IEnumerable<Derived>의 인스턴스를 IEnumerable<Base> 형식의 변수에 할당할 수 있습니다.

  • Contravariance

    원래 지정된 것보다 더 제네릭한(덜 파생적인) 형식을 사용할 수 있습니다.

    Action<Base>의 인스턴스를 Action<Derived> 형식의 변수에 할당할 수 있습니다.

  • Invariance

    원래 지정된 형식만 사용할 수 있음을 의미합니다. 고정 제네릭 형식 매개 변수는 공변(covariant) 및 반공변(contravariant)이 아닙니다.

    List<Base>의 인스턴스를 List<Derived> 형식의 변수에 할당할 수 없고, 그 반대로도 할당할 수 없습니다.

다음 코드에 표시된 것처럼, 공변 형식 매개 변수를 사용하여 일반적인 다형성과 매우 비슷한 할당을 수행할 수 있습니다.

IEnumerable<Derived> d = new List<Derived>();
IEnumerable<Base> b = d;
Dim d As IEnumerable(Of Derived) = New List(Of Derived)
Dim b As IEnumerable(Of Base) = d

List<T> 클래스는 IEnumerable<T> 인터페이스를 구현하므로 List<Derived> (Visual Basic의 경우List(Of Derived) )는 IEnumerable<Derived>를 구현합니다. 나머지 작업은 공변 형식 매개 변수가 처리합니다.

그러나 반공변성은 직관적으로 이해하기가 어려울 수 있습니다. 다음 예제에서는 Action<Base> (Visual Basic의 경우Action(Of Base) ) 형식의 대리자를 만든 다음 이 대리자를 Action<Derived>형식의 변수에 할당합니다.

Action<Base> b = (target) => { Console.WriteLine(target.GetType().Name); };
Action<Derived> d = b;
d(new Derived());
Dim b As Action(Of Base) = Sub(target As Base)
                               Console.WriteLine(target.GetType().Name)
                           End Sub
Dim d As Action(Of Derived) = b
d(New Derived())

이는 순서가 뒤바뀐 것처럼 보이지만 실제로는 형식이 안전한 코드로서 문제 없이 컴파일 및 실행됩니다. 람다 식이 할당된 대리자와 일치하므로 Base 형식의 매개 변수 하나를 사용하고 반환 값이 없는 메서드를 정의할 수 있습니다. 결과로 얻은 대리자를 Action<Derived> 형식의 변수에 할당할 수 있습니다. T 대리자의 형식 매개 변수 Action<T> 가 반공변성을 지니기 때문입니다. T 에서 매개 변수 형식을 지정하므로 이는 형식이 안전한 코드입니다. Action<Base> 형식의 대리자를 Action<Derived>형식의 대리자인 것처럼 호출하는 경우 해당 인수가 Derived형식이어야 합니다. 메서드의 매개 변수가 Base형식이므로 이 인수를 내부 메서드에 항상 안전하게 전달할 수 있습니다.

일반적으로 공변 형식 매개 변수는 대리자의 반환 형식으로 사용할 수 있으며, 반공변 형식 매개 변수는 매개 변수 형식으로 사용할 수 있습니다. 인터페이스의 경우 공변 형식 매개 변수는 인터페이스 메서드의 반환 형식으로 사용할 수 있으며, 반공변 형식 매개 변수는 인터페이스 메서드의 매개 변수 형식으로 사용할 수 있습니다.

공변성(Covariance) 및 반공변성(Contravariance)을 전체적으로 차이 라고 합니다. 공변 또는 반공변 여부가 표시되지 않은 제네릭 형식 매개 변수를 고정(invariant) 매개 변수라고 합니다. 다음은 공용 언어 런타임의 가변성에 대한 간략한 설명입니다.

  • Variant 형식 매개 변수가 제네릭 인터페이스와 제네릭 대리자 형식에만 사용됩니다.

  • 제네릭 인터페이스 또는 제네릭 대리자 형식은 공변 및 반공변 형식 매개 변수를 둘 다 가질 수 있습니다.

  • 가변성은 참조 형식에만 적용되므로 variant 형식 매개 변수에 대한 값 형식을 지정하면 이 형식 매개 변수는 결과로 생성되는 형식에 대해 invariant가 됩니다.

  • 대리자 결합에는 가변성이 적용되지 않습니다. 즉, 두 대리자의 형식이 Action<Derived>Action<Base> (Visual Basic의 경우Action(Of Derived)Action(Of Base) )라고 할 때 결과의 형식이 안전하더라도 둘째 대리자를 첫째 대리자와 결합할 수 없습니다. 가변성을 통해 둘째 대리자를 Action<Derived>형식의 변수에 할당할 수 있지만, 대리자를 결합하기 위해서는 해당 형식이 정확하게 일치해야 합니다.

  • C# 9부터 공변 반환 형식이 지원됩니다. 재정의 메서드는 재정의하는 메서드의 더 파생된 반환 형식으로 선언할 수 있으며, 재정의 읽기 전용 속성은 더 파생된 형식을 선언할 수 있습니다.

공변 형식 매개 변수가 있는 제네릭 인터페이스

여러 제네릭 인터페이스에 공변 형식 매개 변수가 있습니다(예: IEnumerable<T>, IEnumerator<T>, IQueryable<T>, IGrouping<TKey,TElement>). 이러한 인터페이스의 모든 형식 매개 변수는 공변성이므로, 형식 매개 변수는 멤버의 반환 형식에만 사용됩니다.

다음 예제에서는 공변 형식 매개 변수를 사용하는 방법을 보여 줍니다. 이 예제에서는 두 가지 형식을 정의합니다. 그중 하나인 Base 에는 PrintBases (Visual Basic의 경우 IEnumerable<Base> )를 취하고 요소를 출력하는IEnumerable(Of Base) 라는 정적 메서드가 있습니다. DerivedBase에서 상속됩니다. 이 예제에서는 빈 List<Derived> (Visual Basic의 경우List(Of Derived) )를 만든 다음 이 형식을 캐스팅하지 않은 채 PrintBases 에 전달하고 IEnumerable<Base> 형식의 변수에 할당하는 방법을 보여 줍니다. List<T> 은 단일 공변 형식 매개 변수가 있는 IEnumerable<T>을 구현합니다. IEnumerable<Derived> 의 인스턴스를 IEnumerable<Base>대신 사용할 수 있는 것은 공변 형식 매개 변수 때문입니다.

using System;
using System.Collections.Generic;

class Base
{
    public static void PrintBases(IEnumerable<Base> bases)
    {
        foreach(Base b in bases)
        {
            Console.WriteLine(b);
        }
    }
}

class Derived : Base
{
    public static void Main()
    {
        List<Derived> dlist = new List<Derived>();

        Derived.PrintBases(dlist);
        IEnumerable<Base> bIEnum = dlist;
    }
}
Imports System.Collections.Generic

Class Base
    Public Shared Sub PrintBases(ByVal bases As IEnumerable(Of Base))
        For Each b As Base In bases
            Console.WriteLine(b)
        Next
    End Sub
End Class

Class Derived
    Inherits Base

    Shared Sub Main()
        Dim dlist As New List(Of Derived)()

        Derived.PrintBases(dlist)
        Dim bIEnum As IEnumerable(Of Base) = dlist
    End Sub
End Class

반공변 형식 매개 변수가 있는 제네릭 인터페이스

IComparer<T>, IComparable<T>, IEqualityComparer<T> 같은 여러 제네릭 인터페이스에서 반공변 형식 매개 변수를 사용합니다. 이러한 인터페이스에는 반공변 형식 매개 변수만 있으므로 형식 매개 변수가 인터페이스 멤버의 매개 변수 형식으로만 사용됩니다.

다음 예제에서는 반공변 형식 매개 변수를 사용하는 방법을 보여 줍니다. 이 예제에서는MustInherit 속성을 사용하여 추상(Visual Basic의 경우 Shape ) Area 클래스를 정의합니다. 이 예제에서는 또한 ShapeAreaComparer (Visual Basic의 경우 IComparer<Shape> )를 구현하는IComparer(Of Shape) 클래스를 정의합니다. IComparer<T>.Compare 메서드 구현은 Area 속성의 값을 기반으로 하므로 ShapeAreaComparer 를 사용하여 Shape 개체를 영역별로 정렬할 수 있습니다.

Circle 클래스는 Shape 를 상속하고 Area를 재정의합니다. 이 예제에서는 SortedSet<T> (Visual Basic의 경우 Circle )을 받아 들이는 생성자를 사용하여 IComparer<Circle> 개체의IComparer(Of Circle) 을 만듭니다. 하지만 이 예제에서는 IComparer<Circle>을 전달하는 대신 ShapeAreaComparer 를 구현하는 IComparer<Shape>개체를 전달합니다. 이 예제에서는Shape제네릭 인터페이스의 형식 매개 변수가 반공변 형식이기 때문에 코드에서 더 많이 파생된 형식(Circle)의 비교자를 호출하더라도 더 적게 파생된 형식( IComparer<T> )의 비교자를 전달할 수 있습니다.

Circle 개체를 SortedSet<Circle>에 추가하면 기존 요소에 대해 새 요소를 비교할 때마다 IComparer<Shape>.Compare 개체의IComparer(Of Shape).Compare 메서드(Visual Basic의 경우 ShapeAreaComparer 메서드)가 호출됩니다. 메서드의 매개 변수 형식(Shape)은 전달되는 형식(Circle)보다 더 적게 파생되었으므로 호출에서 형식 안전성을 유지합니다. 반공변성은 ShapeAreaComparerShape에서 파생되는 혼합된 형식 컬렉션뿐만 아니라 모든 단일 형식의 컬렉션을 정렬할 수 있게 해줍니다.

using System;
using System.Collections.Generic;

abstract class Shape
{
    public virtual double Area { get { return 0; }}
}

class Circle : Shape
{
    private double r;
    public Circle(double radius) { r = radius; }
    public double Radius { get { return r; }}
    public override double Area { get { return Math.PI * r * r; }}
}

class ShapeAreaComparer : System.Collections.Generic.IComparer<Shape>
{
    int IComparer<Shape>.Compare(Shape a, Shape b)
    {
        if (a == null) return b == null ? 0 : -1;
        return b == null ? 1 : a.Area.CompareTo(b.Area);
    }
}

class Program
{
    static void Main()
    {
        // You can pass ShapeAreaComparer, which implements IComparer<Shape>,
        // even though the constructor for SortedSet<Circle> expects
        // IComparer<Circle>, because type parameter T of IComparer<T> is
        // contravariant.
        SortedSet<Circle> circlesByArea =
            new SortedSet<Circle>(new ShapeAreaComparer())
                { new Circle(7.2), new Circle(100), null, new Circle(.01) };

        foreach (Circle c in circlesByArea)
        {
            Console.WriteLine(c == null ? "null" : "Circle with area " + c.Area);
        }
    }
}

/* This code example produces the following output:

null
Circle with area 0.000314159265358979
Circle with area 162.860163162095
Circle with area 31415.9265358979
 */
Imports System.Collections.Generic

MustInherit Class Shape
    Public MustOverride ReadOnly Property Area As Double
End Class

Class Circle
    Inherits Shape

    Private r As Double
    Public Sub New(ByVal radius As Double)
        r = radius
    End Sub
    Public ReadOnly Property Radius As Double
        Get
            Return r
        End Get
    End Property
    Public Overrides ReadOnly Property Area As Double
        Get
            Return Math.Pi * r * r
        End Get
    End Property
End Class

Class ShapeAreaComparer
    Implements System.Collections.Generic.IComparer(Of Shape)

    Private Function AreaComparer(ByVal a As Shape, ByVal b As Shape) As Integer _
            Implements System.Collections.Generic.IComparer(Of Shape).Compare
        If a Is Nothing Then Return If(b Is Nothing, 0, -1)
        Return If(b Is Nothing, 1, a.Area.CompareTo(b.Area))
    End Function
End Class

Class Program
    Shared Sub Main()
        ' You can pass ShapeAreaComparer, which implements IComparer(Of Shape),
        ' even though the constructor for SortedSet(Of Circle) expects 
        ' IComparer(Of Circle), because type parameter T of IComparer(Of T)
        ' is contravariant.
        Dim circlesByArea As New SortedSet(Of Circle)(New ShapeAreaComparer()) _
            From {New Circle(7.2), New Circle(100), Nothing, New Circle(.01)}

        For Each c As Circle In circlesByArea
            Console.WriteLine(If(c Is Nothing, "Nothing", "Circle with area " & c.Area))
        Next
    End Sub
End Class

' This code example produces the following output:
'
'Nothing
'Circle with area 0.000314159265358979
'Circle with area 162.860163162095
'Circle with area 31415.9265358979

Variant 형식 매개 변수가 있는 제네릭 대리자

Func<T,TResult> 같은 Func 제네릭 대리자가 공변 반환 형식과 반공변 매개 변수 형식을 사용합니다. Action 같은 Action<T1,T2>제네릭 대리자는 반공변 매개 변수 형식을 사용합니다. 즉, 더 많이 파생된 매개 변수 형식과 더 적게 파생된 반환 형식( Func 제네릭 대리자의 경우)이 있는 변수에 대리자를 할당할 수 있습니다.

참고

Func 제네릭 대리자의 마지막 제네릭 형식 매개 변수는 대리자 시그니처에 반환 값의 형식을 지정합니다. 이 제네릭 형식 매개 변수는 공변(out 키워드)인 반면 다른 한 제네릭 형식 매개 변수는 반공변(in 키워드)입니다.

다음 코드에서는 이를 보여 줍니다. 코드의 첫 부분에서는 Base라는 클래스, Derived 를 상속하는 Base라는 클래스 및 static 라는Shared 메서드(Visual Basic의 경우 MyMethod)가 있는 또 다른 클래스를 정의합니다. 이 메서드는 Base의 인스턴스를 사용하고 Derived의 인스턴스를 반환합니다. 인수가 Derived의 인스턴스이면 MyMethod에서 이 인스턴스를 반환하고, 인수가 Base의 인스턴스이면 MyMethod에서 Derived의 새 인스턴스를 반환합니다. 이 예제에서는 Main() 내에서 Func<Base, Derived>를 나타내고 이를 Func(Of Base, Derived) 변수에 저장하는 MyMethod(Visual Basic의 경우 f1)의 인스턴스를 만듭니다.

public class Base {}
public class Derived : Base {}

public class Program
{
    public static Derived MyMethod(Base b)
    {
        return b as Derived ?? new Derived();
    }

    static void Main()
    {
        Func<Base, Derived> f1 = MyMethod;
Public Class Base
End Class
Public Class Derived
    Inherits Base
End Class

Public Class Program
    Public Shared Function MyMethod(ByVal b As Base) As Derived
        Return If(TypeOf b Is Derived, b, New Derived())
    End Function

    Shared Sub Main()
        Dim f1 As Func(Of Base, Derived) = AddressOf MyMethod

코드의 둘째 부분에서는 반환 형식이 공변적이기 때문에 Func<Base, Base> (Visual Basic의 경우Func(Of Base, Base) ) 형식의 변수에 대리자를 할당할 수 있음을 보여 줍니다.

// Covariant return type.
Func<Base, Base> f2 = f1;
Base b2 = f2(new Base());
' Covariant return type.
Dim f2 As Func(Of Base, Base) = f1
Dim b2 As Base = f2(New Base())

코드의 셋째 부분에서는 매개 변수 형식이 반공변적이기 때문에 Func<Derived, Derived> (Visual Basic의 경우Func(Of Derived, Derived) ) 형식의 변수에 대리자를 할당할 수 있음을 보여 줍니다.

// Contravariant parameter type.
Func<Derived, Derived> f3 = f1;
Derived d3 = f3(new Derived());
' Contravariant parameter type.
Dim f3 As Func(Of Derived, Derived) = f1
Dim d3 As Derived = f3(New Derived())

코드의 마지막 부분에서는 반공변 매개 변수 형식과 공변 반환 형식의 효과를 결합하여 Func<Derived, Base> (Visual Basic의 경우Func(Of Derived, Base) ) 형식의 변수에 대리자를 할당할 수 있음을 보여 줍니다.

// Covariant return type and contravariant parameter type.
Func<Derived, Base> f4 = f1;
Base b4 = f4(new Derived());
' Covariant return type and contravariant parameter type.
Dim f4 As Func(Of Derived, Base) = f1
Dim b4 As Base = f4(New Derived())

제네릭이 아닌 대리자의 가변성

위의 코드에서 MyMethod 의 시그니처는 생성된 제네릭 대리자 Func<Base, Derived> (Visual Basic의 경우Func(Of Base, Derived) )의 시그니처와 정확하게 일치합니다. 이 예제에서는 모든 대리자 형식이 제네릭 대리자 형식 Func<T,TResult>에서 생성되는 한 더 많이 파생된 매개 변수 형식과 더 적게 파생된 반환 형식이 있는 메서드 매개 변수 또는 변수에 이 제네릭 대리자를 저장할 수 있음을 보여 줍니다.

다음은 중요한 내용입니다. 제네릭 대리자의 형식 매개 변수가 지니는 공변성 및 반공변성의 효과는 일반적인 대리자 바인딩이 지니는 공변성 및 반의 효과와 비슷합니다. 자세한 내용은 대리자의 가변성(C#)대리자의 가변성(Visual Basic)을 참조하세요. 그러나 대리자 바인딩의 가변성은 variant 형식 매개 변수가 있는 제네릭 대리자 형식뿐 아니라 모든 대리자 형식에서 작동합니다. 또한 대리자 바인딩이 가변성을 지니면 더 제한적인 매개 변수 형식과 덜 제한적인 반환 형식이 있는 임의의 대리자에 메서드를 바인딩할 수 있는 반면, 제네릭 대리자의 할당은 두 대리자 형식이 모두 동일한 제네릭 형식 정의에서 생성되는 경우에만 작동합니다.

다음 예제에서는 대리자 바인딩의 가변성과 제네릭 형식 매개 변수의 가변성이 결합된 효과를 보여 줍니다. 이 예제에서는 가장 적게 파생된 형식(Type1)부터 가장 많이 파생된 형식(Type3)까지 세 개의 형식을 포함하는 형식 계층을 정의합니다. 일반적인 대리자 바인딩의 가변성은 Type1 의 매개 변수 형식과 Type3 의 반환 형식이 있는 제네릭 대리자에 Type2 의 매개 변수 형식과 Type2의 반환 형식이 있는 메서드를 바인딩하는 데 사용됩니다. 결과로 생성된 제네릭 대리자는 제네릭 형식 매개 변수의 공 분산과 반공 분산을 사용하여 제네릭 대리자의 매개 변수 형식과 반환 형식이 각각 Type3Type1인 다른 변수에 할당됩니다. 이 두 번째 할당을 수행하려면 변수 형식과 대리자 형식이 둘 다 같은 제네릭 형식 정의(이 예제의 경우 Func<T,TResult>)에서 생성된 것이어야 합니다.

using System;

public class Type1 {}
public class Type2 : Type1 {}
public class Type3 : Type2 {}

public class Program
{
    public static Type3 MyMethod(Type1 t)
    {
        return t as Type3 ?? new Type3();
    }

    static void Main()
    {
        Func<Type2, Type2> f1 = MyMethod;

        // Covariant return type and contravariant parameter type.
        Func<Type3, Type1> f2 = f1;
        Type1 t1 = f2(new Type3());
    }
}
Public Class Type1
End Class
Public Class Type2
    Inherits Type1
End Class
Public Class Type3
    Inherits Type2
End Class

Public Class Program
    Public Shared Function MyMethod(ByVal t As Type1) As Type3
        Return If(TypeOf t Is Type3, t, New Type3())
    End Function

    Shared Sub Main()
        Dim f1 As Func(Of Type2, Type2) = AddressOf MyMethod

        ' Covariant return type and contravariant parameter type.
        Dim f2 As Func(Of Type3, Type1) = f1
        Dim t1 As Type1 = f2(New Type3())
    End Sub
End Class

Variant 제네릭 인터페이스 및 대리자 정의

Visual Basic과 C#에서 인터페이스와 대리자의 제네릭 형식 매개 변수를 공변 또는 반공변으로 표시하는 데 사용할 수 있는 키워드를 제공합니다.

공변 형식 매개 변수는 out 키워드(Visual Basic의 Out 키워드)로 표시됩니다. 공변 형식 매개 변수는 인터페이스에 속하는 메서드의 반환 값이나 대리자의 반환 형식으로 사용할 수 있지만 인터페이스 메서드에 대한 제네릭 형식 제약 조건으로는 사용할 수 없습니다.

참고

인터페이스의 메서드에 제네릭 대리자 형식인 매개 변수가 있으면 인터페이스 형식의 공변 형식 매개 변수를 사용하여 대리자 형식의 반공변 형식 매개 변수를 지정할 수 있습니다.

반공변 형식 매개 변수는 in 키워드(Visual Basic의 In 키워드)로 표시됩니다. 반공변 형식 매개 변수는 인터페이스에 속하는 메서드의 매개 변수 형식이나 대리자의 매개 변수 형식으로 사용할 수 있으며 인터페이스 메서드의 제네릭 형식 제약 조건으로도 사용할 수 있습니다.

variant 형식 매개 변수를 사용할 수 있는 것은 인터페이스 형식과 대리자 형식뿐입니다. 인터페이스 형식이나 대리자 형식은 공변 및 반공변 형식 매개 변수를 둘 다 가질 수 있습니다.

Visual Basic과 C#에서는 공변 및 반공변 형식 매개 변수의 사용 규칙을 위반하거나 인터페이스와 대리자가 아닌 다른 형식의 형식 매개 변수에 공 분산 및 반공 분산 주석을 추가할 수 없습니다.

자세한 내용과 예제 코드는 제네릭 인터페이스의 가변성(C#)제네릭 인터페이스의 가변성(Visual Basic)을 참조하세요.

형식 목록

다음 인터페이스 및 대리자 형식에서 공변 및/또는 반공변 형식 매개 변수를 사용합니다.

형식 공변 형식 매개 변수 반공변 형식 매개 변수
Action<T> - Action<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16>
Comparison<T>
Converter<TInput,TOutput>
Func<TResult>
Func<T,TResult> - Func<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10,T11,T12,T13,T14,T15,T16,TResult>
IComparable<T>
Predicate<T>
IComparer<T>
IEnumerable<T>
IEnumerator<T>
IEqualityComparer<T>
IGrouping<TKey,TElement>
IOrderedEnumerable<TElement>
IOrderedQueryable<T>
IQueryable<T>

참조