Kovariance a Contravariance (C# a Visual Basic)

C# a Visual Basic, kovariance a contravariance umožňují převod implicitní odkaz pro typy polí, typů delegátů a argumentů obecného typu.Kovariance zachová kompatibilitu přiřazení a contravariance se obrátí.

Následující kód ukazuje rozdíl mezi přiřazení kompatibility kovariance a contravariance.

' Assignment compatibility. 
Dim str As String = "test"
' An object of a more derived type is assigned to an object of a less derived type. 
Dim obj As Object = str

' Covariance. 
Dim strings As IEnumerable(Of String) = New List(Of String)()
' An object that is instantiated with a more derived type argument 
' is assigned to an object instantiated with a less derived type argument. 
' Assignment compatibility is preserved. 
Dim objects As IEnumerable(Of Object) = strings

' Contravariance.           
' Assume that there is the following method in the class: 
' Shared Sub SetObject(ByVal o As Object)
' End Sub
Dim actObject As Action(Of Object) = AddressOf SetObject

' An object that is instantiated with a less derived type argument 
' is assigned to an object instantiated with a more derived type argument. 
' Assignment compatibility is reversed. 
Dim actString As Action(Of String) = actObject

// Assignment compatibility. 
string str = "test";
// An object of a more derived type is assigned to an object of a less derived type. 
object obj = str;

// Covariance. 
IEnumerable<string> strings = new List<string>();
// An object that is instantiated with a more derived type argument 
// is assigned to an object instantiated with a less derived type argument. 
// Assignment compatibility is preserved. 
IEnumerable<object> objects = strings;

// Contravariance.           
// Assume that the following method is in the class: 
// static void SetObject(object o) { } 
Action<object> actObject = SetObject;
// An object that is instantiated with a less derived type argument 
// is assigned to an object instantiated with a more derived type argument. 
// Assignment compatibility is reversed. 
Action<string> actString = actObject;

Kovariance pro pole umožňuje implicitní převod matice více odvozeného typu do pole méně odvozeného typu.Ale není tato operace typu bezpečné, jak je znázorněno v následujícím příkladu kódu.

Dim array() As Object = New String(10) {}
' The following statement produces a run-time exception.
' array(0) = 10

object[] array = new String[10];
// The following statement produces a run-time exception.
// array[0] = 10;

Kovariance a contravariance podporu pro skupiny metoda umožňuje odpovídající metodu podpisy s typy delegáta.Umožňuje přiřadit Delegáti není pouze metody, které mají odpovídající podpisy, ale také metody, které vracejí více odvozené typy (kovariance) nebo který přijmout parametry, které obsahují méně odvozené typy (contravariance), než je určený typ delegáta.Další informace naleznete v tématu Rozptyl Delegáti (C# a Visual Basic) a Použití odchylky v Delegáti (C# a Visual Basic).

Následující příklad kódu ukazuje kovariance a contravariance podporu pro metodu skupiny.

Shared Function GetObject() As Object
    Return Nothing
End Function

Shared Sub SetObject(ByVal obj As Object)
End Sub

Shared Function GetString() As String
    Return ""
End Function

Shared Sub SetString(ByVal str As String)

End Sub

Shared Sub Test()
    ' Covariance. A delegate specifies a return type as object,
    ' but you can assign a method that returns a string.
    Dim del As Func(Of Object) = AddressOf GetString

    ' Contravariance. A delegate specifies a parameter type as string,
    ' but you can assign a method that takes an object.
    Dim del2 As Action(Of String) = AddressOf SetObject
End Sub

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

V programu.NET Framework 4 a Visual Studio 2010, C# a Visual Basic support kovariance i contravariance v obecné rozhraní a Delegáti a umožňuje implicitní převod parametrů obecného typu.Další informace naleznete v tématu Odchylka v obecné rozhraní (C# a Visual Basic) a Rozptyl Delegáti (C# a Visual Basic).

Následující příklad kódu ukazuje převod implicitní odkaz pro obecné rozhraní.

Dim strings As IEnumerable(Of String) = New List(Of String)
Dim objects As IEnumerable(Of Object) = strings

IEnumerable<String> strings = new List<String>();
IEnumerable<Object> objects = strings;

Obecné rozhraní nebo delegát se nazývá varianty Pokud jsou deklarovány své obecné parametry covariant nebo contravariant.Jak C# a Visual Basic lze vytvořit varianty rozhraní a delegáty.Další informace naleznete v tématu Vytváření Variant obecné rozhraní (C# a Visual Basic) a Rozptyl Delegáti (C# a Visual Basic).

Příbuzná témata

Title	Description
Odchylka v obecné rozhraní (C# a Visual Basic)	Popisuje kovariance a contravariance v obecné rozhraní a poskytuje seznam variant obecné rozhraní v.NET Framework.
Vytváření Variant obecné rozhraní (C# a Visual Basic)	Ukazuje, jak vytvořit vlastní rozhraní typu variant.
Pomocí odchylka v rozhraní pro obecný kolekce (C# a Visual Basic)	Ukazuje, jak kovariance contravariance podpora a IEnumerable<T> a IComparable<T> rozhraní umožňují opakované použití kódu.
Rozptyl Delegáti (C# a Visual Basic)	Popisuje kovariance a contravariance v obecný a obecné delegátů a poskytuje seznam variant obecný Delegáti v.NET Framework.
Použití odchylky v Delegáti (C# a Visual Basic)	Ukazuje, jak pomocí kovariance a contravariance podporu delegátů obecné metody podpisy odpovídat typy delegáta.
Použití odchylky pro Func a akce obecný Delegáti (C# a Visual Basic)	Ukazuje, jak kovariance contravariance podpora a Func a Action Delegáti umožňují opakované použití kódu.