Un patrón de diseño para evitar múltiples ifs

Question

Tengo una clase realmente horrible con dos métodos que inician o detienen algunos servicios cuando esos servicios están disponibles. Algo así como lo siguiente (si no son-vigilara, solo si):

void startServices() { 
if (service1 == true) { 
    start1(); 
} 
if (service2 == true) { 
    start2(); 
} if (serviceN == true) { 
    startN(); 
} 
} 


void stopServices() { 
if (service1 == true) { 
    stop1(); 
} 
if (service2 == true) { 
    stop2(); 
} 
if (serviceN == true) { 
    stopN(); 
} 

} 

¿Me recomiendan que cualquier golpeteo diseño para hacerlo más bonito?

Gracias!

Answer 1

Depende; mi primera reacción es almacenar los servicios en un hash o matriz. Cada servicio implementa una interfaz con métodos de inicio y detención. Iniciar o detener un servicio requiere solo una clave o índice de servicio.

Todavía es un poco frágil, quizás, pero sin saber más no estoy seguro de cómo "dominar" ut para que se parezca más a lo que estás haciendo.

Answer 2

Puede usar el patrón de Estrategia.

La idea es que usted debe saber qué estrategia va a utilizar cuando cree una instancia de su clase (o puede cambiarla de forma dinámica por latrr). Por lo tanto, puede pasar esa estrategia al instanciar (y opcionalmente reemplazarla más adelante).

public interface IStartupStrategy 
{ 
    void Start(); 
} 

public interface IStopStrategy 
{ 
    void Stop(); 
} 

public class MyClass 
{ 
    private readonly IEnumerable<IStartupStrategy> startupStrategies; 
    private readonly IEnumerable<IStopStrategy> stopStrategies; 

    public MyClass(IEnumerable<IStartupStrategy> startup, IEnumerable<IStopStrategy> stop) 
    { 
     this.startupStrategies = startup; 
     this.stopStrategies = stop; 
    } 

    public void Start() 
    { 
     foreach(var strategy in this.startupStrategies) 
     { 
      strategy.Start(); 
     } 
    } 

    public void Stop() 
    { 
     foreach(var strategy in this.stopStrategies) 
     { 
      strategy.Stop(); 
     } 
    } 
} 

Answer 3

Use Objects, donde tiene una lista de servicios que puede repetir apagándolos con un método heredado stop().

public interface Service { 
    void start(); 
    void stop(); 
} 

public class TestService implements Service { 
    @Override 
    void start() { 
    } 

    @Override 
    void stop() { 
    } 
} 

Cada servicio también puede almacenar su estado de forma que sólo para apagarlos si están en.

Answer 4

Las instrucciones de cambio son menos confusas. Si se usa junto con enums, el código se vuelve muy legible.