C#: Enum anti-patterns

Question

Si è parlato di Enum in generale che violava i principi del Codice pulito, quindi sto cercando gli anti-pattern e le soluzioni alternative di Enum preferite dalle persone per questi.

Per esempio ho visto il codice come questo:

switch(enumValue) { 
    case myEnum.Value1: 
     // ... 
     break; 
    case myEnum.Value2: 
     // ... 
     break; 
} 

E 'un passo migliore di switch-dichiarazioni con le stringhe di magia, ma questo probabilmente avrebbe potuto essere risolto meglio con una fabbrica, un contenitore o altro modello .

O anche vecchia scuola codice come questo:

if(enumValue == myEnum.Value1) { 
    // ... 
} else if (enumValue == myEnum.Value2) { 
    // ... 
} 

Quali altri anti-pattern e le implementazioni migliori avete sperimentato con enumerazioni?

Answer 1

Penso che le enumerazioni siano abbastanza utili. Ho scritto un paio di estensioni per Enum che hanno aggiunto ancora più valore al suo uso

In primo luogo, c'è il metodo di descrizione estensione

public static class EnumExtensions 
{ 
    public static string Description(this Enum value) 
    { 
     var entries = value.ToString().Split(ENUM_SEPERATOR_CHARACTER); 
     var description = new string[entries.Length]; 
     for (var i = 0; i < entries.Length; i++) 
     { 
      var fieldInfo = value.GetType().GetField(entries[i].Trim()); 
      var attributes = (DescriptionAttribute[])fieldInfo.GetCustomAttributes(typeof(DescriptionAttribute), false); 
      description[i] = (attributes.Length > 0) ? attributes[0].Description : entries[i].Trim(); 
     } 
     return String.Join(", ", description); 
    } 
    private const char ENUM_SEPERATOR_CHARACTER = ','; 
} 

Questo mi permetterà di definire en enum come questo:

public enum MeasurementUnitType 
{ 
    [Description("px")] 
    Pixels = 0, 
    [Description("em")] 
    Em = 1, 
    [Description("%")] 
    Percent = 2, 
    [Description("pt")] 
    Points = 3 
} 

E ottenere l'etichetta facendo questo: var myLabel = rectangle.widthunit.Description() (eliminando qualsiasi necessità di una dichiarazione switch).

Ciò restituirà "px" se rectangle.widthunit = MeasurementUnitType.Pixels o restituirà "px, em" se rectangle.widthunit = MeasurementUnitType.Pixels | MeasurementUnitType.Em.

Poi, c'è un

public static IEnumerable<int> GetIntBasedEnumMembers(Type @enum) 
    { 
     foreach (FieldInfo fi in @enum.GetFields(BindingFlags.Public | BindingFlags.Static)) 
      yield return (int)fi.GetRawConstantValue(); 
    } 

Il che mi permette di attraversare qualsiasi enum con valori basati int e restituire l'int stessi valori.

Trovo che questi siano molto utili in un concetto già utile.

Answer 2

Utilizzo di enum in non anti-pattern. In alcuni libri sul refactoring questo codice è usato per dimostrare come sostituirlo con il polimorfismo. Sarebbe OK quando usi eccessivamente le enumerazioni nel codice.

Answer 3

Vedo di avere due istruzioni di commutazione come un sintomo di progettazione non OO as explained further in this answer.

Answer 4

Questa non è una risposta, oltre a contribuire a un elenco di anti-pattern Enum.

Durante una revisione del codice questa mattina, mi sono imbattuto in un caso simile al seguente, tutti nella stessa classe.

due casi:

1. prima di bere
2. Dopo aver bevuto

..

public enum ListEnum 
    { 
     CategoryOne, 
     CategoryTwo, 
     CategoryThree, 
     CategoryFour 
    } 


    public class UIELementType 
    { 
     public const string FactoryDomain = "FactoryDomain"; 
     public const string Attributes = "Attributes"; 
    }