Should/could enums inherit the interfaces of their implemented types?

[Avid29]

First of all, for quality of life, this would remove a lot of frustration adding explicit casts when primitive's interface methods with enums.

This would also add real functionality that is currently missing. This would allow additional specification and functionality when using the generic Enum constraint.

Here's my incredibly specific use case from implementing ELF header parsing in C#:

Depending on if the file is 32/64 bit there's a different set of flags. The flags also need to be encoded in either big or little endian (a process which is already incredibly annoying to do with structs, but that's a different issue). This would allow the IBinaryIntger<T>.TryReadBigEndian, IBinaryIntger<T>.TryReadLittleEndian, IBinaryIntger<T>.TryWriteBigEndian, etc methods to be used on a where : Enum, IBinaryIntger<T> constrained generic type.

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct SectionHeader<TAddress, TFlags>
    where TAddress : unmanaged, IBinaryInteger<TAddress>, IUnsignedNumber<TAddress>
    where TFlags : unmanaged, Enum, IBinaryInteger<TFlags>, IUnsignedNumber<TFlags>
... 
    /// <summary>
    /// Attempts to read a section header from a <see cref="Stream"/>.
    /// </summary>
    /// <param name="stream">The stream of the module.</param>
    /// <param name="header">The header of the module.</param>
    /// <param name="littleEndian">If the module is expected to be little endian.</param>
    /// <returns><see cref="true"/> if header was successfully read. <see cref="false"/> otherwise.</returns>
    public static bool TryRead(Stream stream, out SectionHeader<TAddress, TFlags> header, bool littleEndian = false)
    {
        header = default;

        // Pre-declare explicit header components
        Unsafe.SkipInit(out uint name);
        Unsafe.SkipInit(out uint type);
        Unsafe.SkipInit(out TFlags flags);
        Unsafe.SkipInit(out TAddress vAddress);
        Unsafe.SkipInit(out TAddress offset);
        Unsafe.SkipInit(out TAddress size);
        Unsafe.SkipInit(out uint link);
        Unsafe.SkipInit(out uint info);
        Unsafe.SkipInit(out TAddress alignment);
        Unsafe.SkipInit(out TAddress entrySize);

        // Try reading explict header components
        bool success = stream.TryRead(out name, littleEndian) &&
                       stream.TryRead(out type, littleEndian) &&
                       stream.TryRead(out flags, littleEndian) &&
                       stream.TryRead(out vAddress, littleEndian) &&
                       stream.TryRead(out offset, littleEndian) &&
                       stream.TryRead(out size, littleEndian) &&
                       stream.TryRead(out link, littleEndian) &&
                       stream.TryRead(out info, littleEndian) &&
                       stream.TryRead(out alignment, littleEndian) &&
                       stream.TryRead(out entrySize, littleEndian);
        
        // Return if component reading failed
        if (!success)
            return false;

        // Assign explicit header components
        header.Name = name;
        header.Type = (Type)type;
        header.Flags = flags;
        header.VirtualAddress = vAddress;
        header.Offset = offset;
        header.Size = size;
        header.Link= link;
        header.Info = info;
        header.Alignment = alignment;
        header.EntrySize = entrySize;

        return true;
    }

    /// <summary>
    /// Attempts to write the section header to a stream.
    /// </summary>
    /// <param name="stream">The stream to write the header on.</param>
    /// <param name="littleEndian">If the module is to be written in little endian.</param>
    /// <returns><see cref="true"/> if header was successfully written. <see cref="false"/> otherwise.</returns>
    public readonly bool TryWrite(Stream stream, bool littleEndian)
    {
        // Try write explicit header components
        bool success = stream.TryWrite(Name, littleEndian) &&
                       stream.TryWrite((uint)Type, littleEndian) &&
                       stream.TryWrite(Flags, littleEndian) &&
                       stream.TryWrite(VirtualAddress, littleEndian) &&
                       stream.TryWrite(Offset, littleEndian) &&
                       stream.TryWrite(Size, littleEndian) &&
                       stream.TryWrite(Link, littleEndian) &&
                       stream.TryWrite(Info, littleEndian) &&
                       stream.TryWrite(Alignment, littleEndian) &&
                       stream.TryWrite(EntrySize, littleEndian);

        // Return if component writing failed
        if (!success)
            return false;

        stream.Flush();
        return true;
    }
    
    
/// <summary>
/// A class containing extensions for <see cref="Stream"/>.
/// </summary>
public static class StreamExtensions
{
    /// <summary>
    /// Reads a <see cref="IBinaryInteger{TSelf}"/> from a stream.
    /// </summary>
    /// <typeparam name="T">The <see cref="IBinaryInteger{TSelf}"/> type.</typeparam>
    /// <param name="stream">The stream to write to.</param>
    /// <param name="value">The next <typeparamref name="T"/> from the stream.</param>
    /// <param name="littleEndian">Indicates if the bytes should be read in little endian.</param>
    /// <returns><see cref="true"/> if value was successfully read. <see cref="false"/> otherwise.</returns>
    public static bool TryRead<T>(this Stream stream, out T value, bool littleEndian = false)
        where T : unmanaged, IBinaryInteger<T>
    {
        // TODO: This doesn't feel like it should be neccesary.
        bool signed = (-T.MultiplicativeIdentity) < T.Zero;

        // Initialize results
        bool success = false;
        value = default;

        // Create temporary array
        byte[]? pooledArray = null;
        var byteCount = value.GetByteCount();
        var bytes = byteCount <= 8 ?
            stackalloc byte[byteCount] :
            (pooledArray = ArrayPool<byte>.Shared.Rent(byteCount));

        // Read bytes and parse
        int realCount = stream.Read(bytes);
        if (realCount == byteCount)
        {
            success = littleEndian
                ? T.TryReadLittleEndian(bytes, !signed, out value)
                : T.TryReadBigEndian(bytes, !signed, out value);
        }

        // Free temporary array
        if (pooledArray is not null)
        {
            ArrayPool<byte>.Shared.Return(pooledArray);
        }

        return success;
    }

    /// <summary>
    /// Writes a <see cref="IBinaryInteger{TSelf}"/> to a stream.
    /// </summary>
    /// <typeparam name="T">The <see cref="IBinaryInteger{TSelf}"/> type.</typeparam>
    /// <param name="stream">The stream to write to.</param>
    /// <param name="value">The value to write to the stream.</param>
    /// <param name="littleEndian">Indicates if the bytes should be written in little endian.</param>
    /// <returns><see cref="true"/> if value was successfully written. <see cref="false"/> otherwise.</returns>
    public static bool TryWrite<T>(this Stream stream, T value, bool littleEndian = false)
        where T : unmanaged, IBinaryInteger<T>
    {
        // Initialize results
        bool success = false;

        // Create temporary array
        byte[]? pooledArray = null;
        var byteCount = value.GetByteCount();
        var bytes = byteCount <= 8 ?
            stackalloc byte[byteCount] :
            (pooledArray = ArrayPool<byte>.Shared.Rent(byteCount));

        // Write bytes
        Unsafe.SkipInit(out int bytesWritten);
        success = littleEndian
            ? value.TryWriteLittleEndian(bytes, out bytesWritten)
            : value.TryWriteBigEndian(bytes, out bytesWritten);

        if (success && bytesWritten == byteCount)
        {
            stream.Write(bytes);
        }

        // Free temporary array
        if (pooledArray is not null)
        {
            ArrayPool<byte>.Shared.Return(pooledArray);
        }

        return success;
    }
}

[Avid29]

My bad. This is kind of a duplicate of #8789 and #5093 and probably more