Why Don't Covariance and Contravariance Work with Value Types in C#?

C# Covariance and Contravariance: Value Type Restrictions

C#'s covariance and contravariance features enable flexible type assignments. However, these capabilities are limited when working with value types.

IEnumerable<T> exhibits covariance, permitting assignment of a T reference to an object reference. This doesn't extend to value types, as illustrated:

<code class="language-csharp">IEnumerable<string> strList = new List<string>();
IEnumerable<object> objList = strList;  // Compiles fine

IEnumerable<int> intList = new List<int>();
IEnumerable<object> objList = intList;  // Compilation error</code>

This difference stems from boxing. Assigning a value type to a reference variable necessitates boxing—creating a new heap-allocated object. This adds overhead and introduces potential runtime issues.

With covariance, the Common Language Runtime (CLR) can't guarantee preservation of boxed value identity. For instance, a method accepting an object[] and modifying an element doesn't guarantee the IEnumerable<int>'s boxed value remains unchanged.

Consequently, to maintain type safety and prevent boxing-related errors, covariance and contravariance aren't supported for value types in C#.

The above is the detailed content of Why Don't Covariance and Contravariance Work with Value Types in C#?. For more information, please follow other related articles on the PHP Chinese website!