Getting attributes from enum values in C#, circa 2023

[IanKemp]

Currently, in order to get an attribute from an enum value you have to use some relatively arcane code that harks back to the days of .NET Framework 2.0 (example from https://stackoverflow.com/a/9276348/70345):

    public static T GetAttributeOfType<T>(this Enum enumVal) where T:System.Attribute
    {
        var type = enumVal.GetType();
        var memInfo = type.GetMember(enumVal.ToString());
        var attributes = memInfo[0].GetCustomAttributes(typeof(T), false);
        return (attributes.Length > 0) ? (T)attributes[0] : null;
    }

with usage:

string desc = myEnumVariable.GetAttributeOfType<DescriptionAttribute>().Description;

While this can be refactored to be somewhat more concise using newer C# features like the null-propagating operator, as far as I'm aware the underlying mechanism for accomplishing this remains the same with the latest version of C#:

• get the type of the underlying enum
• use that type to get the MemberInfo pointing to the enum value by converting that value to a string
• call GetCustomAttributes on the MemberInfo, passing in the type of the desired attribute
• return the first attribute found, or null if none

While this is not particularly onerous, I'm also pretty sure that almost every company in the world with a C# codebase has some variant of the above method in it somewhere. It definitely feels like functionality that should be in the BCL, not just because of the commonality of the need for something like this, but also because my assumption is that the method as presented is not particularly performant (which is called out in an answer on the same SO question). And calling ToString to lookup a MemberInfo just feels yucky.

Anyhow, is the provided code still the simplest way to accomplish this functionality today, or are there new features of C# that could make it simpler, more concise and more performant?

[tfenise]

Wouldn't it be more performant to just cache the relevant data in something like a Dictionary<(Type AttributeType, Enum EnumValue), Attribute> (or the new FrozenDictionary<,>) ? The code would be more complicated, though.

You could consider proposing a new reflection API that gets the MemberInfo corresponding to an enum value.

[Fabi]

Wouldn't it be more performant to just cache the relevant data in something like a Dictionary<(Type AttributeType, Enum EnumValue), Attribute> (or the new FrozenDictionary<,>) ? The code would be more complicated, though.

You could consider proposing a new reflection API that gets the MemberInfo corresponding to an enum value.

But accessing such a dictionary is pretty slow

[colejohnson66]

Have you benchmarked that? Reflection is almost certainly worse than a dictionary lookup.