Why cannot IEnumerable be cast as IEnumerable?

by

Why is the last line not allowed?

Because double is a value type and object is a reference type; covariance only works when both types are reference types.

Is this because double is a value type that doesn’t derive from object, hence the covariance doesn’t work?

No. Double does derive from object. All value types derive from object.

Now the question you should have asked:

Why does covariance not work to convert IEnumerable<double> to IEnumerable<object>?

Because who does the boxing? A conversion from double to object must box the double. Suppose you have a call to IEnumerator<object>.Current that is “really” a call to an implementation of IEnumerator<double>.Current. The caller expects an object to be returned. The callee returns a double. Where is the code that does the boxing instruction that turns the double returned by IEnumerator<double>.Current into a boxed double?

It is nowhere, that’s where, and that’s why this conversion is illegal. The call to Current is going to put an eight-byte double on the evaluation stack, and the consumer is going to expect a four-byte reference to a boxed double on the evaluation stack, and so the consumer is going to crash and die horribly with an misaligned stack and a reference to invalid memory.

If you want the code that boxes to execute then it has to be written at some point, and you’re the person who gets to write it. The easiest way is to use the Cast<T> extension method:

IEnumerable<object> objects2 = doubleenumerable.Cast<object>();

Now you call a helper method that contains the boxing instruction that converts the double from an eight-byte double to a reference.

UPDATE: A commenter notes that I have begged the question — that is, I have answered a question by presupposing the existence of a mechanism which solves a problem every bit as hard as a solution to the original question requires. How does the implementation of Cast<T> manage to solve the problem of knowing whether to box or not?

It works like this sketch. Note that the parameter types are not generic:

public static IEnumerable<T> Cast<T>(this IEnumerable sequence) 
{
    if (sequence == null) throw ...
    if (sequence is IEnumerable<T>) 
        return sequence as IEnumerable<T>;
    return ReallyCast<T>(sequence);
}

private static IEnumerable<T> ReallyCast<T>(IEnumerable sequence)
{
    foreach(object item in sequence)
        yield return (T)item;
}

The responsibility for determining whether the cast from object to T is an unboxing conversion or a reference conversion is deferred to the runtime. The jitter knows whether T is a reference type or a value type. 99% of the time it will of course be a reference type.

More Related Contents:

  1. In C#, why can’t a List object be stored in a List variable
  2. vs in Generics
  3. c# covariant return types utilizing generics
  4. T must be contravariantly valid
  5. Why can’t I cast from a List to List?
  6. Why does C# (4.0) not allow co- and contravariance in generic class types?
  7. Why can’t I assign a List to a List?
  8. Is this a covariance bug in C# 4?
  9. Create Generic method constraining T to an Enum
  10. Why can’t the C# constructor infer type?
  11. Can’t operator == be applied to generic types in C#?
  12. Nullable type as a generic parameter possible?
  13. Generic constraint to match numeric types [duplicate]
  14. Generic Method Executed with a runtime type [duplicate]
  15. Combination of List
  16. Static Generic Class as Dictionary
  17. Get a generic method without using GetMethods
  18. Using IsAssignableFrom with ‘open’ generic types
  19. A reusable pattern to convert event into task
  20. Sorting an IList in C#
  21. How do I create a generic class from a string in C#? [duplicate]
  22. Why does this generic constraint compile when it seems to have a circular reference
  23. What does new() mean?
  24. How to define generic type limit to primitive types?
  25. How can I write a generic anonymous method?
  26. How do I get the type name of a generic type argument?
  27. Generic List as parameter on method
  28. How can I write a generic container class that implements a given interface in C#?
  29. Using generics with XmlSerializer
  30. c# 9.0 covariant return types and interfaces

Leave a Comment