Andrew Stopford's Weblog

I have also run into a few issues where I though generics would be a solution, but ended up running into this same problem.

I would love it is this became possible.

However does it cause any problems when using value types as in:

List<object> list = new List<int>();

I would need to think through the ramifications, given the way the CLR implements generics.

IMHO this is called co-variance. Contravariance is the opposite:

http://blogs.msdn.com/rmbyers/archive/2005/02/16/375079.aspx

Frans, from reading that post types in generics in C# as it stands right now can be considerd invariant. Contravariance seems to be stricter on how types relate, to qoute:

it means that the subtype relationship of the generic type varies inversely with the relationship of the type parameter.  Or formally, G<T> is a subtype of G<U> if and only if U is a subtype of T.

Arrays in C# are already contravariant, to qoute.

For example, since you can convert a string to an object, shouldn’t you also be able to convert a List<string> to a List<object>?  After all, you can convert a string[] to an object[], why should List<T> be any different?

More formally, in C# v2.0 if T is a subtype of U, then T[] is a subtype of U[], but G<T> is not a subtype of G<U> (where G is any generic type).  In type-theory terminology, we describe this behavior by saying that C# array types are “covariant” and generic types are “invariant”.

Imho, the best way to add covariance and contravariance to generics would be to add "Readonly" and "WriteOnly" to the Type arguments.

That is ReadOnlyList<Readonly T> (in which no method in ReadOnlyList can be defined as taking an object of type T as an argument, nor can any return-value, out-parameter, or exception throw a Generic Object that involves type T except as Readonly.

ReadOnly would be the way to make sure you never have the type violation of trying to insert an "Object" into a list of "strings" because we're using List<string> in a variable typed as List<Object>.

WriteOnly is the opposite, and handles the reverse concept of substitution - cases where we want to treat a List<Object> as a List<String> - sine you can insert Strings into a list of OBjects, but you can't read strings _out_ of a list of Objects.

I am writing to support this post.  Although I see the problems with implementing co-/contravariance, the ability to cast concrete/lower types to their abstract/base type as a whole object tree allows for very generic and flexible coding.  I am glad I found this page because I knew others had to share my frustration, but I didn't know what to search for.

Cheers.

It's that time of year again and a custom on my blog to look back at my predictions for this year, relect

In case anyone in a position of authority looks at this post, I support this feature; I ran into an issue that this would have solved. It would be a nice addition to a future version of C#!