Implicitly cast an enum to its base integer type

[B3zaleel]

An enum's base integer type is usually fixed, however, when comparing an integer to an enum, we need to perform an explicit cast when normal integer-integer comparisons could apply.

Example case:

enum Corners : byte
{
    Top = 1,
    Bottom = 2,
}

int corner = 1;

// byte casting here feels verbose
if (corner == (byte)Corners.Top)
{
    Console.WriteLine("Foo");
}

// this would be valid if enums can be implicitly converted to their base types
if (corner == Corners.Top)
{
    Console.WriteLine("Bar");
}

[HaloFour]

This behavior is intentional, the verbosity is for clarity and to avoid potential mistakes. The cast informs the compiler that you really intended to perform that comparison.

[ParsaMehdipour]

Intresting

[B3zaleel]

That makes sense although, it would have been nice to make that optional because it's odd that I can't just compare an enum, which stores integer constants, to an integer. With the way enums are in C# right now, they technically aren't much different from a static class containing constant integer fields.

[ParsaMehdipour]

I believe this requirement for explicit casting serves several purposes:

1. Type safety: It prevents accidental comparisons between enums and integers, which might lead to logical errors in the code.

2. Code clarity: Explicit casts make it clear to readers that you're intentionally comparing an enum to a specific integer value.

3. Avoiding ambiguity: Some enum values might have the same underlying integer value, so explicit casting ensures you're using the correct type.

[B3zaleel]

@HaloFour @ParsaMehdipour Thank you for answering the question.

[Tinister]

Will the extensions feature allow for this?

implicit extension EnumExtensions<T> for T where T : struct, Enum
{
    public static implicit operator int(T value) => // some MemoryMarshal magic
}

[CyrusNajmabadi]

My preference is that we not allow a user defined conversion for where a language conversion exists (explicit or implicit).