modello di strategia di progettazione con controllo nullo

Question

modello di strategia di progettazione con controllo nullo

#1 da (10 voti)

4

Quando la classe di contesto può accettare una strategia nulla, c'è un altro modo per farlo senza verificare se è nullo?

Questa è considerata una buona implementazione della progettazione della strategia?

class MainApp{
    static void Main(){
        Context context = new Context();
        while(true){
            Strategy strategy = createConcreteStrategy(Console.ReadLine());
            context.setStrategy(strategy);
            context.run();
        }
    }
    static void createConcreteStrategy(string input){
        if( input == "strategyA" ){
            return new StrategyA();
        }
        if( input == "strategyB" ){
            return new StrategyB();
        }       
        return null;
    }
}
abstract class Strategy { public abstract void doSomething(); }
class Context{
    Strategy strategy;
    ClassX x;

    public Context(){}
    public void setStrategy(Strategy strategy){
        this.strategy = strategy;
    }
    public void run(){
        if( strategy != null ){
            data = strategy.doSomething();
            x.setData(data);
        }
    }
}

design design-patterns null

posta user658091 18.05.2013 - 06:39

fonte

1 risposta

Leggi altre domande sui tag design design-patterns null

Come determinare i casi di test più difficili da testare qualsiasi algoritmo? Nascondi o Mostra singleton?

score 10 · Accepted Answer

C'è assolutamente un modo per evitare di verificare null qui! Utilizza il modello di oggetto nullo , cioè

class NullStrategy: Strategy {
    public void doSomething() {
    }
}

e quindi il caso "predefinito" in createConcreteStrategy è return new NullStrategy() invece di return null , e quindi non devi più controllare se strategy è nullo in run .

Se non vuoi chiamare x.setData con un argomento nullo, potresti passare x alla strategia. Ecco una possibile implementazione:

class NullStrategy: Strategy {
    public void doSomething(ClassX x) {
        // don't do anything with x
    }
}

class RealStrategy: Strategy {
    public void doSomething(ClassX x) {
        var data = someOperation();
        x.setData(data);
    }
}

Il push di un'istruzione if in un'istanza di Strategy ha senso per me in questa situazione.