C'è un modello buon progetto per l'attuazione di funzioni opzionali?
-
19-09-2019 - |
Domanda
Supponiamo che io abbia una funzione che esegue un compito (questo è in Python pseudocodice):
def doTask():
...
Ma ho diverse caratteristiche opzionali sulla piattaforma che si traduce nell'avere il codice che assomiglia a questo:
def doTask():
...
if FEATURE_1_ENABLED:
...
if FEATURE_2_ENABLED:
...
...
Purtroppo, questo diventa piuttosto disordinato con molte caratteristiche opzionali diverse che coincidono con l'un l'altro. Quali tipi di modelli di progettazione risolvere questo problema?
Soluzione
Questo è ciò che Comando e Strategia sono tutti circa. Così come Composizione .
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 )
È possibile comporre caratteristiche, funzioni delegate, ereditare caratteristiche. Questo funziona abbastanza bene per un set espandibile di caratteristiche opzionali.
Altri suggerimenti
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();
}
}
Credo che si chiama modello di strategia
La sintassi potrebbe non essere esatto