Add EnumMemberSelection.DefinitionOrder and EnumMember.DefinitionIndex

Src/Enums.NET.Test/EnumsTest.cs

@@ -138,6 +138,8 @@ public void GetValues()
 
         Assert.Equal([DisplayAttributeEnum.Up, DisplayAttributeEnum.Down, DisplayAttributeEnum.Left, DisplayAttributeEnum.Right], GetValues<DisplayAttributeEnum>());
         Assert.Equal([DisplayAttributeEnum.Left, DisplayAttributeEnum.Up, DisplayAttributeEnum.Down, DisplayAttributeEnum.Right], GetValues<DisplayAttributeEnum>(EnumMemberSelection.DisplayOrder));
+        Assert.Equal([DefinitionOrderEnum.First, DefinitionOrderEnum.Fourth, DefinitionOrderEnum.Third, DefinitionOrderEnum.Second], GetValues<DefinitionOrderEnum>());
+        Assert.Equal([DefinitionOrderEnum.First, DefinitionOrderEnum.Second, DefinitionOrderEnum.Third, DefinitionOrderEnum.Fourth], GetValues<DefinitionOrderEnum>(EnumMemberSelection.DefinitionOrder));
     }
 
     [Fact]

Src/Enums.NET.TestEnums/DefinitionOrderEnum.cs

@@ -0,0 +1,9 @@
+namespace EnumsNET.Tests.TestEnums;
+
+public enum DefinitionOrderEnum
+{
+    First = 1,
+    Second = 5,
+    Third = 3,
+    Fourth = 2
+}

Src/Enums.NET/EnumCache.cs

@@ -339,13 +339,19 @@ protected EnumCache(Type enumType, IEnumBridge<TUnderlying, TUnderlyingOperation
 
     public sealed override int GetMemberCount(EnumMemberSelection selection)
     {
-        return selection switch
+        if (selection is EnumMemberSelection.All or EnumMemberSelection.DisplayOrder or EnumMemberSelection.DefinitionOrder)
         {
-            EnumMemberSelection.All or EnumMemberSelection.DisplayOrder => _members.Length,
-            EnumMemberSelection.Flags or EnumMemberSelection.Flags | EnumMemberSelection.Distinct or EnumMemberSelection.Flags | EnumMemberSelection.DisplayOrder or EnumMemberSelection.Flags | EnumMemberSelection.DisplayOrder | EnumMemberSelection.Distinct => GetFlagCount(),
-            EnumMemberSelection.Distinct or EnumMemberSelection.Distinct | EnumMemberSelection.DisplayOrder => _distinctCount,
-            _ => throw new ArgumentException($"invalid value of {selection.AsString()} for EnumMemberSelection", nameof(selection)),
-        };
+            return _members.Length;
+        }
+        if (selection.HasAnyFlags(EnumMemberSelection.Flags))
+        {
+            return GetFlagCount();
+        }
+        if (selection.HasAnyFlags(EnumMemberSelection.Distinct))
+        {
+            return _distinctCount;
+        }
+        throw new ArgumentException($"invalid value of {selection.AsString()} for EnumMemberSelection", nameof(selection));
     }
 
     protected sealed override IReadOnlyList<EnumMember> GetMembersInternal(EnumMemberSelection selection, bool cached) => EnumBridge.CreateMembersContainer(GetMembersInternal(selection), GetMemberCount(selection), cached);
@@ -356,16 +362,28 @@ public sealed override int GetMemberCount(EnumMemberSelection selection)
 
     private IEnumerable<EnumMemberInternal<TUnderlying, TUnderlyingOperations>> GetMembersInternal(EnumMemberSelection selection)
     {
-        IEnumerable<EnumMemberInternal<TUnderlying, TUnderlyingOperations>> members = selection switch
+        IEnumerable<EnumMemberInternal<TUnderlying, TUnderlyingOperations>> members;
+        if (selection is EnumMemberSelection.All or EnumMemberSelection.DisplayOrder or EnumMemberSelection.DefinitionOrder)
         {
-            EnumMemberSelection.All or EnumMemberSelection.DisplayOrder => _members,
-            EnumMemberSelection.Flags or EnumMemberSelection.Flags | EnumMemberSelection.Distinct or EnumMemberSelection.Flags | EnumMemberSelection.DisplayOrder or EnumMemberSelection.Flags | EnumMemberSelection.DisplayOrder | EnumMemberSelection.Distinct => EnumerateFlagMembers(_allFlags),
-            EnumMemberSelection.Distinct or EnumMemberSelection.Distinct | EnumMemberSelection.DisplayOrder => _hasDuplicateValues ? _members.Distinct() : _members,
-            _ => throw new ArgumentException($"invalid value of {selection.AsString()} for EnumMemberSelection", nameof(selection)),
-        };
+            members = _members;
+        }
+        else if (selection.HasAnyFlags(EnumMemberSelection.Flags))
+        {
+            members = EnumerateFlagMembers(_allFlags);
+        }
+        else if (selection.HasAnyFlags(EnumMemberSelection.Distinct))
+        {
+            members = _hasDuplicateValues ? _members.Distinct() : _members;
+        }
+        else
+        {
+            throw new ArgumentException($"invalid value of {selection.AsString()} for EnumMemberSelection", nameof(selection));
+        }
         return selection.HasAnyFlags(EnumMemberSelection.DisplayOrder)
             ? members.OrderBy(m => m.Attributes.Get<DisplayAttribute>()?.GetOrder() ?? int.MaxValue)
