Generic ciąg ENUM konwersji

Question

Załóżmy ENUM:

public enum SysLogsAppTypes { None, MonitorService, MonitorTool }; 

i tutaj jest funkcja konwersji z powrotem do reprezentacji ToString()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; 
    } 
} 

Czy istnieje sposób, aby ten Generic ??

Próbowałem:

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

ale otrzymuję: 'T' jest 'parametr typ', który nie jest ważny w danym kontekście
gdzie istnieje T.None

Wszelkie Wsparcie ? Dzięki

Answer 1

Myślę, że kluczowe default jest to, czego potrzebujesz:

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

Nie sposób próbujesz go, ale używam metody poniżej, aby to zrobić:

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

żadnych wyjątków wyrzucony tutaj ...

Answer 3

Chciałbym dodać parametr defaultValue dla przeciążenia mojego TryParse dla przypadków, w których Chcę wartość domyślną, jeśli nie można jej przeanalizować lub ma wartość null. Jest to najbardziej przydatne do analizowania string.Empty lub null.

Uwaga: ta implementacja powróci do defaultValue, jeśli zostanie przekazana wartość śmieciowa - więc możesz ją poprawić, rzucając wyjątek.

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

wiem, że to jest stary, ale na podstawie kilku próbek, mam zbadane wraz z @Simon_Weaver's rozwiązania jest to, co mam:

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