enumerador - enum to list c#

cómo verificar si el valor de la cadena está en la lista Enum?

Question

En mi cadena de consulta, tengo una variable de ?age=New_Born .

¿Hay alguna manera de comprobar si este valor de cadena New_Born está en mi lista Enum?

[Flags]
public enum Age
{
New_Born = 1,
Toddler = 2,
Preschool = 4,
Kindergarten = 8
}

Podría usar la declaración if para este momento, pero si mi lista Enum se hace más grande. Quiero encontrar una mejor manera de hacerlo. Estoy pensando en usar Linq, simplemente no estoy seguro de cómo hacerlo.

Answer 1

Debes usar Enum.TryParse para alcanzar tu meta

Este es un ejemplo:

[Flags]
private enum TestEnum
{
Value1 = 1,
Value2 = 2
}
static void Main(string[] args)
{
var enumName = "Value1";
TestEnum enumValue;
if (!TestEnum.TryParse(enumName, out enumValue))
{
throw new Exception("Wrong enum value");
}
// enumValue contains parsed value
}

Answer 2

Para analizar la edad:

Age age;
if (Enum.TryParse(typeof(Age), "New_Born", out age))
MessageBox.Show("Defined"); // Defined for "New_Born, 1, 4 , 8, 12"

Para ver si está definido:

if (Enum.IsDefined(typeof(Age), "New_Born"))
MessageBox.Show("Defined");

Dependiendo de cómo planee usar Age enum, las banderas pueden no ser lo correcto. Como probablemente sepa, [Flags] indica que desea permitir múltiples valores (como en una máscara de bits). IsDefined devolverá falso para Age.Toddler | Age.Preschool Age.Toddler | Age.Preschool porque tiene múltiples valores.

Answer 3

Puede usar el método TryParse que devuelve verdadero si tiene éxito:

Age age;
if(Enum.TryParse<Age>("myString", out age))
{
//Here you can use age
}

Answer 4

Puede usar el método Enum.TryParse:

Age age;
if (Enum.TryParse<Age>("New_Born", out age))
{
// You now have the value in age
}

Answer 5

Puedes usar:

 Enum.IsDefined(typeof(Age), youragevariable)

Answer 6

Sé que este es un hilo viejo, pero aquí hay un enfoque ligeramente diferente que usa atributos en los enumerados y luego una clase auxiliar para encontrar el enumerado que coincida.

De esta manera, podría tener múltiples asignaciones en un solo enumerate.

public enum Age
{
[Metadata("Value", "New_Born")]
[Metadata("Value", "NewBorn")]
New_Born = 1,
[Metadata("Value", "Toddler")]
Toddler = 2,
[Metadata("Value", "Preschool")]
Preschool = 4,
[Metadata("Value", "Kindergarten")]
Kindergarten = 8
}

Con mi clase de ayudante como esta

public static class MetadataHelper
{
public static string GetFirstValueFromMetaDataAttribute<T>(this T value, string metaDataDescription)
{
return GetValueFromMetaDataAttribute(value, metaDataDescription).FirstOrDefault();
}
private static IEnumerable<string> GetValueFromMetaDataAttribute<T>(T value, string metaDataDescription)
{
var attribs =
value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof (MetadataAttribute), true);
return attribs.Any()
? (from p in (MetadataAttribute[]) attribs
where p.Description.ToLower() == metaDataDescription.ToLower()
select p.MetaData).ToList()
: new List<string>();
}
public static List<T> GetEnumeratesByMetaData<T>(string metadataDescription, string value)
{
return
typeof (T).GetEnumValues().Cast<T>().Where(
enumerate =>
GetValueFromMetaDataAttribute(enumerate, metadataDescription).Any(
p => p.ToLower() == value.ToLower())).ToList();
}
public static List<T> GetNotEnumeratesByMetaData<T>(string metadataDescription, string value)
{
return
typeof (T).GetEnumValues().Cast<T>().Where(
enumerate =>
GetValueFromMetaDataAttribute(enumerate, metadataDescription).All(
p => p.ToLower() != value.ToLower())).ToList();
}
}

entonces puedes hacer algo como

var enumerates = MetadataHelper.GetEnumeratesByMetaData<Age>("Value", "New_Born");

Y para completar, aquí está el atributo:

 [AttributeUsage(AttributeTargets.Field, Inherited = false, AllowMultiple = true)]
public class MetadataAttribute : Attribute
{
public MetadataAttribute(string description, string metaData = "")
{
Description = description;
MetaData = metaData;
}
public string Description { get; set; }
public string MetaData { get; set; }
}

Answer 7

Tengo un práctico método de extensión que usa TryParse, ya que IsDefined distingue entre mayúsculas y minúsculas.

public static bool IsParsable<T>(this string value) where T : struct
{
return Enum.TryParse<T>(value, true, out _);
}