Question

I wrote this EnumHelper method

    public static IEnumerable<T> AsEnumerable<TEnum, T>(Func<TEnum, T> projection = null) where TEnum : struct
    {
        if (!typeof(TEnum).IsEnum)
            throw new InvalidOperationException("Type parameter TEnum must be an enum");

        if (projection == null)
            return Enum.GetValues(typeof (TEnum)).OfType<TEnum>();

        return Enum.GetValues(typeof (TEnum)).OfType<TEnum>().Select(projection);
    }

I get a compile time error in the first return. That returns an IEnumerable<TEnum>

Error 46 Cannot implicitly convert type System.Collections.Generic.IEnumerable<TEnum> to System.Collections.Generic.IEnumerable<T>

I don’t have any constraints on T, so T is more generic than TEnum. In IEnumerable<out T> T is convariant, so why do I still get the error?

Answer 1

Covariance only applies if there is a polymorphic relationship between the two types. In your case, TEnum and T are not constrained to be related, so covariance does not apply.

You could trivially fix this issue by casting your enumeration members directly to your target type:

if (projection == null)
    return Enum.GetValues(typeof(TEnum)).OfType<T>();

Edit: I would suggest eliminating the projection parameter, and define your method more simply like so:

public static IEnumerable<TEnum> AsEnumerable<TEnum>() where TEnum : struct
{
    if (!typeof(TEnum).IsEnum)
        throw new InvalidOperationException("Type parameter TEnum must be an enum");

    return Enum.GetValues(typeof(TEnum)).OfType<TEnum>();
}

If you do need to perform a projection, you could use the standard LINQ Select operation on the returned sequence:

var optionsA = AsEnumerable<RegexOptions>();
var optionsB = AsEnumerable<RegexOptions>().Select(o => o.ToString());

This will give you practically the same conciseness as your code, but save you the trouble of maintaining the optional parameter.

Edit₂: If you really want to define an overload for the projection, I would suggest implementing all the logic within it, and then call it using the identity function from the parameterless version:

public static IEnumerable<TEnum> AsEnumerable<TEnum>() where TEnum : struct
{
    return AsEnumerable<TEnum, TEnum>(e => e);
}

public static IEnumerable<TResult> AsEnumerable<TEnum, TResult>(
    Func<TEnum, TResult> projection) where TEnum : struct
{
    if (!typeof(TEnum).IsEnum)
        throw new InvalidOperationException("Type parameter TEnum must be an enum");

    return Enum.GetValues(typeof(TEnum)).OfType<TEnum>().Select(projection);
}

Sample calls:

var optionsA = AsEnumerable<RegexOptions>();
var optionsB = AsEnumerable<RegexOptions, string>(o => o.ToString());