¿Cómo convierto una enumeración en una lista en C#?

Question

¿Hay alguna forma de convertir un enum en una lista que contenga todas las opciones de enum?

Answer 1

Esto devolverá IEnumerable<SomeEnum> de todos los valores de un Enum.

Enum.GetValues(typeof(SomeEnum)).Cast<SomeEnum>(); 

Si quieren que para ser un List<SomeEnum>, sólo tiene que añadir .ToList() después .Cast<SomeEnum>().

Para usar la función de Cast en una matriz, necesita tener el System.Linq en la sección de uso.

Answer 2

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 A más información disponible here. forma

Answer 3

Mucho más fácil:

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

Answer 4

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

Answer 5

Aquí para utilidad ... algo de código para obtener los valores en una lista, que convierte la enumeración en forma legible para el texto

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(); 
    } 
    } 

.. y el método de extensión System.String compatible:

/// <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(); 
} 

Answer 6

Siempre he usado para obtener una lista de valores enum así:

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

Answer 7

se puede utilizar el siguiente método genérico:

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(); 
    } 

Answer 8

/// <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(); 
} 

donde T es un tipo de Enumeración; Añadir este :

using System.Collections.ObjectModel; 

Answer 9

Si desea Enum int como la clave y el nombre como valor, bueno si almacenar el número a la base de datos y es a partir de enumeración!

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 
} 

Answer 10

respuesta muy simple

Aquí es una propiedad que utilizo en una de mis aplicaciones

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

Answer 11

Esta es la forma que amo, utilizando 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(); 
} 

Esperanza ayuda

Answer 12

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 el código superior, el registro es un Enum y SimpleLogType es una estructura para los registros.

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

Answer 13

La respuesta corta es, usar:

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

Si necesita que para una variable local, es var allSomeEnumValues = (SomeEnum[])Enum.GetValues(typeof(SomeEnum));.

¿Por qué es la sintaxis así ?!

El método staticGetValues se introdujo en los antiguos .NET 1.0 días. Devuelve una matriz unidimensional del tipo de tiempo de ejecución SomeEnum[]. Pero dado que es un método no genérico (los genéricos no se introdujeron hasta .NET 2.0), no puede declarar su tipo de devolución (tipo de devolución en tiempo de compilación) como tal.

matrices .NET tienen una especie de covarianza, sino porque SomeEnum habrá un tipo valor, y por tipo de matriz de covarianza no funciona con tipos de valor, ni siquiera podían declarar el tipo de retorno como una object[] o Enum[]. (Esto es diferente de por ejemplo this overload of GetCustomAttributes from .NET 1.0 que tiene tiempo de compilación de retorno tipo object[] pero en realidad devuelve una matriz de tipo SomeAttribute[] donde SomeAttribute es necesariamente un tipo de referencia.)

Debido a esto, el método .NET 1.0 tuvo que declarar su regreso escriba como System.Array. Pero te garantizo que es un SomeEnum[].

Cada vez que llame al GetValues nuevamente con el mismo tipo de enumeración, tendrá que asignar una nueva matriz y copiar los valores en la nueva matriz. Esto se debe a que el "consumidor" del método debe escribir las matrices (modificadas), por lo que debe crear una nueva matriz para asegurarse de que los valores no se hayan modificado. .NET 1.0 no tenía buenas colecciones de solo lectura.

Si necesita la lista de todos los valores de muchos lugares diferentes, considere llamar GetValues sólo una vez y almacenar en caché el resultado de sólo lectura envoltura, por ejemplo, así:

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

continuación, puede utilizar AllSomeEnumValues muchas veces , y la misma colección se puede reutilizar de forma segura.

¿Por qué es malo usar .Cast<SomeEnum>()?

Muchas otras respuestas usan .Cast<SomeEnum>(). El problema con esto es que utiliza la implementación no genérica IEnumerable de la clase Array. Este debe incluir encajonar cada uno de los valores en un cuadro System.Object y, a continuación, utilizar el método Cast<> para volver a poner en la caja todos esos valores. Afortunadamente, el método .Cast<> parece verificar el tipo de tiempo de ejecución de su parámetro IEnumerable (el parámetro this) antes de que comience a recorrer la colección, por lo que no es tan malo después de todo. Resulta que .Cast<> deja pasar la misma instancia de matriz.

Si sigue por .ToArray() o .ToList(), como en:

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

tiene otro problema: Se crea una nueva colección (matriz) cuando se llama GetValues y luego crear todavía una nueva colección (List<>) con la llamada .ToList(). Entonces esa es una asignación (extra) redundante de una colección completa para contener los valores.

Answer 14

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