What is the equivalence to getting an enum member by ordinal position when using EnumFormat?

Hi Tyler,

Been watching this for a while and I hope it finally gets included as it is a great addition to .NET IMHO.

I am in the process of converting my (simple) enum helper and have the following that I don’t know how to convert:

 /// <summary>
 ///     Class to assist with manipulating enums. These operate on the enum type as a whole and
 ///     are hence not extension methods for the enum members themselves.
 /// </summary>
 /// <typeparam name="T">Enumeration we are operating on.</typeparam>
 public static class SpYtEnumHelper<T> where T : struct, IConvertible
 {
     /// <summary>
     ///     Internal helper method to ensure that the type we are dealing with is an enumeration.
     /// </summary>
     /// <returns>
     ///     Returns the type information for the enumeration. Raises an exception if the type supplied is not an
     ///     enumeration.
     /// </returns>
     private static Type CheckIsEnum()
     {
         Type result = typeof(T);
         if (!result.IsEnum) throw new Exception("T must be an Enumeration type.");

         return result;
     }

     /// <summary>
     ///     Given the ordinal position of the member within the enumeration we return the enum member.
     /// </summary>
     /// <param name="aOrdinalPosition">Zero based position of the member within the enumeration.</param>
     /// <returns>Returns the enumeration member if found.</returns>
     /// ///
     /// <remarks>With an enum of MyEnum {Red = 3, Green = 5, Orange = 12} => GetMemberFromOrdinalPosition(1) = Green. </remarks>
     public static T GetMemberFromOrdinalPosition(int aOrdinalPosition)
     {
         Type enumType = CheckIsEnum();
         return (T) Enum.Parse(enumType, Enum.GetNames(typeof(T))[aOrdinalPosition]);
     }
}

So given:

enum NumericOperator
{
    [Symbol("="), Description("Is")]
    Equals = 2,
    [Symbol("!="), Description("Is not")]
    NotEquals,
    [Symbol("<")]
    LessThan,
    [Symbol(">="), PrimaryEnumMember] // PrimaryEnumMember indicates enum member as primary duplicate for extension methods
    GreaterThanOrEquals,
    NotLessThan = GreaterThanOrEquals,
    [Symbol(">")]
    GreaterThan,
    [Symbol("<="), PrimaryEnumMember]
    LessThanOrEquals,
    NotGreaterThan = LessThanOrEquals
}


/// <summary>
///     Tests for SpYtEnumHelper.
/// </summary>
[TestFixture]
public class SpYtEnumHelperTests : SpYtTestsBase
{
    [Test]
    public void DummyTest()
    {
        //GetMemberFromValue
        SpYtEnumHelper<NumericOperator>.GetMemberFromValue(3).ShouldBe(NumericOperator.NotEquals);
        Enums.GetMember<NumericOperator>("3", EnumFormat.DecimalValue).Value.ShouldBe(SpYtEnumHelper<NumericOperator>.GetMemberFromValue(3));

        //GetMemberFromOrdinalPosition
        SpYtEnumHelper<NumericOperator>.GetMemberFromOrdinalPosition(0).ShouldBe(NumericOperator.Equals);
        //Enums.GetMember<NumericOperator>("0", EnumFormat.EnumMemberValue).Value.ShouldBe(SpYtEnumHelper<NumericOperator>.GetMemberFromOrdinalPosition(0));
        //Enums.GetMember<NumericOperator>("0", EnumFormat.UnderlyingValue).Value.ShouldBe(SpYtEnumHelper<NumericOperator>.GetMemberFromOrdinalPosition(0));

    }
}

I am looking for the equivalence of my GetMemberFromOrdinalPosition() but none of the EnumFormat members appear to do that. While I realise I could do:

Enums.GetMembers<NumericOperator>().Skip(0).First().Value

I was hoping there was something more elegant I had missed?

[TylerBrinkley]

@natiki Just as an FYI the recently released v3.0.0 now returns an IReadOnlyList<T> instead of IEnumerable<T> for GetNames, GetValues, GetMembers, GetFlags, and GetFlagMembers.

[natiki]

I don’t think it’s a good fit for EnumFormat, especially as the notion of ordinal might change slightly in the future to match System.Enum which returns values in increasing bit-significance order as opposed

Which is why I suggested it, because then ultimately the changes in terms of internal structure will be hidden from the caller and can be managed by Enums.NET.

However I will use your suggestions and you close this one. Looking forward to https://github.com/TylerBrinkley/Enums.NET/issues/26#issuecomment-487576627 and hope Enums.NET gets up before .NET 5 😉