cadena genérico para ENUM conversión

Question

enumeración Supongamos:

public enum SysLogsAppTypes { None, MonitorService, MonitorTool }; 

y aquí hay una función para convertir de la representación ToString() de nuevo a enum:

private SysLogsAppTypes Str2SysLogsAppTypes(string str) 
{ 
    try 
    { 
     SysLogsAppTypes res = (SysLogsAppTypes)Enum 
             .Parse(typeof(SysLogsAppTypes), str); 
     if (!Enum.IsDefined(typeof(SysLogsAppTypes), res)) 
      return SysLogsAppTypes.None; 
     return res; 
    } 
    catch 
    { 
    return SysLogsAppTypes.None; 
    } 
} 

¿Hay una manera de hacer esto Genérico ??

me trataron:

private T Str2enum<T>(string str) 
{ 
    try 
    { 
     T res = (T)Enum.Parse(typeof(T), str); 
     if (!Enum.IsDefined(typeof(T), res)) return T.None; 
     return res; 
    } 
    catch 
    { 
     return T.None; 
    } 
} 

pero me sale: 'T' es un 'parámetro de tipo', que no es válida en el contexto dado
donde hay T.None

Cualquier ayuda ? Gracias

Answer 1

creo que la palabra clave default es lo que necesita:

private T Str2enum<T>(string str) where T : struct 
{ 
    try 
    { 
     T res = (T)Enum.Parse(typeof(T), str); 
     if (!Enum.IsDefined(typeof(T), res)) return default(T); 
     return res; 
    } 
    catch 
    { 
     return default(T); 
    } 
} 

Answer 2

No es la forma en que están tratando, pero lo utiliza el método siguiente para hacer esto:

public static bool EnumTryParse<E>(string enumVal, out E resOut) 
     where E : struct 
{ 
     var enumValFxd = enumVal.Replace(' ', '_'); 
     if (Enum.IsDefined(typeof(E), enumValFxd)) 
     { 
      resOut = (E)Enum.Parse(typeof(E), 
      enumValFxd, true); 
      return true; 
     } 
     // ---------------------------------------- 
     foreach (var value in 
      Enum.GetNames(typeof (E)).Where(value => 
       value.Equals(enumValFxd, 
       StringComparison.OrdinalIgnoreCase))) 
     { 
      resOut = (E)Enum.Parse(typeof(E), value); 
      return true; 
     } 
     resOut = default(E); 
     return false; 
} 

No hay excepciones arrojado aquí ...

Answer 3

Me gustaría agregar en un parámetro defaultValue para una sobrecarga de mi TryParse para casos donde Quiero un valor predeterminado si no se puede analizar o si es nulo. Esto es más útil para analizar string.Empty o null.

Nota: esta implementación revertirá a defaultValue si se pasa un valor no deseado, por lo que es posible que desee modificarlo lanzando una excepción.

public static T TryParse<T>(string value, T defaultValue) where T: struct 
    { 
     if (string.IsNullOrWhiteSpace(value)) 
      { 
       return defaultValue; 
      } 

      T result; 
      if (Enum.TryParse<T>(value, out result)) 
      { 
       return result; 
      } 
      else 
      { 
       return defaultValue; // you may want to throw exception here 
      } 
     } 
    } 


    ConverterMode mode = EnumUtils<ConverterMode>.TryParse(stringValue, ConverterMode.DefaultMode); 

Answer 4

Sé que esto es viejo, pero en base a unas pocas muestras, he investigado junto con @Simon_Weaver's solución, esto es lo que tengo:

public static T TryParse(String value, T defaultValue) where T : struct { 
    if (String.IsNullOrWhiteSpace(value)) { 
     return defaultValue; 
    } 

    T result; 
    if (!Enum.TryParse(value, out result)) { 
     if (Enum.IsDefined(typeof (T), result) | result.ToString().Contains(",")) { 
      // do nothing 
     } else { 
      result = defaultValue; 
     } 
    } else { 
     result = defaultValue; 
    } 

    return result; 
}