Why generic IList does not inherit non-generic IList

by

As you note, T in IList<T> is not covariant. As a rule of thumb: any class that can modify its state cannot be covariant. The reason is that such classes often have methods that have T as the type of one of their parameters, e.g. void Add(T element). And covariant type parameters are not allowed in input positions.

Generics were added, among other reasons, to provide type safety. For example, you can’t add an Elephant to a list of Apple. If ICollection<T> were to extend ICollection, then you could call ((ICollection)myApples).Add(someElephant) without a compile-time error, as ICollection has a method void Add(object obj), which seemingly allows you to add any object to the list, while in practice you can only add objects of T. Therefore, ICollection<T> does not extend ICollection and IList<T> does not extend IList.

Anders Hejlsberg, one of the creators of C#, explains it like this:

Ideally all of the generic collection interfaces (e.g. ICollection<T>, IList<T>) would inherit from their non-generic counterparts such that generic interface instances could be used both with generic and non-generic code.

As it turns out, the only generic interface for which this is possible is IEnumerable<T>, because only IEnumerable<T> is contra-variant [sic1]: In IEnumerable<T>, the type parameter T is used only in “output” positions (return values) and not in “input” positions (parameters). ICollection<T> and IList<T> use T in both input and output positions, and those interfaces are therefore invariant.

1) IEnumerable<T> is co-variant

Since .Net 4.5 there are the IReadOnlyCollection<out T> and IReadOnlyList<out T> covariant interfaces. But IList<T>, ICollection<T> and many of the list and collection classes don’t implement or extend them. Frankly, I find them not very useful, as they only define Count and this[int index].

If I could redesign .Net 4.5 from the ground up, I would have split the list interface into a read-only covariant interface IList<out T> that includes Contains and IndexOf, and a mutable invariant interface IMutableList<T>. Then you could cast IList<Apple> to IList<object>. I implemented this here:

M42 Collections – Covariant collections, lists and arrays.

More Related Contents:

  1. How do I use reflection to call a generic method?
  2. Passing arguments to C# generic new() of templated type
  3. What exactly is an “open generic type” in .NET? [duplicate]
  4. Generics in C#, using type of a variable as parameter [duplicate]
  5. A generic list of anonymous class
  6. No generic implementation of OrderedDictionary?
  7. Why must I provide explicitly generic parameter types While the compiler should infer the type?
  8. Passing a single item as IEnumerable
  9. Static Generic Class as Dictionary
  10. Why isn’t ArrayList marked [Obsolete]?
  11. Convert string to nullable type (int, double, etc…)
  12. How to initialize a List to a given size (as opposed to capacity)?
  13. Get a generic method without using GetMethods
  14. Anonymous Types – Are there any distingushing characteristics?
  15. Generic Type in constructor
  16. A reusable pattern to convert event into task
  17. Collection of generic types
  18. How do I create a generic class from a string in C#? [duplicate]
  19. Parse string to enum type
  20. Wildcard equivalent in C# generics
  21. Ambiguous call between two C# extension generic methods one where T:class and other where T:struct
  22. How do I tell if a type is a “simple” type? i.e. holds a single value
  23. Generics can’t infer second parameter? [duplicate]
  24. Can I have a variable number of generic parameters?
  25. How to define generic type limit to primitive types?
  26. Which C# method overload is chosen?
  27. Are static members of a generic class tied to the specific instance?
  28. Convert DataTable to List
  29. How to make correct clone of the List? [duplicate]
  30. Why it is not possible to define generic indexers in .NET?

Leave a Comment