Does C# support return type covariance?

by

UPDATE: This answer was written in 2011. After two decades of people proposing return type covariance for C# they have been implemented. See Covariant Returns in https://devblogs.microsoft.com/dotnet/c-9-0-on-the-record/.

It sounds like what you want is return type covariance. C# does not support return type covariance.

Return type covariance is where you override a base class method that returns a less-specific type with one that returns a more specific type:

abstract class Enclosure
{
    public abstract Animal Contents();
}
class Aquarium : Enclosure
{
    public override Fish Contents() { ... }
}

This is safe because consumers of Contents via Enclosure expect an Animal, and Aquarium promises to not only fulfill that requirement, but moreover, to make a more strict promise: that the animal is always a fish.

This kind of covariance is not supported in C#, and is unlikely to ever be supported. It is not supported by the CLR. (It is supported by C++, and by the C++/CLI implementation on the CLR; it does so by generating magical helper methods of the sort I suggest below.)

(Some languages support formal parameter type contravariance as well — that you can override a method that takes a Fish with a method that takes an Animal. Again, the contract is fulfilled; the base class requires that any Fish be handled, and the derived class promises to not only handle fish, but any animal. Similarly, C# and the CLR do not support formal parameter type contravariance.)

The way you can work around this limitation is to do something like:

abstract class Enclosure
{
    protected abstract Animal GetContents();
    public Animal Contents() { return this.GetContents(); }
}
class Aquarium : Enclosure
{
    protected override Animal GetContents() { return this.Contents(); }
    public new Fish Contents() { ... }
}

Now you get both the benefits of overriding a virtual method, and getting stronger typing when using something of compile-time type Aquarium.

More Related Contents:

  1. Convert List to List
  2. Why covariance and contravariance do not support value type
  3. In C#, why can’t a List object be stored in a List variable
  4. Difference between Covariance & Contra-variance
  5. How is Generic Covariance & Contra-variance Implemented in C# 4.0?
  6. Cast Generic to Generic [duplicate]
  7. Understanding Covariant and Contravariant interfaces in C#
  8. still confused about covariance and contravariance & in/out
  9. Covariance and IList
  10. vs in Generics
  11. C#: Overriding return types
  12. c# covariant return types utilizing generics
  13. covariance in c#
  14. Why cannot IEnumerable be cast as IEnumerable?
  15. Casting List – covariance/contravariance problem
  16. C# : Is Variance (Covariance / Contravariance) another word for Polymorphism?
  17. ref and out parameters in C# and cannot be marked as variant
  18. Contravariance explained
  19. T must be contravariantly valid
  20. Why can’t I cast from a List to List?
  21. Why does C#/CLR not support method override co/contra-variance?
  22. Why does C# (4.0) not allow co- and contravariance in generic class types?
  23. Why can’t I assign a List to a List?
  24. How to get around lack of covariance with IReadOnlyDictionary?
  25. Is this a covariance bug in C# 4?
  26. C# Covariance on subclass return types
  27. Can I Override with derived types?
  28. Why classes that implement variant interfaces remain invariant?
  29. Understanding Covariance and Contravariance in C# 4.0
  30. c# 9.0 covariant return types and interfaces

Leave a Comment