Existe-t-il un bon modèle de conception pour l'implémentation de fonctionnalités optionnelles?

Question

Supposons que j'ai une fonction qui exécute une tâche (ce qui est en Python pseudocode):

def doTask(): 
    ... 

Mais j'ai plusieurs caractéristiques en option sur la plate-forme qui en résulte ayant un code qui ressemble à ceci:

def doTask(): 
    ... 
    if FEATURE_1_ENABLED: 
     ... 
    if FEATURE_2_ENABLED: 
     ... 
    ... 

Malheureusement, cela devient plutôt désordonné avec de nombreuses fonctionnalités optionnelles qui coïncident entre elles. Quels types de modèles de conception résolvent ce problème?

Answer 1

C'est ce commandement et Stratégie sont tout. Ainsi que Composition.

class Command(object): 
    def do(self): 
     raise NotImplemented 

class CompositeCommand(Command, list): 
    def do(self): 
     for subcommand in self: 
      subcommand.do() 

class Feature_1(Command): 
    def do(self, aFoo): 
     # some optional feature. 

class Feature_2(Command): 
    def do(self, aFoo): 
     # another optional feature. 

class WholeEnchilada(CompositeCommand): 
    def __init__(self): 
     self.append(Feature_1()) 
     self.append(Feature_2()) 

class Foo(object): 
    def __init__(self, feature=None): 
     self.feature_command= feature 
    def bar(self): 
     # the good stuff 
     if self.feature: 
      self.feature.do(self) 

Vous pouvez composer des entités, déléguer des entités, hériter de fonctionnalités. Cela fonctionne plutôt bien pour un ensemble extensible de fonctionnalités optionnelles.

Answer 2

interface Feature{ 

    void execute_feature(); 

} 

class Feature1 implements Feature{ 
    void execute_feature(){} 
} 
class Feature2 implements Feature{ 
    void execute_feature(){} 
} 

public static void main(String argv[]){ 

List<Feature> my_list = new List<Feature>(); 
my_list.Add(new Feature1()); 
my_list.Add(new Feature2()); 

for (Feature f : my_list){ 
    f.execute_feature(); 
} 

} 

Je pense qu'il est appelé modèle de stratégie

Syntaxe pourrait ne pas être exacte