web-dev-qa-db-fra.com

Enum to Dictionary c #

J'ai cherché ceci en ligne mais je ne peux pas trouver la réponse que je cherche. Fondamentalement, j'ai l'énumération suivante:

public enum typFoo : int
{
   itemA : 1,
   itemB : 2
   itemC : 3
}

Comment puis-je convertir cette énumération en dictionnaire afin qu'il soit stocké dans le dictionnaire suivant

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

et mydic ressemblerait à ceci:

1, itemA
2, itemB
3, itemC

Des idées?

c#dictionarycollectionsenums
47
daehaai

voir: Comment énumérer un enum?

foreach( typFoo foo in Enum.GetValues(typeof(typFoo)) )
{
    mydic.Add((int)foo, foo.ToString());
}
40
Zhais

Essayer:

var dict = Enum.GetValues(typeof(typFoo))
               .Cast<typFoo>()
               .ToDictionary(t => (int)t, t => t.ToString() );
137
Ani

Adapter la réponse de Ani pour qu'elle puisse être utilisée comme méthode générique (merci, toddmo )

public static Dictionary<int, string> EnumDictionary<T>()
{
    if (!typeof(T).IsEnum)
        throw new ArgumentException("Type must be an enum");
    return Enum.GetValues(typeof(T))
        .Cast<T>()
        .ToDictionary(t => (int)(object)t, t => t.ToString());
}
12
Arithmomaniac
  • Méthode d'extension
  • Nom conventionnel
  • Une ligne
  • la syntaxe de retour de c # 7 (mais vous pouvez utiliser des crochets dans ces anciennes versions de c #)
  • Lance une ArgumentException si le type n'est pas System.Enum, grâce à Enum.GetValues 
  • Intellisense sera limité aux structures (aucune contrainte enum n'est encore disponible)
  • Vous permet d'utiliser enum pour indexer dans le dictionnaire, si vous le souhaitez.
public static Dictionary<T, string> ToDictionary<T>() where T : struct 
  => Enum.GetValues(typeof(T)).Cast<T>().ToDictionary(e => e, e => e.ToString());
5
toddmo
public static class EnumHelper
{
    public static IDictionary<int, string> ConvertToDictionary<T>() where T : struct
    {
        var dictionary = new Dictionary<int, string>();

        var values = Enum.GetValues(typeof(T));

        foreach (var value in values)
        {                
            int key = (int) value;

            dictionary.Add(key, value.ToString());
        }

        return dictionary;
    }
}

Utilisation:

public enum typFoo : int
{
   itemA = 1,
   itemB = 2,
   itemC = 3
}

var mydic = EnumHelper.ConvertToDictionary<typFoo>();
5
Arif

+1 à Ani . Voici la version VB.NET

Voici la version VB.NET de la réponse d'Ani:

Public Enum typFoo
    itemA = 1
    itemB = 2
    itemC = 3
End Enum

Sub example()

    Dim dict As Dictionary(Of Integer, String) = System.Enum.GetValues(GetType(typFoo)) _
                                                 .Cast(Of typFoo)() _
                                                 .ToDictionary(Function(t) Integer.Parse(t), Function(t) t.ToString())
    For Each i As KeyValuePair(Of Integer, String) In dict
        MsgBox(String.Format("Key: {0}, Value: {1}", i.Key, i.Value))
    Next

End Sub

Exemple supplémentaire

Dans mon cas, je voulais sauvegarder le chemin des répertoires importants et les stocker dans la section AppSettings de mon web.config. Ensuite, j'ai créé une énumération pour représenter les clés de ces paramètres d'application ... mais mon ingénieur frontal avait besoin d'accéder à ces emplacements dans nos fichiers JavaScript externes. J'ai donc créé le bloc de code suivant et l'ai placé dans notre page maître principale. Désormais, chaque nouvel élément Enum créera automatiquement une variable javascript correspondante. Voici mon bloc de code:

    <script type="text/javascript">
        var rootDirectory = '<%= ResolveUrl("~/")%>';
        // This next part will loop through the public enumeration of App_Directory and create a corresponding javascript variable that contains the directory URL from the web.config.
        <% Dim App_Directories As Dictionary(Of String, App_Directory) = System.Enum.GetValues(GetType(App_Directory)) _
                                                                   .Cast(Of App_Directory)() _
                                                                   .ToDictionary(Of String)(Function(dir) dir.ToString)%>
        <% For Each i As KeyValuePair(Of String, App_Directory) In App_Directories%>
            <% Response.Write(String.Format("var {0} = '{1}';", i.Key, ResolveUrl(ConfigurationManager.AppSettings(i.Value))))%>
        <% next i %>
    </script>

NOTE: Dans cet exemple, j'ai utilisé le nom de l'énum en tant que clé (pas la valeur int).

3
Lopsided

Vous pouvez énumérer les descripteurs d’énumération:

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

foreach(var name in Enum.GetNames(typeof(typFoo))
{
    enumDictionary.Add((int)((typFoo)Enum.Parse(typeof(typFoo)), name), name);
}

Cela devrait mettre la valeur de chaque élément et le nom dans votre dictionnaire. 

3
Tejs

Une autre méthode d'extension qui s'appuie sur l'exemple des Arithmomanes ci-dessus. 

    /// <summary>
    /// Returns a Dictionary&lt;int, string&gt; of the parent enumeration. Note that the extension method must
    /// be called with one of the enumeration values, it does not matter which one is used.
    /// Sample call: var myDictionary = StringComparison.Ordinal.ToDictionary().
    /// </summary>
    /// <param name="enumValue">An enumeration value (e.g. StringComparison.Ordianal).</param>
    /// <returns>Dictionary with Key = enumeration numbers and Value = associated text.</returns>
    public static Dictionary<int, string> ToDictionary(this Enum enumValue)
    {
        var enumType = enumValue.GetType();
        return Enum.GetValues(enumType)
            .Cast<Enum>()
            .ToDictionary(t => (int)(object)t, t => t.ToString());
    }
2
j2associates

En utilisant la réflexion:

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

foreach (FieldInfo fi in typeof(typFoo).GetFields(BindingFlags.Public | BindingFlags.Static))
{
    mydic.Add(fi.GetRawConstantValue(), fi.Name);
}
1
Cipi

Si vous n'avez besoin que du nom, vous n'avez pas du tout besoin de créer ce dictionnaire.

Cela va convertir enum en int:

 int pos = (int)typFoo.itemA;

Cela convertira int en enum:

  typFoo foo = (typFoo) 1;

Et ceci vous retransmettra le nom de celui-ci:

 ((typFoo) i).toString();
0
Damian Leszczyński - Vash
public class EnumUtility
    {
        public static string GetDisplayText<T>(T enumMember)
            where T : struct, IConvertible
        {
            if (!typeof(T).IsEnum)
                throw new Exception("Requires enum only");

            var a = enumMember
                    .GetType()
                    .GetField(enumMember.ToString())
                    .GetCustomAttribute<DisplayTextAttribute>();
            return a == null ? enumMember.ToString() : a.Text;
        }

        public static Dictionary<int, string> ParseToDictionary<T>()
            where T : struct, IConvertible
        {
            if (!typeof(T).IsEnum)
                throw new Exception("Requires enum only");

            Dictionary<int, string> dict = new Dictionary<int, string>();
            T _enum = default(T);
            foreach(var f in _enum.GetType().GetFields())
            {
               if(f.GetCustomAttribute<DisplayTextAttribute>() is DisplayTextAttribute i)
                    dict.Add((int)f.GetValue(_enum), i == null ? f.ToString() : i.Text);
            }
            return dict;
        }

        public static List<(int Value, string DisplayText)> ParseToTupleList<T>()
            where T : struct, IConvertible
        {
            if (!typeof(T).IsEnum)
                throw new Exception("Requires enum only");

            List<(int, string)> tupleList = new List<(int, string)>();
            T _enum = default(T);
            foreach (var f in _enum.GetType().GetFields())
            {
                if (f.GetCustomAttribute<DisplayTextAttribute>() is DisplayTextAttribute i)
                    tupleList.Add(((int)f.GetValue(_enum), i == null ? f.ToString() : i.Text));
            }
            return tupleList;
        }
    }
0
Swaraj Ketan