Comment convertir un enum en liste en C#? [dupliquer]

beaucoup plus facile:

Enum.GetValues(typeof(SomeEnum))
    .Cast<SomeEnum>()
    .Select(v => v.ToString())
    .ToList();

la réponse courte est, utiliser:

(SomeEnum[])Enum.GetValues(typeof(SomeEnum))

si vous avez besoin de ça pour une variable locale, c'est var allSomeEnumValues = (SomeEnum[])Enum.GetValues(typeof(SomeEnum)); .

pourquoi cette syntaxe?!

la static méthode GetValues a été introduite dans L'ancien .NET 1.0 jours. Il renvoie un tableau unidimensionnel du type d'exécution SomeEnum[] . Mais puisque c'est une méthode non-générique (génériques n'a pas été introduit jusqu'à .NET 2.0), Il ne peut pas déclarer son type de retour (compiler-time return type) comme tel.

. les tableaux réseau ont une sorte de covariance, mais parce que SomeEnum sera un type valeur , et parce que la covariance type tableau ne fonctionne pas avec les types valeur, ils ne pouvaient même pas déclarer le type retour comme un object[] ou" 15198090920". (Ceci est différent de par exemple cette surcharge de GetCustomAttributes de .NET 1.0 qui a le type de retour de compilation object[] mais retourne en fait un tableau de type SomeAttribute[] où SomeAttribute est nécessairement un type de référence.)

pour cette raison, la méthode .net 1.0 devait déclarer son type de retour comme System.Array . Mais je vous garantis que c'est un SomeEnum[] .

chaque fois que vous appelez GetValues encore une fois avec le même type d'enum, il devra allouer un nouveau tableau et copier les valeurs dans le nouveau tableau. C'est parce que les tableaux peuvent être écrits à (modifié) par le "consommateur" de la méthode, de sorte qu'ils doivent faire un nouveau tableau pour être sûr que les valeurs sont inchangées. .NET 1.0 n'avait pas de bonnes collections en lecture seule.

si vous avez besoin de la liste de toutes les valeurs de nombreux endroits différents, pensez à appeler GetValues juste une fois et mettre en cache le résultat dans l'emballage en lecture seule, par exemple comme ceci:

public static readonly ReadOnlyCollection<SomeEnum> AllSomeEnumValues
    = Array.AsReadOnly((SomeEnum[])Enum.GetValues(typeof(SomeEnum)));

alors vous pouvez utiliser AllSomeEnumValues plusieurs fois, et la même collection peut être réutilisée en toute sécurité.

Pourquoi est-ce mauvais d'utiliser .Cast<SomeEnum>() ?

beaucoup d'autres réponses utilisent .Cast<SomeEnum>() . Le problème avec cela est qu'il utilise la non-générique IEnumerable mise en œuvre de la classe Array . Ce aurait dû avoir boxe chacune des valeurs dans une System.Object boîte, puis en utilisant la méthode Cast<> pour unbox toutes ces les valeurs de nouveau. Heureusement, la méthode .Cast<> semble vérifier le type d'exécution de son paramètre IEnumerable (le paramètre this ) avant de commencer à itérer dans la collection, donc ce n'est pas si mal après tout. Il s'avère que .Cast<> laisse passer le même tableau d'instance.

si vous le Suivez par .ToArray() ou .ToList() , comme dans:

Enum.GetValues(typeof(SomeEnum)).Cast<SomeEnum>().ToList() // DON'T do this

vous avez un autre problème: vous créez une nouvelle collection (tableau) lorsque vous appelez GetValues puis créez une nouvelle collection ( List<> ) avec l'appel .ToList() . Donc c'est une (extra) allocation redondante d'une collection entière pour contenir les valeurs.

Voici la façon dont j'aime, en utilisant LINQ:

public class EnumModel
{
    public int Value { get; set; }
    public string Name { get; set; }
}

public enum MyEnum
{
    Name1=1,
    Name2=2,
    Name3=3
}

public class Test
{
    List<EnumModel> enums = ((MyEnum[])Enum.GetValues(typeof(MyEnum))).Select(c => new EnumModel() { Value = (int)c, Name = c.ToString() }).ToList();
}

j'Espère que ça aide

List <SomeEnum> theList = Enum.GetValues(typeof(SomeEnum)).Cast<SomeEnum>().ToList();

réponse très simple

Voici une propriété que j'utilise dans une de mes applications""

public List<string> OperationModes
{
    get
    {
       return Enum.GetNames(typeof(SomeENUM)).ToList();
    }
}

j'ai toujours utilisé pour obtenir une liste de enum valeurs comme ceci:

Array list = Enum.GetValues(typeof (SomeEnum));

ici pour utilité... certains codes pour obtenir les valeurs dans une liste, qui convertit l'enum en forme lisible pour le texte

