Why are generic Parse methods for Enum types constrained with struct rather than directly with Enum itself?

[egvijayanand]

Ref. Link:

https://learn.microsoft.com/en-us/dotnet/api/system.enum.parse?view=net-9.0#system-enum-parse-1(system-string)

Why is the generic type parameter set as struct when can be directly constrained on the Enum itself, the ultimate base type for all enum types?

public static TEnum Parse<TEnum>(string value) where TEnum : struct;

Rather it should have been defined as below:

public static TEnum Parse<TEnum>(string value) where TEnum : Enum;

Since the type constraint is defined as a struct, unable to cast the resulting value to an integer.

I am attempting to create a generic method that returns a dictionary when Enum is provided as its input.

I've constrained the generic type to be T : Enum and since Environment.SpecialFolder has two items (MyDocuments and Personal) pointing to the same value. Will get the names list and then Parse each one to int value.

// Invocation - EnumNamedValues<DayOfWeek>();
public static IDictionary<int, string?> EnumNamedValues<T>() where T : Enum
{
    var items = new Dictionary<int, string?>();
    var enumType = typeof(T);
    int item;

    foreach (var name in Enum.GetNames(enumType))
    {
        //item = (int)Enum.Parse<T>(name); // Not working because of the incorrect type constraint of Parse method
        item = (int)Enum.Parse(enumType, name);

        if (items.ContainsKey(item))
        {
            items[item] += ", " + name;
        }
        else
        {
            items.Add(item, name);
        }
    }

    return items;
}

This is the error message when the generic Parse method is used, which is incorrect and error-prone as any struct value can be used here. Defeats the ultimate purpose of using generic constraints.

CS0453 The type 'T' must be a non-nullable value type in order to use it as parameter 'TEnum' in the generic type or method 'Enum.Parse<TEnum>(ReadOnlySpan<char>)'

[egvijayanand]

The only good thing here is that the Parse method has a runtime validation that prevents it from using a type that is not an Enum.

But when I update the generic type constraint of my method to be of struct to match with that of Parse then the cast fails.

// For any given enum, casting to type int should work. If Parse is successful, this should work.
var item = (int)Enum.Parse<T>(name); // Cannot convert type 'T' to 'int'

[huoyaoyuan]

// For any given enum, casting to type int should work.

Note that enum can be long based which is larger than int.

Also in CLR, operation on generic type are limited to those present in generic constraint only. Although every known enum type has conversion to its underlying numeric type, there is no representation for the conversion with unknown enum type.

The only workaround is IConvertible now.

[egvijayanand]

Note that enum can be long based which is larger than int.

That will only result in data loss and not conversion and not compilation errors.

It's not about int, but rather converting to a numeric type. For context, have specified it as int.

That generic constraint is my concern. It calls for an update.

I'll try the workaround for the time being.

[CyrusNajmabadi]

but rather converting to a numeric type.

Enums don't implement a numeric type in a generic fashion. So there's no generic way to convert to a numeric type.

[CyrusNajmabadi]

That generic constraint is my concern. It calls for an update.

If you want an update to a generic constraint, you'll have to explain deeply how it would actually work. Including how it woudl be encoded, what capabilities it woudl provide the language/runtime, and how that functionality would actually be implemented.

[huoyaoyuan]

The correct constraint is struct, Enum. However, the method was introduced before Enum is supported in generic constraint.

Your caller method should also be constrained with struct, Enum. This disallows the base type Enum itself.

[egvijayanand]

Another scenario:

[huoyaoyuan]

integral numeric types so converting to integral type should have been included if there's a claim that Enums can explicitly specified as a generic type constraint.

Again, that would require a enhanced enum constraint, not the current System.Enum constraint.

Another scenario:

T? is the correct type for generics that not constraint to struct. struct, Enum constraint should be used for any new function that doesn't have compatibility debt.

[egvijayanand]

integral numeric types so converting to integral type should have been included if there's a claim that Enums can explicitly specified as a generic type constraint.

Again, that would require a enhanced enum constraint, not the current System.Enum constraint.

Another scenario:

T? is the correct type for generics that not constraint to struct. struct, Enum constraint should be used for any new function that doesn't have compatibility debt.

It seems Enum generic type implementation is short-circuited, struct constraint with an additional runtime check.

[huoyaoyuan]

It seems Enum generic type implementation is short-circuited, struct constraint with an additional runtime check.

Yes, it was introduced before Enum can be used in constraint, so it can only use struct then.
Changing from struct to the correct struct, Enum constraint is a breaking change.
You can see methods introduced later (GetValues, GetNames) are constrained with struct, Enum. Parse just came too early.

[CyrusNajmabadi]

as Enums are integral numeric types

THere is no non-generic 'integral numeric type'. So it's not possible to treat enums generically as some integral numeric type. There is INumber<T>, but that's not something exposable on top of Enum itself as each enum type may have a different integral numberic type it uses as its representation.

Furthermore, enums are not required to be integral numeric types at all. For example, the clr has this definition for enums:

II.14.3 Enums

An enum (short for enumeration) defines a set of symbols that all have the same type. A type shall be an enum if and only if it has an immediate base type of System.Enum. Since System.Enum itself has an immediate base type of System.ValueType, (see Partition IV
) enums are value types (§II.13 ) The symbols of an enum are ... one of { bool, char, ...

So from teh runtime's perspective, an enum can have a bool or char base type (neither of which are integral numeric types). Note: different languages might have their own additional restrictions on this (like disallowing 'bool'). But it's all legal from teh runtime's perspective, and it is the runtime that would have to enable some sort of 'convert to numeric' instruction to support arbitrary conversion of an enum in a generic context to an integral value.