-            : members;
+            : selection.HasAnyFlags(EnumMemberSelection.DefinitionOrder)
+                ? members.OrderBy(m => m.DefinitionIndex)
+                : members;
     }
     #endregion
 

Src/Enums.NET/EnumMember.cs

@@ -51,6 +51,11 @@ public abstract class EnumMember : IComparable<EnumMember>, IEquatable<EnumMembe
     /// </summary>
     public AttributeCollection Attributes => Member.Attributes;
 
+    /// <summary>
+    /// The enum member's definition index.
+    /// </summary>
+    public int DefinitionIndex => Member.DefinitionIndex;
+
     private protected EnumMember(EnumMemberInternal member)
     {
         Member = member;

Src/Enums.NET/EnumMemberInternal.cs

@@ -38,6 +38,7 @@ internal abstract class EnumMemberInternal : IComparable<EnumMemberInternal>
 {
     public readonly string Name;
     public readonly AttributeCollection Attributes;
+    public readonly int DefinitionIndex;
     private EnumMember? _enumMember;
 
     public EnumMember EnumMember
@@ -51,10 +52,11 @@ public EnumMember EnumMember
 
     private protected abstract EnumMember CreateEnumMember();
 
-    protected EnumMemberInternal(string name, AttributeCollection attributes)
+    protected EnumMemberInternal(string name, AttributeCollection attributes, int definitionIndex)
     {
         Name = name;
         Attributes = attributes;
+        DefinitionIndex = definitionIndex;
     }
 
     public abstract void GetValue(ref byte result);
@@ -110,9 +112,9 @@ internal sealed class EnumMemberInternal<TUnderlying, TUnderlyingOperations> : E
     private protected override EnumMember CreateEnumMember() => EnumCache.EnumBridge.CreateEnumMember(this);
 
 #pragma warning disable CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable. Gets set soon after creation but cannot be set at creation as EnumCache is not created yet
-    public EnumMemberInternal(TUnderlying value, string name, AttributeCollection attributes)
+    public EnumMemberInternal(TUnderlying value, string name, AttributeCollection attributes, int definitionIndex)
 #pragma warning restore CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable.
-        : base(name, attributes)
+        : base(name, attributes, definitionIndex)
     {
         Value = value;
     }

Src/Enums.NET/EnumMemberSelection.cs

@@ -49,5 +49,9 @@ public enum EnumMemberSelection
     /// <summary>
     /// Include enum members in display order using <see cref="DisplayAttribute.Order"/>.
     /// </summary>
-    DisplayOrder = 4
+    DisplayOrder = 4,
+    /// <summary>
+    /// Include enum members in definition order as opposed to by value.
+    /// </summary>
+    DefinitionOrder = 8
 }

Src/Enums.NET/Enums.cs

@@ -113,7 +113,7 @@ private EnumCache CreateCache(IEnumBridge<TUnderlying, TUnderlyingOperations> en
                 var attributesArray = Attribute.GetCustomAttributes(field, false);
                 var attributes = attributesArray.Length == 0 ? AttributeCollection.Empty : new AttributeCollection(attributesArray);
 
-                var member = new EnumMemberInternal<TUnderlying, TUnderlyingOperations>(value, name, attributes);
+                var member = new EnumMemberInternal<TUnderlying, TUnderlyingOperations>(value, name, attributes, i);
                 var index = i;
                 var isPrimary = attributes.Has<PrimaryEnumMemberAttribute>();
 #if NET7_0_OR_GREATER