Cómo cambiar la definición de enum sin afectar a los clientes que la usan en C#

Question

Tengo la siguiente enumeración definida. He usado guiones bajos ya que esta enumeración se usa en el registro y no quiero incurrir en la sobrecarga de la reflexión mediante el uso de un atributo personalizado. Usamos un registro muy pesado. Ahora el requisito es cambiar "LoginFailed_InvalidAttempt1" a "LoginFailed Attempt1". Si cambio esta enumeración, tendré que cambiar su valor en la aplicación. Puedo reemplazar el guion bajo por un espacio dentro del logging SP. ¿Hay alguna manera por la cual puedo cambiar esto sin afectar toda la aplicación? Sugiero.

public enum ActionType 
{ 
    None, 
    Created, 
    Modified, 
    Activated, 
    Inactivated, 
    Deleted, 
    Login, 
    Logout, 
    ChangePassword, 
    ResetPassword, 
    InvalidPassword, 
    LoginFailed_LockedAccount, 
    LoginFailed_InActiveAccount, 
    LoginFailed_ExpiredAccount, 
    ForgotPassword, 
    LoginFailed_LockedAccount_InvalidAttempts, 
    LoginFailed_InvalidAttempt1, 
    LoginFailed_InvalidAttempt2, 
    LoginFailed_InvalidAttempt3, 
    ForgotPassword_InvalidAttempt1, 
    ForgotPassword_InvalidAttempt2, 
    ForgotPassword_InvalidAttempt3, 
    SessionTimeOut, 
    ForgotPassword_LockedAccount, 
    LockedAccount, 
    ReLogin, 
    ChangePassword_Due_To_Expiration, 
    ChangePassword_AutoExpired 

} 

Answer 1

La mejor manera de hacerlo será con un atributo de Descripción. Entiendo que no usa el reflejo, pero siempre puede almacenar en caché el resultado para que solo ocurra una vez.

Añadir la descripción del atributo:

[Description("LoginFailed Attempt1")] 
LoginFailed_InvalidAttempt1 

A continuación, cuando se muestra el valor de texto de la enumeración, se puede obtener la descripción a cabo utilizando el siguiente fragmento de código:

private static Dictionary<Type, Dictionary<Enum, string>> enumMaps = null; 

public static string GetDescription(Enum value) 
{ 
    Type eType = value.GetType(); 
    if (enumMaps == null) 
    { 
     enumMaps = new Dictionary<Type, Dictionary<Enum, string>>(); 
    } 
    Dictionary<Enum, string> map; 
    if (enumMaps.ContainsKey(eType)) 
    { 
     map = enumMaps[eType]; 
    } 
    else 
    { 
     map = new Dictionary<Enum, string>(); 
     foreach (Enum e in Enum.GetValues(eType)) 
     { 
      FieldInfo fi = eType.GetField(e.ToString()); 
      DescriptionAttribute[] attributes = (DescriptionAttribute[])fi.GetCustomAttributes(
       typeof(DescriptionAttribute), false); 
      map[e] = (attributes.Length > 0) ? attributes[0].Description : e.ToString(); 
     } 
     enumMaps[eType] = map; 
    } 
    return map[value]; 
} 

Como se puede ver del código anterior, la reflexión solo se hace una vez. Cualquier llamada subsiguiente en el mismo valor Enum devolverá el resultado de Dictionary, que es muy rápido.

Answer 2

Puede hacer dos valores de enumeración tienen el mismo número entero, y marque una obsoleta:

public enum MyEnum { 
    Value1, 
    Value2, 

    [Obsolete] 
    Value3, 

    NewValue3 = Value3, 
} 

por lo que entonces MyEnum.Value3 == MyEnum.NewValue3