Why classes that implement variant interfaces remain invariant?

by

Firstly, classes are always invariant in C#. You can’t declare a class like this:

// Invalid
public class Foo<out T>

Secondly – and more importantly for the example you’ve given – List<T> couldn’t be declared to be covariant or contravariant in T anyway, as it has members both accepting and returning values of type T.

Imagine if it were covariant. Then you could write this (for the obvious Fruit class hierarchy):

List<Banana> bunchOfBananas = new List<Banana>();
// This would be valid if List<T> were covariant in T
List<Fruit> fruitBowl = bunchOfBananas;
fruitBowl.Add(new Apple());
Banana banana = bunchOfBananas[0];

What would you expect that last line to do? Fundamentally, you shouldn’t be able to add an Apple reference to an object whose actual execution-time type is List<Banana>. If you add an apple to a bunch of bananas, it falls off. Believe me, I’ve tried.

The last line should be safe in terms of types – the only values within a List<Banana> should be null or references to instances of Banana or a subclass.

Now as for why classes can’t be covariant even when they could logically be… I believe that introduces problems at the implementation level, and would also be very restrictive at the programming level as well. For example, consider this:

public class Foo<out T> // Imagine if this were valid
{
    private T value;

    public T Value { get { return value; } }

    public Foo(T value)
    {
        this.value = value;
    }
}

That would still probably have to be invalid – the variable is still writable, meaning it counts as an “in” slot. You’d have to make every variable of type T read-only… and that’s just for starters. I strongly suspect that there would be deeper problems.

In terms of pure pragmatism, the CLR has supported delegate and interface variance from v2 – C# 4 just introduced the syntax to expose the feature. I don’t believe the CLR has ever supported generic class variance.

More Related Contents:

  1. Why covariance and contravariance do not support value type
  2. Difference between Covariance & Contra-variance
  3. Covariance and contravariance real world example
  4. How is Generic Covariance & Contra-variance Implemented in C# 4.0?
  5. Contravariance explained
  6. Why does C# (4.0) not allow co- and contravariance in generic class types?
  7. Question about C# covariance
  8. how to add new method to TextBox Class [closed]
  9. Convert List to List
  10. What is the ‘dynamic’ type in C# 4.0 used for?
  11. Shorter syntax for casting from a List to a List?
  12. Count the items from a IEnumerable without iterating?
  13. Correct, idiomatic way to use custom editor templates with IEnumerable models in ASP.NET MVC
  14. List thread safety
  15. Why cannot IEnumerable be cast as IEnumerable?
  16. Overloaded method-group argument confuses overload resolution?
  17. Limit the number of parallel threads in C#
  18. How can I simulate a mouse click at a certain position on the screen?
  19. Fastest way to Remove Duplicate Value from a list by lambda
  20. Using IEnumerable without foreach loop
  21. Why can’t I cast from a List to List?
  22. Is this a covariance bug in C# 4?
  23. C# operator overload for `+=`?
  24. Dynamically implementing an interface in .NET 4.0 (C#)
  25. C# – Issues with boxing / unboxing / typecasting ints. I don’t understand
  26. C# Regex to match the word with dot
  27. Understanding Covariance and Contravariance in C# 4.0
  28. VS 2015 SSIS Script Tasks cannot be debugged
  29. How do I translate an expression tree of one type to a different expression type?
  30. USB Device Connected

Leave a Comment