contravariance

I'm having a struggle understanding these two concepts. But I think after many videos and SO QA's, I have it distilled down to its simplest form: Covariant - Assumes a sub-type can do what its base-type does. Contravariant - Assumes you can treat a sub-type the same way you would treat its base-type. Supposing these three classes: class Animal { void Live(Animal animal) { //born! } void Die(Animal animal) { //dead! } } class Cat : Animal { } class Dog : Animal { } Covariant Any animal can do what animals do. Assumes a sub-type can do what its base-type does. Animal anAnimal = new Cat();

Inspired by Real-world examples of co- and contravariance in Scala I thought a better question would be: When designing a library, are there a specific set of questions you should ask yourself when determining whether a type parameter should be covariant or contravariant? Or should you make everything invariant and then change as needed? Well, simple, does it make sense? Think of Liskov substitution. Co-variance If A <: B , does it make sense to pass a C[A] where a C[B] is expected? If so, make it C[+T] . The classic example is the immutable List , where a List[A] can be passed to anything

What is the meaning of the concepts 'covariance' and 'contravariance'? Given 2 classes, Animal and Elephant (which inherits from Animal ), my understanding is that you would get a run-time errors if you try and put an Elephant into an array of Animals, and this happens because Elephant is "bigger" (more specific) than Animal. But could you place an Animal into an array of Elephant, seeing how Elephant is guaranteed to contain the Animal properties? You have it backwards. You can add an Elephant to an Animal array because it is an Animal, and it's guaranteed to have all of the methods an Animal

When learning more about the standard event model in .NET, I found that before introducing generics in C#, the method that will handle an event is represented by this delegate type: // // Summary: // Represents the method that will handle an event that has no event data. // // Parameters: // sender: // The source of the event. // // e: // An object that contains no event data. public delegate void EventHandler(object sender, EventArgs e); But after generics were introduced in C# 2, I think this delegate type was rewritten using genericity: // // Summary: // Represents the method that will

First, remember that a .NET String is both IConvertible and ICloneable . Now, consider the following quite simple code: //contravariance "in" interface ICanEat<in T> where T : class { void Eat(T food); } class HungryWolf : ICanEat<ICloneable>, ICanEat<IConvertible> { public void Eat(IConvertible convertibleFood) { Console.WriteLine("This wolf ate your CONVERTIBLE object!"); } public void Eat(ICloneable cloneableFood) { Console.WriteLine("This wolf ate your CLONEABLE object!"); } } Then try the following (inside some method): ICanEat<string> wolf = new HungryWolf(); wolf.Eat("sheep"); When one

I can't understand why the following C# code doesn't compile. As you can see, I have a static generic method Something with an IEnumerable<T> parameter (and T is constrained to be an IA interface), and this parameter can't be implicitly converted to IEnumerable<IA> . What is the explanation? (I don't search for a workaround, just to understand why it doesn't work). public interface IA { } public interface IB : IA { } public class CIA : IA { } public class CIAD : CIA { } public class CIB : IB { } public class CIBD : CIB { } public static class Test { public static IList<T> Something<T>