C# in Depth

Limitations of generics in C# and other languages1033.6.1 Lack of covariance and contravarianceIn section 2.3.2, we looked at the covariance of arrays—the fact that an array of a referencetype can be viewed as an array of its base type, or an array of any of the interfacesit implements. Generics don’t support this—they are invariant. This is for the sake oftype safety, as we’ll see, but it can be annoying.WHY DON’T GENERICS SUPPORT COVARIANCE?Let’s suppose we have two classes, Animal and Cat, where Cat derives from Animal. Inthe code that follows, the array code (on the left) is valid C# 2; the generic code (onthe right) isn’t:Valid (at compile-time):Animal[] animals = new Cat[5];animals[0] = new Animal();Invalid:List animals=new List();animals.Add(new Animal());The compiler has no problem with the second line in either case, but the first line onthe right causes the error:error CS0029: Cannot implicitly convert type'System.Collections.Generic.List' to'System.Collections.Generic.List'This was a deliberate choice on the part of the framework and language designers. Theobvious question to ask is why this is prohibited—and the answer lies on the secondline. There is nothing about the second line that should raise any suspicion. After all,List effectively has a method with the signature void Add(Animal value)—you should be able to put a Turtle into any list of animals, for instance. However, theactual object referred to by animals is a Cat[] (in the code on the left) or a List(on the right), both of which require that only references to instances of Cat are storedin them. Although the array version will compile, it will fail at execution time. This wasdeemed by the designers of generics to be worse than failing at compile time, which isreasonable—the whole point of static typing is to find out about errors before the codeever gets run.NOTE So why are arrays covariant? Having answered the question about whygenerics are invariant, the next obvious step is to question why arrays arecovariant. According to the Common Language Infrastructure AnnotatedStandard (Addison-Wesley Professional, 2003), for the first edition thedesigners wished to reach as broad an audience as possible, which includedbeing able to run code compiled from Java source. In other words, .NET hascovariant arrays because Java has covariant arrays—despite this being aknown “wart” in Java.So, that’s why things are the way they are—but why should you care, and how can youget around the restriction?Licensed to Rhona Hadida