public class KeyValuePair
  {
    public string Key { get; set; }

    public string Name { get; set; }

    public int Value { get; set; }

    public static List<KeyValuePair> ListFrom<T>()
    {
      var array = (T[])(Enum.GetValues(typeof(T)).Cast<T>());
      return array
        .Select(a => new KeyValuePair
          {
            Key = a.ToString(),
            Name = a.ToString().SplitCapitalizedWords(),
            Value = Convert.ToInt32(a)
          })
          .OrderBy(kvp => kvp.Name)
         .ToList();
    }
  }

.. et le Système de soutien.Chaîne d'extension de la méthode:

/// <summary>
/// Split a string on each occurrence of a capital (assumed to be a word)
/// e.g. MyBigToe returns "My Big Toe"
/// </summary>
public static string SplitCapitalizedWords(this string source)
{
  if (String.IsNullOrEmpty(source)) return String.Empty;
  var newText = new StringBuilder(source.Length * 2);
  newText.Append(source[0]);
  for (int i = 1; i < source.Length; i++)
  {
    if (char.IsUpper(source[i]))
      newText.Append(' ');
    newText.Append(source[i]);
  }
  return newText.ToString();
}

Language[] result = (Language[])Enum.GetValues(typeof(Language))

public class NameValue
{
    public string Name { get; set; }
    public object Value { get; set; }
}

public class NameValue
{
    public string Name { get; set; }
    public object Value { get; set; }
}

public static List<NameValue> EnumToList<T>()
{
    var array = (T[])(Enum.GetValues(typeof(T)).Cast<T>()); 
    var array2 = Enum.GetNames(typeof(T)).ToArray<string>(); 
    List<NameValue> lst = null;
    for (int i = 0; i < array.Length; i++)
    {
        if (lst == null)
            lst = new List<NameValue>();
        string name = array2[i];
        T value = array[i];
        lst.Add(new NameValue { Name = name, Value = value });
    }
    return lst;
}

Convertir Enum Pour une liste plus d'informations disponibles ici .

/// <summary>
/// Method return a read-only collection of the names of the constants in specified enum
/// </summary>
/// <returns></returns>
public static ReadOnlyCollection<string> GetNames()
{
    return Enum.GetNames(typeof(T)).Cast<string>().ToList().AsReadOnly();   
}

où T est un type de dénombrement; Ajouter ce qui suit:

using System.Collections.ObjectModel; 

si vous voulez enum int comme clé et nom comme valeur, bon si vous stockez le numéro à la base de données et il est de Enum!

void Main()
{
     ICollection<EnumValueDto> list = EnumValueDto.ConvertEnumToList<SearchDataType>();

     foreach (var element in list)
     {
        Console.WriteLine(string.Format("Key: {0}; Value: {1}", element.Key, element.Value));
     }

     /* OUTPUT:
        Key: 1; Value: Boolean
        Key: 2; Value: DateTime
        Key: 3; Value: Numeric         
     */
}

public class EnumValueDto
{
    public int Key { get; set; }

    public string Value { get; set; }

    public static ICollection<EnumValueDto> ConvertEnumToList<T>() where T : struct, IConvertible
    {
        if (!typeof(T).IsEnum)
        {
            throw new Exception("Type given T must be an Enum");
        }

        var result = Enum.GetValues(typeof(T))
                         .Cast<T>()
                         .Select(x =>  new EnumValueDto { Key = Convert.ToInt32(x), 
                                       Value = x.ToString(new CultureInfo("en")) })
                         .ToList()
                         .AsReadOnly();

        return result;
    }
}

public enum SearchDataType
{
    Boolean = 1,
    DateTime,
    Numeric
}

private List<SimpleLogType> GetLogType()
{
  List<SimpleLogType> logList = new List<SimpleLogType>();
  SimpleLogType internalLogType;
  foreach (var logtype in Enum.GetValues(typeof(Log)))
  {
    internalLogType = new SimpleLogType();
    internalLogType.Id = (int) (Log) Enum.Parse(typeof (Log), logtype.ToString(), true);
    internalLogType.Name = (Log)Enum.Parse(typeof(Log), logtype.ToString(), true);
    logList.Add(internalLogType);
  }
  return logList;
}

en code haut , Log est un Enum et SimpleLogType est une structure pour les logs .

public enum Log
{
  None = 0,
  Info = 1,
  Warning = 8,
  Error = 3
}

vous pouvez utiliser la méthode générique suivante:

public static List<T> GetItemsList<T>(this int enums) where T : struct, IConvertible
{
    if (!typeof (T).IsEnum)
    {
        throw new Exception("Type given must be an Enum");
    }

    return (from int item in Enum.GetValues(typeof (T))
            where (enums & item) == item
            select (T) Enum.Parse(typeof (T), item.ToString(new CultureInfo("en")))).ToList();
}