Attribute von Enums Wert erhalten

Sollte dies tun, was Sie brauchen.

var type = typeof(FunkyAttributesEnum);
var memInfo = type.GetMember(FunkyAttributesEnum.NameWithoutSpaces1.ToString());
var attributes = memInfo[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
var description = ((DescriptionAttribute)attributes[0]).Description;

InformationsquelleAutor der Antwort Bryan Rowe

Dies ist eine generische Implementierung verwendet einen lambda-Ausdruck für die Auswahl

public static Expected GetAttributeValue<T, Expected>(this Enum enumeration, Func<T, Expected> expression)
    where T : Attribute
{
    T attribute =
      enumeration
        .GetType()
        .GetMember(enumeration.ToString())
        .Where(member => member.MemberType == MemberTypes.Field)
        .FirstOrDefault()
        .GetCustomAttributes(typeof(T), false)
        .Cast<T>()
        .SingleOrDefault();

    if (attribute == null)
        return default(Expected);

    return expression(attribute);
}

Nennen mag:

string description = targetLevel.GetAttributeValue<DescriptionAttribute, string>(x => x.Description);

InformationsquelleAutor der Antwort Scott Belchak

Neben AdamCrawford Antworthabe ich weitere erstellt eine spezielle Erweiterung-Methoden, die Einspeisung der es um die Beschreibung zu erhalten.

public static string GetAttributeDescription(this Enum enumValue)
{
    var attribute = enumValue.GetAttributeOfType<DescriptionAttribute>();
    return attribute == null ? String.Empty : attribute.Description;
} 

daher, um die Beschreibung zu erhalten, können Sie entweder verwenden Sie die original-extension-Methode als

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

oder Sie können einfach rufen Sie die extension-Methode hier:

string desc = myEnumVariable.GetAttributeDescription();

Sollte hoffentlich machen Sie Ihren code ein wenig lesbarer zu gestalten.

InformationsquelleAutor der Antwort FunksMaName

Hier ist der code, um Informationen von einem Display-Attribut. Es verwendet eine generische Methode zum abrufen des Attributs. Wenn das Attribut nicht gefunden wird, wandelt es den enum-Wert einen string mit pascal/camel-case konvertiert Titel Fall (code erhalten hier)

public static class EnumHelper
{
    //Get the Name value of the Display attribute if the   
    //enum has one, otherwise use the value converted to title case.  
    public static string GetDisplayName<TEnum>(this TEnum value)
        where TEnum : struct, IConvertible
    {
        var attr = value.GetAttributeOfType<TEnum, DisplayAttribute>();
        return attr == null ? value.ToString().ToSpacedTitleCase() : attr.Name;
    }

    //Get the ShortName value of the Display attribute if the   
    //enum has one, otherwise use the value converted to title case.  
    public static string GetDisplayShortName<TEnum>(this TEnum value)
        where TEnum : struct, IConvertible
    {
        var attr = value.GetAttributeOfType<TEnum, DisplayAttribute>();
        return attr == null ? value.ToString().ToSpacedTitleCase() : attr.ShortName;
    }

    ///<summary>
    ///Gets an attribute on an enum field value
    ///</summary>
    ///<typeparam name="TEnum">The enum type</typeparam>
    ///<typeparam name="T">The type of the attribute you want to retrieve</typeparam>
    ///<param name="value">The enum value</param>
    ///<returns>The attribute of type T that exists on the enum value</returns>
    private static T GetAttributeOfType<TEnum, T>(this TEnum value)
        where TEnum : struct, IConvertible
        where T : Attribute
    {

        return value.GetType()
                    .GetMember(value.ToString())
                    .First()
                    .GetCustomAttributes(false)
                    .OfType<T>()
                    .LastOrDefault();
    }
}

Ist und diese Erweiterung-Methode für strings, für die Konvertierung in Titel Fall:

    ///<summary>
    ///Converts camel case or pascal case to separate words with title case
    ///</summary>
    ///<param name="s"></param>
    ///<returns></returns>
    public static string ToSpacedTitleCase(this string s)
    {
        //https://stackoverflow.com/a/155486/150342
        CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture;
        TextInfo textInfo = cultureInfo.TextInfo;
        return textInfo
           .ToTitleCase(Regex.Replace(s, 
                        "([a-z](?=[A-Z0-9])|[A-Z](?=[A-Z][a-z]))", "$1 "));
    }

InformationsquelleAutor der Antwort Colin

Ich implementiert diese Erweiterung Methode um die Beschreibung von enum-Werte. Es funktioniert für alle Art von enums.

public static class EnumExtension
{
    public static string ToDescription(this System.Enum value)
    {
        FieldInfo fi = value.GetType().GetField(value.ToString());
        var attributes = (DescriptionAttribute[])fi.GetCustomAttributes(typeof(DescriptionAttribute), false);
        return attributes.Length > 0 ? attributes[0].Description : value.ToString();
    }
}

InformationsquelleAutor der Antwort Nick N.

Hinzufügen meine Lösung für Net Framework und NetCore.

Habe ich dies für meine Net-Framework-Implementierung:

public static class EnumerationExtension
{
    public static string Description( this Enum value )
    {
        //get attributes  
        var field = value.GetType().GetField( value.ToString() );
        var attributes = field.GetCustomAttributes( typeof( DescriptionAttribute ), false );

        //return description
        return attributes.Any() ? ( (DescriptionAttribute)attributes.ElementAt( 0 ) ).Description : "Description Not Found";
    }
}

Funktioniert das nicht bei NetCore also habe ich es geändert, um dies zu tun:

public static class EnumerationExtension
{
    public static string Description( this Enum value )
    {
        //get attributes  
        var field = value.GetType().GetField( value.ToString() );
        var attributes = field.GetCustomAttributes( false );

        //Description is in a hidden Attribute class called DisplayAttribute
        //Not to be confused with DisplayNameAttribute
        dynamic displayAttribute = null;

        if (attributes.Any())
        {
            displayAttribute = attributes.ElementAt( 0 );
        }

        //return description
        return displayAttribute?.Description ?? "Description Not Found";
    }
}

Enumeration Beispiel:

public enum ExportTypes
{
    [Display( Name = "csv", Description = "text/csv" )]
    CSV = 0
}

Beispiel für statische Hinzugefügt:

var myDescription = myEnum.Description();

InformationsquelleAutor der Antwort HouseCat

Diese Erweiterung Methode erhalten Sie eine string-Darstellung eines enum-Wert mit seiner XmlEnumAttribute. Wenn keine XmlEnumAttribute vorhanden ist, fällt es zurück zu enum.ToString().

public static string ToStringUsingXmlEnumAttribute<T>(this T enumValue)
    where T: struct, IConvertible
{
    if (!typeof(T).IsEnum)
    {
        throw new ArgumentException("T must be an enumerated type");
    }

    string name;

    var type = typeof(T);

    var memInfo = type.GetMember(enumValue.ToString());

    if (memInfo.Length == 1)
    {
        var attributes = memInfo[0].GetCustomAttributes(typeof(System.Xml.Serialization.XmlEnumAttribute), false);

        if (attributes.Length == 1)
        {
            name = ((System.Xml.Serialization.XmlEnumAttribute)attributes[0]).Name;
        }
        else
        {
            name = enumValue.ToString();
        }
    }
    else
    {
        name = enumValue.ToString();
    }

    return name;
}

InformationsquelleAutor der Antwort saille

Ich diese Antwort, um das setup eine combo-box enum-Attribute, die war toll.

Ich dann benötigt, um code der Rückseite, so dass ich kann die Auswahl aus der box und Rückkehr der enum in den richtigen Typ.

Habe ich auch geändert, der code zum verarbeiten der Fall, wo ein Attribut fehlte

Für die Vorteile, die die nächste person, hier ist meine Letzte Lösung

public static class Program
{
   static void Main(string[] args)
    {
       //display the description attribute from the enum
       foreach (Colour type in (Colour[])Enum.GetValues(typeof(Colour)))
       {
            Console.WriteLine(EnumExtensions.ToName(type));
       }

       //Get the array from the description
       string xStr = "Yellow";
       Colour thisColour = EnumExtensions.FromName<Colour>(xStr);

       Console.ReadLine();
    }

   public enum Colour
   {
       [Description("Colour Red")]
       Red = 0,

       [Description("Colour Green")]
       Green = 1,

       [Description("Colour Blue")]
       Blue = 2,

       Yellow = 3
   }
}

public static class EnumExtensions
{

    //This extension method is broken out so you can use a similar pattern with 
    //other MetaData elements in the future. This is your base method for each.
    public static T GetAttribute<T>(this Enum value) where T : Attribute
    {
        var type = value.GetType();
        var memberInfo = type.GetMember(value.ToString());
        var attributes = memberInfo[0].GetCustomAttributes(typeof(T), false);

        //check if no attributes have been specified.
        if (((Array)attributes).Length > 0)
        {
            return (T)attributes[0];
        }
        else
        {
            return null;
        }
    }

    //This method creates a specific call to the above method, requesting the
    //Description MetaData attribute.
    public static string ToName(this Enum value)
    {
        var attribute = value.GetAttribute<DescriptionAttribute>();
        return attribute == null ? value.ToString() : attribute.Description;
    }

    ///<summary>
    ///Find the enum from the description attribute.
    ///</summary>
    ///<typeparam name="T"></typeparam>
    ///<param name="desc"></param>
    ///<returns></returns>
    public static T FromName<T>(this string desc) where T : struct
    {
        string attr;
        Boolean found = false;
        T result = (T)Enum.GetValues(typeof(T)).GetValue(0);

        foreach (object enumVal in Enum.GetValues(typeof(T)))
        {
            attr = ((Enum)enumVal).ToName();

            if (attr == desc)
            {
                result = (T)enumVal;
                found = true;
                break;
            }
        }

        if (!found)
        {
            throw new Exception();
        }

        return result;
    }
}

}

InformationsquelleAutor der Antwort Steve Pinfold

Alternativ können Sie das folgende tun:

Dictionary<FunkyAttributesEnum, string> description = new Dictionary<FunkyAttributesEnum, string>()
    {
      { FunkyAttributesEnum.NameWithoutSpaces1, "Name With Spaces1" },
      { FunkyAttributesEnum.NameWithoutSpaces2, "Name With Spaces2" },
    };

Bekommen und die Beschreibung mit den folgenden:

string s = description[FunkyAttributesEnum.NameWithoutSpaces1];

Meiner Meinung nach ist dies ein effizienter Weg, das zu tun, was Sie erreichen möchten, keine Reflexion erforderlich.

InformationsquelleAutor der Antwort Ian P

Können Sie auch definieren ein enum-Wert wie Name_Without_Spacesund wenn Sie möchten eine Beschreibung Name_Without_Spaces.ToString().Replace('_', ' ') ersetzt die Unterstriche durch Leerzeichen.

InformationsquelleAutor der Antwort Coda