Covariance generic arguments don't work with Enums?

[justinbhopper]

I'm confused about Enums and why they seem to fail with covariance generic arguments.

Everything I can see tells me that all enums inherit from the base Enum class. However, I cannot assign IEnumerable<MyEnum> to IEnumerable<Enum>.

Why not?

public class Person { }
public class Employee : Person { }

public enum EnumNumbers
{
    One
}

public static void Test()
{
    // IEnumerable<out T> supports covariance
    IEnumerable<Employee> employees = new List<Employee>();
    IEnumerable<Person> people = employees; // Covariance works

    IEnumerable<EnumNumbers> numbers = new List<EnumNumbers>();
    IEnumerable<Enum> enums = numbers; // ERROR: Covariance not working?

    // EnumNumbers does indeed inherit from Enum
    Enum value = EnumNumbers.One;

    // Always true
    if (EnumNumbers.One is Enum)
    {
    }

    // The generic constraint agrees, IEnumerable<EnumNumbers> is covariant of IEnumerable<Enum>
    GenericConstraintTest(numbers);
}

public static void GenericConstraintTest<T>(IEnumerable<T> value)
    where T : Enum
{

}

[HaloFour]

Generic variance doesn't work with value types. While System.Enum itself is technically a reference type, every implementation of an enum is a value type and has the same layout as the underlying integral type.

[justinbhopper]

Thank you! That explains the difference I wasn't picking up.

[333fred]

Another way to think of variance in C# is that it only works if the conversion can happen without changing the state of the value in any fashion. Reference conversions work because it requires no state change to go from regarding something as a string to regarding it as an object; both are pointers. However, converting from a specific enum to an Enum is a boxing conversion; the runtime has to take the value of the enum instance, put it on the heap, and then give you a pointer to that heap location. This is not state preserving, so it can't participate in variance.

[TahirAhmadov]

You could probably achieve this with wrappers:

abstract class EnumWrapperBase
{
  public abstract Enum ValueTypeless { get; }
}
class EnumWrapper<T>(T value) : EnumWrapperBase
  where T : Enum, struct
{
  public T Value { get; } = value;
  public override Enum ValueTypeless => this.Value;
}
IEnumerable<EnumWrapper<MyEnum>> x = ...;
IEnumerable<EnumWrapperBase> y = x; // should work

However, this entails allocating an object for each enum value, so I'm not sure how useful this is.

[TahirAhmadov]

Or:

static class IEnumerableOfEnumExtensions
{
  public static IEnumerable<Enum> Variate<TEnum>(this IEnumerable<TEnum> This)
    where TEnum : Enum, struct
    => This.Select(x => (Enum)x);
}

Calling this is also expensive, because of LINQ and allocations. But if you need it, you can use it, I guess.