Konvertieren von Enum-Sammlung zum Wörterbuch Angegebenen Typ

Ich bin auf der Suche um eine Funktion erstellen, wandelt ein Enum an eine Wörterbuch-Liste. Die Enum-Namen werden auch umgewandelt in eine besser lesbare form. Ich möchte nur noch die Funktion aufrufen, geben Sie den enum-Typ und Holen das Wörterbuch zurück. Ich glaube ich bin fast da ich kann einfach nicht scheinen, um herauszufinden, wie zu werfen, den enum um den richtigen Typ. (Immer ein Fehler auf " returnList.Hinzufügen' - Zeile). Im Moment bin ich gerade mit var für den Typ, aber ich weiß die Art, wie es übergeben wird.

internal static Dictionary<int,string> GetEnumList(Type e)
{
    List<string> exclusionList =
    new List<string> {"exclude"};

    Dictionary<int,string> returnList = new Dictionary<int, string>();

    foreach (var en in Enum.GetValues(e))
    {
        //split if necessary
        string[] textArray = en.ToString().Split('_');

        for (int i=0; i< textArray.Length; i++)
        {
            //if not in the exclusion list
            if (!exclusionList
                .Any(x => x.Equals(textArray[i],
                    StringComparison.OrdinalIgnoreCase)))
            {
                textArray[i] = Thread.CurrentThread.CurrentCulture.TextInfo
                    .ToTitleCase(textArray[i].ToLower());
            }
        }

        returnList.Add((int)en, String.Join(" ", textArray));
    }

    return returnList;
}
  • Welche Fehler sind Sie immer?
  • Wahrscheinlich casting-Objekt int löst einen Fehler aus
InformationsquelleAutor Will | 2013-09-17
  1. 5

    Können generische Methode, die schaffen Wörterbuch mit enum-Werte und-Namen:

    public static Dictionary<int, string> GetEnumList<T>()
{
    Type enumType = typeof(T);
    if (!enumType.IsEnum)
        throw new Exception("Type parameter should be of enum type");

    return Enum.GetValues(enumType).Cast<int>()
               .ToDictionary(v => v, v => Enum.GetName(enumType, v));
}

    Fühlen Sie sich frei, zu ändern, Standard-enum-Namen, wie Sie benötigen. Verwendung:

    var daysDictionary = Extensions.GetEnumList<DayOfWeek>();
string monday = daysDictionary[1];
    • Ich wünschte, es ist ein enum generische Einschränkung möglich .NET ...
    • ganz mit Ihnen einverstanden! Btw guter Punkt, zugegeben überprüfen 🙂
    • Warum nicht einfach if(!(T is System.Enum))? Gibt es irgendeinen Vorteil der Verwendung von Type.IsEnum statt?
    • schön, ich wünschte auch, es gibt einige generische Einschränkung wie where T : !enum kann in .NET 8?
    • ist eine Art, aber Sie sollten Instanz des Typs zu verwenden, es mit is Betreiber
    • Recht. Weiß nicht, was ich denken, schreiben, Fragen...
    • Danke! Ich war in der Lage, dies zu ändern, um zu bekommen, was ich brauche.

    InformationsquelleAutor Sergey Berezovskiy
  2. 4

    Einiger Zeit ist der bessere Weg für enum nutzen, mit Beschreibung, und erhalten Sie Dictonary(EnumValue, EnumValueDescription) über die Allgemeine Methode. Ich benutze es, wenn ich brauche, Ansicht filter im dropdown-Menü.
    Sie können es verwenden, für alle Enumerationen, die in eurem code.

    Beispiel:

    public static class EnumExtensions
{
    public static string GetDescription(this Enum value)
    {
        Type type = value.GetType();
        string name = Enum.GetName(type, value);
        if (name != null)
        {
            FieldInfo field = type.GetField(name);
            if (field != null)
            {
                var attr = Attribute.GetCustomAttribute(field, typeof (DescriptionAttribute)) as DescriptionAttribute;
                if (attr != null)
                {
                    return attr.Description;
                }
            }
        }
        return value.ToString();
    }

    public static Dictionary<T, string> EnumToDictionary<T>()
    {
        var enumType = typeof(T);

        if (!enumType.IsEnum)
            throw new ArgumentException("T must be of type System.Enum");

        return Enum.GetValues(enumType)
                   .Cast<T>()
                   .ToDictionary(k => k, v => (v as Enum).GetDescription());
    }
}

    Und Aufruf sieht wie folgt aus:

    public static class SomeFilters
{
    public static Dictionary<SomeUserFilter, string> UserFilters = EnumExtensions.EnumToDictionary<SomeUserFilter>();
}

    Für enum:

    public enum SomeUserFilter
{
    [Description("Active")]
    Active = 0,

    [Description("Passive")]
    Passive = 1,

    [Description("Active & Passive")]
    All = 2
}
    InformationsquelleAutor Andrii Orel
  3. 1

    Bitte beachten Sie, dass die definierten Datentypen mit enum in C# kann eine Reihe von zugrunde liegenden Typen (byte, sbyte, short, ushort, int, uint, long, ulong), wie der doc sagt: enum. Dies bedeutet, dass nicht alle enum-Werte kann sicher zu int gecastet und bekommen Sie Weg, ohne eine Ausnahme ausgelöst wird.

    Wenn Sie zum Beispiel möchten, Sie verallgemeinern, Sie können sicher geben Sie alle enum-Werte zu schweben (obwohl seltsam, es umfasst alle enum zugrunde liegenden Typ wie der Implizite Numerische Konvertierungen Tabelle erzählt). Oder Sie können eine konkrete Anfrage zugrunde liegenden Typ über Generika.

    Weder Lösung ist perfekt, obwohl beide den job zu erledigen Sie sicher mit ausreichende überprüfung der parameter. Verallgemeinerung auf float-Werte Lösung:

    static public IDictionary<float, string> GetEnumList(Type enumType)
{
    if (enumType != null)
        if (enumType.IsEnum)
        {
            IDictionary<float, string> enumList = new Dictionary<float, string>();

            foreach (object enumValue in Enum.GetValues(enumType))
                enumList.Add(Convert.ToSingle(enumValue), Convert.ToString(enumValue));

            return enumList;
        }
        else
            throw new ArgumentException("The provided type is not an enumeration.");
    else
        throw new ArgumentNullException("enumType");
}

    Generischen parameter Lösung:

    static public IDictionary<EnumUnderlyingType, string> GetEnumList<EnumUnderlyingType>(Type enumType)
{
    if (enumType != null)
        if (enumType.IsEnum && typeof(EnumUnderlyingType) == Enum.GetUnderlyingType(enumType))
        {
            IDictionary<EnumUnderlyingType, string> enumList = new Dictionary<EnumUnderlyingType, string>();

            foreach (object enumValue in Enum.GetValues(enumType))
                enumList.Add((EnumUnderlyingType)enumValue, enumValue.ToString());

            return enumList;
        }
        else
            throw new ArgumentException("The provided type is either not an enumeration or the underlying type is not the same with the provided generic parameter.");
    else
        throw new ArgumentNullException("enumType");
}

    Oder Sie können verwenden Sie diese in Kombination mit lazyberezovsky die Lösung zur Vermeidung von null-check. Oder besser die Lösungen mithilfe der impliziten Konvertierungen (sagen wir, du hast ein enum mit den zugrunde liegenden Typ char, können Sie sicher konvertieren eines char in einen int bedeutet, dass die Methode, wenn requrested zurück ein Wörterbuch mit int-Schlüssel, die enum-Werte mit einer enum die zugrunde liegenden Typ ist char, sollte arbeiten, ohne ein problem, da gibt es kein problem in die Speicherung von char auf int).

    InformationsquelleAutor Andrei15193
Schreibe einen Kommentar