c# - que - Convert.ChangeType y convirtiendo a enums?

return enum c#

Question

Int16 un valor Int16 de la base de datos y necesito convertirlo en un tipo de enumeración. Desafortunadamente, esto se hace en una capa del código que sabe muy poco sobre los objetos, excepto por lo que puede reunir a través de la reflexión.

Como tal, termina llamando a Convert.ChangeType que falla con una excepción de Convert.ChangeType no válida.

Encontré lo que considero una solución desagradable, como esta:

String name = Enum.GetName(destinationType, value);
Object enumValue = Enum.Parse(destinationType, name, false);

¿Hay una mejor manera, para que no tenga que pasar por esta operación de Cadena?

Aquí hay un programa corto pero completo que se puede usar si alguien necesita experimentar:

using System;
public class MyClass
{
public enum DummyEnum
{
Value0,
Value1
}
public static void Main()
{
Int16 value = 1;
Type destinationType = typeof(DummyEnum);
String name = Enum.GetName(destinationType, value);
Object enumValue = Enum.Parse(destinationType, name, false);
Console.WriteLine("" + value + " = " + enumValue);
}
}

Answer 1

Enum.ToObject(.... es lo que estás buscando!

DO#

StringComparison enumValue = (StringComparison)Enum.ToObject(typeof(StringComparison), 5);

VB.NET

Dim enumValue As StringComparison = CType([Enum].ToObject(GetType(StringComparison), 5), StringComparison)

Si realiza una gran cantidad de conversiones de Enum intente utilizar la siguiente clase, le ahorrará un montón de código.

public class Enum<EnumType> where EnumType : struct, IConvertible
{
/// <summary>
/// Retrieves an array of the values of the constants in a specified enumeration.
/// </summary>
/// <returns></returns>
/// <remarks></remarks>
public static EnumType[] GetValues()
{
return (EnumType[])Enum.GetValues(typeof(EnumType));
}
/// <summary>
/// Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
/// <remarks></remarks>
public static EnumType Parse(string name)
{
return (EnumType)Enum.Parse(typeof(EnumType), name);
}
/// <summary>
/// Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.
/// </summary>
/// <param name="name"></param>
/// <param name="ignoreCase"></param>
/// <returns></returns>
/// <remarks></remarks>
public static EnumType Parse(string name, bool ignoreCase)
{
return (EnumType)Enum.Parse(typeof(EnumType), name, ignoreCase);
}
/// <summary>
/// Converts the specified object with an integer value to an enumeration member.
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
/// <remarks></remarks>
public static EnumType ToObject(object value)
{
return (EnumType)Enum.ToObject(typeof(EnumType), value);
}
}

Ahora, en lugar de escribir (StringComparison)Enum.ToObject(typeof(StringComparison), 5); simplemente puede escribir Enum<StringComparison>.ToObject(5); .

Answer 2

Según la respuesta de @ Peter, aquí está el método para Nullable<int> a Enum :

public static class EnumUtils
{
public static bool TryParse<TEnum>(int? value, out TEnum result)
where TEnum: struct, IConvertible
{
if(!value.HasValue || !Enum.IsDefined(typeof(TEnum), value)){
result = default(TEnum);
return false;
}
result = (TEnum)Enum.ToObject(typeof(TEnum), value);
return true;
}
}

El uso de EnumUtils.TryParse<YourEnumType>(someNumber, out result) vuelve útil para muchos escenarios. Por ejemplo, el Controlador WebApi en Asp.NET no tiene protección predeterminada contra parametros Enum no válidos. Asp.NET solo usará el default(YourEnumType) , incluso si algunos pasan null , -1000 , 500000 , "garbage string" o ignora por completo el parámetro. Además, ModelState será válido en todos estos casos, entonces una de las soluciones es usar int? escriba con cheque personalizado

public class MyApiController: Controller
{
[HttpGet]
public IActionResult Get(int? myEnumParam){
MyEnumType myEnumParamParsed;
if(!EnumUtils.TryParse<MyEnumType>(myEnumParam, out myEnumParamParsed)){
return BadRequest($"Error: parameter ''{nameof(myEnumParam)}'' is not specified or incorrect");
}
return this.Get(washingServiceTypeParsed);
}
private IActionResult Get(MyEnumType myEnumParam){
// here we can guarantee that myEnumParam is valid
}

Answer 3

Si está almacenando un Enum en una DataTable pero no sabe qué columna es una enumeración y cuál es una cadena / int, puede acceder al valor de esta manera:

foreach (DataRow dataRow in myDataTable.Rows)
{
Trace.WriteLine("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=");
foreach (DataColumn dataCol in myDataTable.Columns)
{
object v = dataRow[dataCol];
Type t = dataCol.DataType;
bool e = false;
if (t.IsEnum) e = true;
Trace.WriteLine((dataCol.ColumnName + ":").PadRight(30) +
(e ? Enum.ToObject(t, v) : v));
}
}