Impossibile ridurre la complessità ciclomatica in un metodo di fabbrica senza utilizzare la riflessione

Question

Nel metodo factory uso l'istruzione Switch per creare oggetti concreti. Ciò si traduce in una complessità ciclomatica molto elevata. Ecco un codice di esempio:

private static UnitDescriptor createUnitDescriptor(string code) 
{ 
    switch (code) 
    { 
     case UnitCode.DEG_C: 
      return new UnitDescriptorDegC(); 

     case UnitCode.DEG_F: 
      return new UnitDescriptorDegF(); 

     : 
     : 
     default: 
      throw new SystemException(string.format("unknown code: {o}", code); 
     } 
    } 

Come posso effettuare il refactoring per ridurre la complessità ciclomatica? Se uso la reflection per creare oggetti o qualcos'altro per costruire oggetti è meglio del metodo sopra?

Answer 1

E 'possibile per l'utilizzo di un Dictionary per rimuovere l'istruzione switch tutto:

class MyClass 
{ 
    private static Dictionary<string, Func<UnitDescriptor>> dict = new Dictionary<string, Func<UnitDescriptor>>(); 

    static MyClass() 
    { 
     dict.Add(UnitCode.DEG_C,() => new UnitDescriptorDegC()); 
     dict.Add(UnitCode.DEG_F,() => new UnitDescriptorDegF()); 
     // Other mappings... 
    } 

    private static UnitDescriptor createUnitDescriptor(string code) 
    { 
     Func<UnitDescriptor> value; 
     if (dict.TryGetValue(code, out value)) 
     { 
      return value(); 
     } 

     throw new SystemException(string.Format("unknown code: {0}", code)); 
    } 
}