Covariance x Contravariance
This is one of the moost confusing generic parts of C# (exists from 4.0)
The goal is to moving from specific to general. Â Look at the code below: thanks to out T Â we are able to do something like this:
public interface IFoo<out T> { T GiveMeFoo(); } public class Program { public static void Main(string[] args) { IFoo<string> foos = null; IFoo<object> generals = foos; /*covariance enables such analogy with generic types*/ string foo = "text"; object general = foo; } }
If you move âoutâ from interface you cannot convert from IFoo<string> to IFoo<object>.Â
Now something more difficult:
public interface IFoo<out T> { T GiveMeFoo(); } public interface IBar<T> : IFoo<T> { } public class Program { public static void Main(string[] args) { IBar<string> barStr = null; IBar<object> barObj = barStr; /*BUILD FAILS because IBar has not covariant T*/ IFoo<object> fooObj = barStr; /*is Ok, because IBar derives from IFoo and IFoo has out T*/ } }
Problem with IList is similiat to IBar<T> in previous example. Â It is invariant (it doesnt allow either covariance or contravariance ). Take look at the next example :Â
public interface IFoo<out T> { IEnumerable<T> GetAllFoos(); /*WORKING*/ IList<T> GetSomeFoos(); /*DOESNT COMPILE*/ } public interface IEdible { }; public abstract class Fruit : IEdible { } public class Apple : Fruit{ } public class Banana: Fruit { } public class Pizza : IEdible { } public class Program { public static void Main(string[] args) { List<Banana> bananas = new List<Banana>(); List<IEdible> edibles = bananas; /*DOESNT COMPILE, IList doesnt allow Covariance*/ IEnumerable<IEdible> eedibles = bananas; /* working IEnumerable allows Covariance*/ IEnumerable<Fruit> fruit = bananas; /* working */ edibles.Add(new Banana()); EatAll(bananas); /*DOESNT COMPILE*/ } public static void EatAll(List<IEdible> edibles) { foreach (var item in edibles) { //Do stuff here } } }
 Donât worry, compiler always keep you safe and tellâs you when covariently or contravariently you shouldnât be.Â
Covariance is no type conversion it is allows Reference conversion (you still working with the same object but in the different kind of way).
Because Covariance allows only returned values you cannot mix it with input values. Thatâs why contravariance exists.
interface IFoo<out T, in U> where T : string, where U : stringÂ
   T QuerySomething(U param);
pixelskylines
2087
jbbartram-illu
yousharknotpass
gummygunk
areudirty
dededos
jacobvanloon
prguitarman
theartofmadeline