In probability theory and statistics, covariance<\/b> is a measure of how much two random variables change together. If the greater values of one variable mainly correspond with the greater values of the other variable, and the same holds for the smaller values, i.e., the variables tend to show similar behavior, the covariance is positive.In the opposite case, when the greater values of one variable mainly correspond to the smaller values of the other, i.e., the variables tend to show opposite behavior, the covariance is negative. The sign of the covariance therefore shows the tendency in the linear relationship between the variables.<\/p>\n
CLR team might have found my assumption quite viable and it got shape in .NET 4.0 as \u201cCovariance and Contravariance in Generics\u201d.<\/strong><\/p>\n Variance<\/b> is a special case of the covariance when the two variables are identical<\/p>\n Covariance<\/b> and <\/b>contravariance<\/b> of generic type parameters enable to use constructed generic types whose type arguments are more derived (covariance) or less derived (contravariance) than a target constructed type.<\/p>\n In general, a covariant type parameter can be used as the return type of a generic delegate\/interface, and contravariant type parameters can be used as input parameter types.<\/strong><\/p>\n IEnumerable<T><\/a>, IEnumerator<T><\/a>—– <\/b>Covariance<\/b><\/p>\n Comparison<T><\/a>, Action<T><\/a>, IComparer<T><\/a>— <\/b>contravariance<\/b><\/p>\n Func<T, TResult><\/a>, Converter<TInput, TOutput><\/a>— Encapsulates a method that has one parameter and returns a value of the type specified by the TResult parameter.it is Covariance and <\/b>contravariance support.<\/b><\/p>\n <\/p>\n <\/p>\n Generic delegates enable type-safe callbacks without the need to create multiple delegate classes<\/p>\n For a generic class Node<T>, client code can reference the class either by specifying a type argument, to create a closed constructed type (Node<int>). Alternatively, it can leave the type parameter unspecified, for example when you specify a generic base class, to create an open constructed type (Node<T>). Generic classes can inherit from concrete, closed constructed<\/b>, or open constructed<\/b> base classes:<\/p>\n Contravariance<\/em> works the other way than covariance<\/em>. Let’s say we have a method that creates some cats and compares them using a provided The The compiler accepts this code because the In probability theory and statistics, covariance is a measure of how much two random variables change together. If the greater values of one variable mainly correspond with the greater values of the other variable, and the same holds for the smaller values, i.e., the variables tend to show similar behavior, the covariance is positive.In the opposite case, when the greater… Read more →<\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[],"class_list":["post-368","post","type-post","status-publish","format-standard","hentry","category-c-vb","xfolkentry"],"_links":{"self":[{"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=\/wp\/v2\/posts\/368","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=368"}],"version-history":[{"count":0,"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=\/wp\/v2\/posts\/368\/revisions"}],"wp:attachment":[{"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=368"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=368"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/mairwa.com\/wordpress\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=368"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}Func<string, string> convertMethod = UppercaseString;(it<\/pre>\n
\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0string name = \"Dakota\";<\/pre>\n
\u00a0\u00a0\u00a0\u00a0\u00a0 \/\/ Use delegate instance to call UppercaseString method<\/pre>\n
\u00a0\u00a0\u00a0\u00a0\u00a0 Console.WriteLine(convertMethod(name));<\/pre>\n
IEnumerable< BaseVO > lstBaseVO = new List< FlightVO >();The above statement is valid because, in .NET 4.0,
List<T> : IEnumerable<out T><\/code> where type \u2018T\u2019 is marked as covariant.<\/strong><\/pre>\n\n
\n\n
\n where T : class<\/td>\n The type argument must be a reference type; this applies also to any class, interface, delegate, or array type.<\/td>\n<\/tr>\n \n where T : new()<\/td>\n The type argument must have a public parameterless constructor. When used together with other constraints, the new() constraint must be specified last.<\/td>\n<\/tr>\n \n where T : <base class name><\/td>\n The type argument must be or derive from the specified base class.<\/td>\n<\/tr>\n \n where T : <interface name><\/td>\n The type argument must be or implement the specified interface. Multiple interface constraints can be specified. The constraining interface can also be generic.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n public\u00a0static\u00a0void OpTest<T>(T s, T t) where T : class<\/pre>\n
{<\/pre>\n\u00a0\u00a0\u00a0 System.Console.WriteLine(s == t);<\/pre>\n
}<\/pre>\n
static\u00a0void Main()<\/pre>\n
{<\/pre>\n\u00a0\u00a0\u00a0 string s1 = \"target\";<\/pre>\n
\u00a0\u00a0\u00a0 System.Text.StringBuilder sb = new System.Text.StringBuilder(\"target\");<\/pre>\n
\u00a0\u00a0\u00a0 string s2 = sb.ToString();<\/pre>\n
\u00a0\u00a0\u00a0 OpTest<string>(s1, s2);<\/pre>\n
}<\/pre>\n
class BaseNode { }<\/pre>\nclass BaseNodeGeneric<T> { }<\/pre>\n\/\/An unbound<\/em> type has no type arguments specified(collection class)<\/pre>\n
<\/pre>\n
\/\/ concrete type<\/pre>\n
class NodeConcrete<T> : BaseNode { }<\/pre>\n<\/pre>\n
\/\/closed constructed type<\/pre>\n
class NodeClosed<T> : BaseNodeGeneric<int> { }<\/pre>\n<\/pre>\n
\/\/open constructed type<\/pre>\n
class NodeOpen<T> : BaseNodeGeneric<T> { }<\/pre>\n<\/pre>\n
Generic Delegates<\/h1>\n
A delegate can define its own type parameters. Code that references the generic delegate can specify the type argument to create a closed constructed type, just like when instantiating a generic class or calling a generic method.<\/pre>\n
public\u00a0delegate\u00a0void Del<T>(T item);<\/pre>\n
public\u00a0static\u00a0void Notify(int i) { }<\/pre>\n<\/pre>\n
Del<int> m1 = new Del<int>(Notify);\n\n\n<\/pre>\n
Contravariance<\/h3>\n
IComparer<Cat><\/code> object. In a more realistic example, the method might, for example, sort the cats:<\/p>\nvoid CompareCats(IComparer<Cat> comparer) {\n var cat1 = new Cat(\"Otto\");\n var cat2 = new Cat(\"Troublemaker\");\n if (comparer.Compare(cat2, cat1) > 0) \n Console.WriteLine(\"Troublemaker wins!\");\n}<\/pre>\ncomparer<\/code> object takes cats as arguments, but it never returns a cat as the result. You could say that it is a write-only in the way in which it uses the generic type parameter. Now, thanks to contravariance<\/em>, we can create a comparer that can compare animals and use it as an argument to CompareCats<\/code>:<\/p>\nIComparator<Animal> compareAnimals = new AnimalSizeComparator();\nCompareCats(compareAnimals);<\/pre>\n
IComparer<\/code> interface is contravariant<\/em> and its generic type parameter is marked with the in<\/code> annotation. When you run the program, it also makes sense. The compareAnimals<\/code> object that we created knows how to compare animals and so it can certainly also compare two cats. A problem would be if we could read a Cat<\/code> from IComparer<Cat><\/code> (because we couldn’t get Cat<\/code> from IComparer<Animal><\/code>!), but that is not possible, because IComparer<\/code> is write-only.<\/p>\n","protected":false},"excerpt":{"rendered":"