Missing features compared to Enums.NET (feature parity discussion)

[simonebortolin]

Hi 👋

while evaluating NetEscapades.EnumGenerators as an alternative to Enums.NET, I noticed that several advanced enum/flags features are currently missing.

This is not necessarily a problem (the goals of the library are different), but I think it would be useful to document or discuss possible gaps — especially for users migrating from Enums.NET.

Below is a list of notable missing APIs with short explanations.

1. Flag operations

Enums.NET provides a rich set of utilities for [Flags] enums, which are currently not available.

Missing APIs (https://github.com/TylerBrinkley/Enums.NET/blob/master/Src/Enums.NET/FlagEnums.cs)

• HasAnyFlags()
• HasAnyFlags(otherFlags)
• HasAllFlags()
• HasAllFlags(otherFlags)
• ToggleFlags()
• GetFlags()
• GetFlagMembers()
• GetFlagCount()
• GetAllFlags()
• IsValidFlagCombination()

2. Formatting of flag combinations

Missing API

• FormatFlags(...) (or similat ToString with FormatFlags paramters)
  Current limitation

The generator explicitly falls back to:

• default ToString() for non-trivial flag combinations:

if (enumToGenerate.HasFlags)
        {
            // We currently don't handle ToString of custom flag-combinations, so lets fall back to the default
            sb.Append(
                """

                                _ => value.ToString(),
                            };
                """);
        }

This means:

• no control over delimiter (, vs custom)
• no deterministic formatting
• no handling of invalid combinations

3. Advanced parsing & validation

Missing capabilities

• Validation strategies (e.g. reject undefined values)
• Safe conversion with overflow checks
• Differentiation between:
  • undefined values
  • invalid flag combinations

4. Reflection-like enum metadata APIs

Missing APIs

• GetMembers()
• GetNames()
• GetValues()
• GetMemberCount()

5. Handling of edge cases

Enums.NET explicitly handles:

• non-contiguous enums
• duplicated values (aliases)
• “primary” enum members
• invalid / undefined values
• mixed flag combinations

I got a bit of help from Copilot to write this issue; I know there was a similar issue at https://github.com/andrewlock/NetEscapades. EnumGenerators/issues/240 and, to be honest, I fully agree with the statement

I’ve been very hesitant to add new features to the library ‘just because I can’, especially where there are simple alternatives that don’t force everyone to deal with the noise of new methods

but I also think there should be a library that has everything, not five different libraries for the same thing, perhaps with an opt-in/opt-out mechanism so that the generation of certain things can be enabled or disabled via attributes. Also with a view to libraries governance and reducing their excessive use....

[andrewlock]

I got a bit of help from Copilot to write this issue

Don't take this the wrong way, but it shows 😬 Some of this is factually inaccurate (claims missing features, that are not missing), and it's very unclear what you're requesting for some of these 🤔

If you could provide examples for each of these methods, including how you would expect them to work and what the generated code should look like I'd be happy to consider them.

but I also think there should be a library that has everything, not five different libraries for the same thing, perhaps with an opt-in/opt-out mechanism so that the generation of certain things can be enabled or disabled via attributes

FWIW, I don't want this library to be the "everything" library 🙂 If Enums.NET is that for you, feel free to use it 😅 I don't want to add endless options for rare use cases, and I'm really not sure I want to add complex configuration for controlling generation - I've been down that route before, and it was terrible to maintain, and terrible to use 😅

But that said, like I say, I'm not averse to adding new APIs that are popular, they just need to be more clearly defined 🙂

[simonebortolin]

If Enums.NET is that for you, feel free to use it 😅

Enums.NET is too slow 😅 and use a unsafe magaed code... I really dosen't like the implementation of Enums.NET, And that’s why I opened the issue. Same for other enum library on NET

But that said, like I say, I'm not averse to adding new APIs that are popular, they just need to be more clearly defined 🙂

Yes, you're right, but I need some time to work out the details and put them into practice. That's why I've tried to summarise my request using Copilot

[simonebortolin]

For:

• HasAnyFlags()
• HasAnyFlags(otherFlags)
• HasAllFlags()
• HasAllFlags(otherFlags)
• ToggleFlags()

[EnumExtensions]
public partial enum Permissions
{
    None = 0,
    Read = 1 << 0,
    Write = 1 << 1,
    Execute = 1 << 2,
    Delete = 1 << 3,
}

public static partial class PermissionsExtensions
{
    public static bool HasAnyFlags(this Permissions value)
    {
        return (int)value != 0; // edit int with the correct type of the enum
    }

    public static bool HasAnyFlags(this Permissions value, Permissions otherFlags)
    {
        return (value & otherFlags) != 0;
    }

    public static bool HasAllFlags(this Permissions value)
    {
        var allFlags = Permissions.Read | Permissions.Write | Permissions.Execute | Permissions.Delete;
        return (value & allFlags) == allFlags;
    }

    public static bool HasAllFlags(this Permissions value, Permissions otherFlags)
    {
        return (value & otherFlags) == otherFlags;
    }

    public static Permissions ToggleFlags(this Permissions value, Permissions flagsToToggle)
    {
        return value ^ flagsToToggle;
    }
}

For:

• GetFlags
• GetFlagCount

public static partial class PermissionsExtensions
{
    public static Permissions[] GetFlags(this Permissions value)
    {
        var flags = new List<Permissions>();

        if ((value & Permissions.Read) == Permissions.Read) flags.Add(Permissions.Read);
        if ((value & Permissions.Write) == Permissions.Write) flags.Add(Permissions.Write);
        if ((value & Permissions.Execute) == Permissions.Execute) flags.Add(Permissions.Execute);
        if ((value & Permissions.Delete) == Permissions.Delete) flags.Add(Permissions.Delete);

        return flags.ToArray();
    }
public static int GetFlagCount()
{
    return 4;  
}
}

[andrewlock]

OK, cool, we can work with that, thanks 😄

HasAnyFlags (both overloads), HasAllFlags (version with a specific value), and ToggleFlags, are all completely generic - implementing them as source generated versions isn't really worth it IMO:

public static partial class GenericExtensions
{
    public static bool HasAnyFlags(this T value) where T : enum
    {
        return (int)value != 0; // edit int with the correct type of the enum
    }

    public static bool HasAnyFlags(this T value, T otherFlags) where T : enum
    {
        return (value & otherFlags) != 0;
    }

    public static bool HasAllFlags(this T value, T otherFlags) where T : enum
    {
        return (value & otherFlags) == otherFlags;
    }

    public static T ToggleFlags(this T value, T flagsToToggle) where T : enum
    {
        return value ^ flagsToToggle;
    }
}

Maybe there's value in shipping those as a separate package, but I'm not sure if that's something this package should be getting into 🤔 Maybe we could/should just ship it in the runtime dependencies package, but it's a bit weird to have them there too. Adding all of them to each of the extension classes would lead to code bloat though. Fundamentally, the idea of the library is to use source generation to replace the "slow" code paths you get in the runtime otherwise, which these aren't.

GetFlagCount seems reasonable, but I'm not actually sure what the expected behaviour would be if, for example, you had this:

public enum Permissions
{
    None = 0,
    Read = 1 << 0,
    Write = 1 << 1,
    ReadWrite = Read | Write,
    Execute = 1 << 2,
    Delete = 1 << 3,
}

Should it be 4? 5? 6? And what are you going to use GetFlagCount for anyway? Honestly, the ambiguous nature of flags in general makes me hesitate to ship some of these 😅

Similarly, for GetFlags(), what would you expect here? I think this just isn't as easy as we'd like. It's also really not performant as written... But if flags are using the "correct" powers-of-two flags, I think you can essentially create a zero-allocation generic version, something like this (quick chatgpt generated version, could probably improve it further):

public static int GetFlags(this Permissions value, Span<Permissions> buffer)
{
    int count = 0;
    int v = (int)value;

    while (v != 0)
    {
        int flag = v & -v; // isolate lowest set bit
        buffer[count++] = (Permissions)flag;
        v &= v - 1; // clear that bit
    }

    return count;
}

[simonebortolin]

implementing them as source generated versions isn't really worth it IMO:

I'm not sure, the type can be int or long or other type... We can approx it to int🤔

Should it be 4? 5? 6? And what are you going to use GetFlagCount for anyway? Honestly, the ambiguous nature of flags in general makes me hesitate to ship some of these 😅

For use on wpf/windows form/avalonia with a custom combobox that discover the value at runtime. I think that 4/5/6 can be choice from a enum(?)

Similarly, for GetFlags(), what would you expect here? I think this just isn't as easy as we'd like. It's also really not performant as written... But if flags are using the "correct" powers-of-two flags, I think you can essentially create a zero-allocation generic version, something like this (quick chatgpt generated version, could probably improve it further):

This return a int, not the ienumerable, but ok

[andrewlock]

I'm not sure, the type can be int or long or other type... We can approx it to int🤔

Oh yeah, good point, that's a good justification for adding them - you can't do a generic implementation, because you need to call the AsUnderlyingType() to do it properly 👍

For use on wpf/windows form/avalonia with a custom combobox that discover the value at runtime

I'm still not sure exactly how we should expect combination flags to be handled... That's part of the reason I've shied away from these things, everyone seems to use them slightly differently 😓

This return a int, not the ienumerable, but ok

Yeah, this is the standard pattern for "safe" Try methods, in which you render the values into a Span<T> buffer, and return the number of items from the method. It means you can do zero-allocation versions, instead of forcing a new list + array for every method call 🙂