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

¿Hay alguna manera de convertir una enum en una lista que contenga todas las opciones de la enumeración?

Esto devolverá un IEnumerable de todos los valores de un Enum.

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

Si quiere que sea una List , simplemente agregue .ToList() después de .Cast() .

Para usar la función de Cast en una Matriz, necesitas tener System.Linq en tu sección de uso.

Manera mucho más fácil:

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

La respuesta corta es, uso:

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

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

¿Por qué es la syntax así?

El método static GetValues se introdujo nuevamente 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 generics no se introdujeron hasta .NET 2.0), no puede declarar su tipo de devolución (tipo de devolución en tiempo de comstackción) como tal.

Los arrays .NET tienen un tipo de covarianza, pero debido a que SomeEnum será un tipo de valor y porque la covarianza de tipos de matriz no funciona con los tipos de valor, ni siquiera podrían declarar el tipo de devolución como un object[] o Enum[] . (Esto es diferente de, por ejemplo, esta sobrecarga de GetCustomAttributes de .NET 1.0 que tiene object[] tipo de retorno en tiempo de comstackción 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 tipo de devolución como System.Array . Pero te garantizo que es un SomeEnum[] .

Cada vez que vuelva a llamar a GetValues 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 en muchos lugares diferentes, considere llamar a GetValues solo una vez y almacenar el resultado en caché en modo de solo lectura, por ejemplo, como este:

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

Luego puede usar AllSomeEnumValues muchas veces, y la misma colección puede reutilizarse de manera segura.

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

Muchas otras respuestas usan .Cast() . El problema con esto es que utiliza la implementación IEnumerable no genérica de la clase Array . Esto debería haber implicado encajonar cada uno de los valores en un cuadro System.Object , y luego usar el método Cast<> para desempaquetar todos esos valores nuevamente. Afortunadamente, el método .Cast<> parece verificar el tipo de tiempo de ejecución de su parámetro IEnumerable ( this parámetro) antes de que comience a recorrer la colección, por lo que no es tan malo después de todo. Resulta que .Cast<> permite pasar la misma instancia de matriz.

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

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

tiene otro problema: crea una nueva colección (matriz) cuando llama a GetValues y luego crea 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.

Esta es la forma en que amo, usando 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 enums = ((MyEnum[])Enum.GetValues(typeof(MyEnum))).Select(c => new EnumModel() { Value = (int)c, Name = c.ToString() }).ToList(); } 

Espero eso ayude

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

respuesta muy simple

Aquí hay una propiedad que uso en una de mis aplicaciones

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

Siempre solía obtener una lista de valores enum como este:

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

Aquí para su utilidad … algún 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 ListFrom() { var array = (T[])(Enum.GetValues(typeof(T)).Cast()); 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:

 ///  /// Split a string on each occurrence of a capital (assumed to be a word) /// eg MyBigToe returns "My Big Toe" ///  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 EnumToList() { var array = (T[])(Enum.GetValues(typeof(T)).Cast()); var array2 = Enum.GetNames(typeof(T)).ToArray(); List lst = null; for (int i = 0; i < array.Length; i++) { if (lst == null) lst = new List(); string name = array2[i]; T value = array[i]; lst.Add(new NameValue { Name = name, Value = value }); } return lst; } 

Convierta Enum A una lista más información disponible aquí .

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

donde T es un tipo de enumeración; Agrega esto:

 using System.Collections.ObjectModel; 
 private List GetLogType() { List logList = new List(); 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, Log es un Enum y SimpleLogType es una estructura para registros.

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

Si quieres Enum int como clave y nombre como valor, ¡es bueno si guardas el número en la base de datos y es de Enum!

 void Main() { ICollection list = EnumValueDto.ConvertEnumToList(); 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 ConvertEnumToList() 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() .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 } 

Puede usar el siguiente método genérico:

 public static List GetItemsList(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(); }