Kovariance a kontravariance (C#)

V jazyce C# kovariance a kontravariance umožňují implicitní převod odkazů pro typy polí, typy delegátů a argumenty obecného typu. Kovariance zachovává kompatibilitu přiřazení a kontravariance ji obrátí.

Následující kód ukazuje rozdíl mezi kompatibilitou přiřazení, kovariancí a kontravariancí.

// 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 pole více odvozeného typu na pole méně odvozeného typu. Tato operace ale není typová bezpečná, jak je znázorněno v následujícím příkladu kódu.

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

Podpora kovariance a kontravariance pro skupiny metod umožňuje porovnávání podpisů metod s typy delegátů. To umožňuje přiřadit delegátům nejen metody, které mají odpovídající podpisy, ale také metody, které vracejí více odvozených typů (kovariance) nebo které přijímají parametry, které mají méně odvozených typů (kontravariance), než je určeno typem delegátu. Další informace najdete v tématu Variance in Delegates (C#) a Using Variance in Delegates (C#).

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

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 .NET Framework 4 a novějších verzích jazyk C# podporuje kovarianci a kontravarianci v obecných rozhraních a delegátech a umožňuje implicitní převod parametrů obecného typu. Další informace najdete v tématu Variance in Generic Interfaces (C#) and Variance in Delegates (C#).

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

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

Obecné rozhraní nebo delegát se nazývá variant, pokud jsou jeho obecné parametry deklarovány jako kovariantní nebo kontravariantní. Jazyk C# umožňuje vytvářet vlastní variantní rozhraní a delegáty. Další informace naleznete v tématu Creating Variant Generic Interfaces (C#) and Variance in Delegates (C#).

Související témata