contravariance

private Dictionary<Type, List<IDataTransferObject>> dataStore = new Dictionary<Type, List<IDataTransferObject>>(); public void Insert<T>(T dto) where T : IDataTransferObject { if (!dataStore.ContainsKey(typeof(T))) { dataStore.Add(typeof(T), new List<T>()); } dataStore[typeof(T)].Add(dto); } The above code gives me a compile error on the dataStore.Add line because it doesn't like me trying to assign a List<T> to a List<IDataTransferObject> . Since my method restricts T to only IDataTransferObject's shouldn't the covariance/contravariance stuff in .Net 4 allow this code? I know I can change it

public class Flea : Animals {...} var fleas = new Dictionary<int, Flea>(); public IReadOnlyDictionary<string, Animal> Animals => fleas.ToDictionary(pair => pair.Key, pair => (Animal)pair.Value); Q Is there a more efficient way to obtain Animals from fleas ? .NET supports covariance in interfaces, delegates, generic types and arrays. The interface or type has to specify it's covariant though with the out keyword. You can write IEnumerable<Animal> animals=new List<Flea>(); or var dict=new Dictionary<int,Flea>{ [1]=new Flea() }; IEnumerable<Animal> animals=dict.Values; This works because

I wrote a class implementing the command design pattern : class MyCommand[-T, +R](val name: String, val execute: T => R) , prepared two command and stored it in a MutableList: val commands = new mutable.MutableList[MyCommand[Nothing, Any]] commands += new MyCommand[String, String]("lower", s => s.toLowerCase()) commands += new MyCommand[Date, Long]("time", d => d.getTime) Then I have two data to be executed: val data = Array("StRiNG", new Date()) The problem for me is that I don't know how to determine which datum is applicable to the command: data.foreach { d => commands.foreach { c => //

wiki Contravariant_method_argument_type says overriding method has the subtyping rule as function type, but no language except one support contravariant argument type. I also not able to come up with any idea of benefit to use that. example: class AnimalShelter { Animal getAnimalForAdoption() { ... } void putAnimal(Animal animal) { ... } } class CatShelter extends AnimalShelter { ＠Overriding Cat getAnimalForAdoption() { return new Cat(); } ＠Overriding void putAnimal(Object animal) { … } } My question is: Is contravariant argument type of overriding method any of good use? if yes, where it is?

On the msdn page on contravariance I find a quite interesting example that shows "benefits of contravariance in IComparer" First they use a fairly odd base & derived classes: public class Person { public string FirstName { get; set; } public string LastName { get; set; } } public class Employee : Person { } I can already say that its a bad example cause no class ever just inherits a base class without adding at least a little something of its own. Then they create a simple IEqualityComparer class class PersonComparer : IEqualityComparer<Person> { public bool Equals(Person x, Person y) { .. }

I was reading the book Java Generics and Collections By Maurice Naftalin, Philip Wadler, and within the first two chapters I ended up in having my head messed up with doubts. I was not able to figure out the answers. In the call: public static <T> void copy(List<? super T> dst, List<? extends T> src) { for (int i = 0; i < src.size(); i++) { dst.set(i, src.get(i)); } } List<Object> objs = Arrays.<Object>asList(2, 3.14, "four"); List<Integer> ints = Arrays.asList(5, 6); Collections.copy(objs, ints); assert objs.toString().equals("[5, 6, four]"); During call to the function 'copy': 1st parameter: