What are covariance and contravariance?<\/h4>\n
In C#, covariance and contravariance enable implicit reference conversion for array types, delegate types, and generic type arguments.Covariance preserves assignment compatibility<\/a> and contravariance reverses it.<\/p>\n The following code demonstrates the difference between assignment compatibility, covariance, and contravariance.<\/p>\n \/\/ Assignment compatibility.\nstring str = “test”;\n\/\/ An object of a more derived type is assigned to an object of a less derived type.\nobject obj = str;<\/p>\n \/\/ Covariance.\nIEnumerable<string> strings = new List<string>();\n\/\/ An object that is instantiated with a more derived type argument\n\/\/ is assigned to an object instantiated with a less derived type argument.\n\/\/ Assignment compatibility is preserved.\nIEnumerable<object> objects = strings;<\/p>\n \/\/ Contravariance.\n\/\/ Assume that I have this method:\n\/\/ static void SetObject(object o) { }\nAction<object> actObject = SetObject;\n\/\/ An object that is instantiated with a less derived type argument\n\/\/ is assigned to an object instantiated with a more derived type argument.\n\/\/ Assignment compatibility is reversed.\nAction<string> actString = actObject;<\/p>\n<\/div>\n<\/div>\n<\/div>\n In C#, variance is supported in the following scenarios:<\/p>\n Arrays are covariant since C# 1.0. You can always do the following:<\/p>\n In the above code, I assigned an array of strings to an array of objects. So I used a more derived type than that originally specified, which is covariance.\nCovariance in arrays is considered \u201cnot safe,\u201d because you can also do this:<\/p>\n This code compiles, but it throws an exception at run time because obj<\/b> is in fact an array of strings and cannot contain integers.<\/p>\n This feature was added in C# 2.0. When you instantiate a delegate, you can assign it a method that has a more derived return type than that specified in the delegate (covariance). You can also assign a method that has parameter types less derived than those in the delegate (contravariance).<\/p>\n Here\u2019s a quick code example illustrating the feature and some of its limitations.<\/p>\n static object GetObject() { return null; }\nstatic void SetObject(object obj) { }<\/p>\n static string GetString() { return “”; }\nstatic void SetString(string str) { }<\/p>\n static void Main()\n{\n\/\/ Covariance. A delegate specifies a return type as object,\n\/\/ but I can assign a method that returns a string.\nFunc<object> del = GetString;<\/p>\n \/\/ Contravariance. A delegate specifies a parameter type as string,\n\/\/ but I can assign a method that takes an object.\nAction<string> del2 = SetObject;<\/p>\n \/\/ But implicit conversion between generic delegates is not supported until C# 4.0.\nFunc<string> del3 = GetString;\nFunc<object> del4 = del3; \/\/ Compiler error here until C# 4.0.\n}<\/p>\n<\/div>\n<\/div>\n<\/div>\n By the way, this feature works for all delegates, both generic and non-generic, not just for Func<\/b> and Action<\/b> delegates.<\/p>\n For more information and examples, see Covariance and Contravariance in Delegates<\/a> on MSDN and Eric Lippert\u2019s post Covariance and Contravariance in C#, Part Three: Method Group Conversion Variance<\/a>.<\/p>\n This is a new feature in C# 4.0. Now, when creating a generic interface, you can specify whether there is an implicit conversion between interface instances that have different type arguments. For example, you can use an interface instance that has methods with more derived return types than originally specified (covariance) or that has methods with less derived parameter types (contravariance). The same rules are applied to generic delegates.<\/p>\n While you can create variant interfaces and delegates yourself, this is not the main purpose for this feature. What is more important is that a set of interfaces and delegates in .NET Framework 4 have been updated to become variant.\nHere\u2019s the list of updated interfaces:<\/p>\n And the list of updated delegates:<\/p>\n The most frequent scenario for most users is expected to be something like this one:<\/p>\n While this code doesn\u2019t look that impressive, it allows you to reuse a lot of methods that accept IEnumerable<\/b> objects.<\/p>\n class Program\n{\n\/\/ The method has a parameter of the IEnumerable<Person> type.\npublic static void PrintFullName(IEnumerable<Person> persons)\n{\n\/\/ The method iterates through a sequence and prints some info.\n}<\/p>\n public static void Main()\n{\nList<Employee> employees = new List<Employee>();<\/p>\n \/\/ I can pass List<Employee>, which is in fact IEnumerable<Employee>,\n\/\/ although the method expects IEnumerable<Person>.\nPrintFullName(employees);\n}\n}<\/p>\n<\/div>\n<\/div>\n<\/div>\n A couple of important rules to remember:<\/p>\n I wrote a couple of MSDN topics that show how you can benefit from this new feature. They might help you better understand the principles of covariance and contravariance:<\/p>\n Also, take a look at the video How Do I: Use Covariance and Contravariance in VS 2010 Part I?<\/a> by Eric Lippert.<\/p>\n The out<\/a> keyword marks a type parameter as covariant, and the in<\/a> keyword marks it as contravariant. The two most important rules to remember:<\/p>\n For more information about variance validation, read Creating Variant Generic Interfaces<\/a> and Variance in Delegates<\/a> on MSDN and Eric Lippert\u2019s post Exact rules for variance validity<\/a>.<\/p>\n This example shows how to create a variant generic interface:<\/p>\n interface IVariant<out R, in A>\n{\n\/\/ These methods satisfy the rules.\nR GetR();\nvoid SetA(A sampleArg);\nR GetRSetA(A sampleArg);<\/p>\n \/\/ And these don\u2019t.\n\/\/ A GetA();\n\/\/ void SetR(R sampleArg);\n\/\/ A GetASetR(R sampleArg);\n}<\/p>\n<\/div>\n<\/div>\n<\/div>\n If you extend a variant interface, the extending interface is invariant by default. You must explicitly specify whether the type parameters are covariant or contravariant by using the out<\/a> or in<\/a> keyword. Here is a quick example from MSDN<\/a>:<\/p>\n interface ICovariant<out T> { }<\/p>\n \/\/ This interface is invariant because I didn’t use the “out” keyword.\ninterface IInvariant<T> : ICovariant<T> { }<\/p>\n \/\/ And this one is covariant because I explicitly specified this.\ninterface IExtCovariant<out T> : ICovariant<T> { }<\/p>\n<\/div>\n<\/div>\n<\/div>\n And once again, this feature is supported for generic interfaces and delegates only. So the following doesn\u2019t compile:<\/p>\n For more examples, take a look at the video How Do I: Use Covariance and Contravariance in VS 2010 Part II?<\/a> by Eric Lippert.<\/p>\n This is the MSDN root topic: Covariance and Contravariance<\/a>.<\/p>\n\n
What is array covariance?<\/h4>\n
What is delegate, or method group, variance?<\/h4>\n
What is variance for generic type parameters?<\/h4>\n
\n
\n
\n
Where can I find more examples of using covariance and contravariance?<\/h4>\n
\n
How can I create variant generic interfaces and delegates myself?<\/h4>\n
\n
Where can I find more in-depth information about covariance and contravariance?<\/h4>\n