Je travaille actuellement sur une base de code qui a de nombreuses classes qui implémentent une méthode de démarrage. Cela semble être une construction en deux phases pour moi, que j'avais toujours considérée comme une mauvaise pratique. Je ne peux pas dire la différence entre cela et un constructeur.
Quand est-il approprié d'utiliser une méthode de démarrage au lieu de la construction d'objets normale?
Quand devrais-je préférer utiliser le constructeur?
Edit: Je ne pense pas que ce soit cela pertinent, mais le langage de programmation est C #, il pourrait également s'appliquer à Java ou C++
Une méthode Start()
(comme Run()
, Execute()
ou quoi que ce soit similaire) est approprié lorsque le coût de la construction de l'objet est faible, mais le coût de en utilisant c'est élevé. Par exemple: une classe qui encapsule un algorithme d'optimisation du meilleur chemin. Il est trivial de la configurer avec un ensemble de paramètres (X
carrés par Y
carrés, avec la méthode de l'évaluation de TaLandsuch), mais cela peut prendre un certain temps à exécuter. Si vous souhaitez créer 20 de ces objets, vous souhaiterez peut-être retarder l'exécution jusqu'à ce qu'ils aient été créés - cela vous permet de les parallementer plus facilement, par exemple.
Alternativement, cela pourrait être utile lorsque vous ne savez pas quand l'objet sera nécessaire pour commencer - peut-être parce qu'il est basé sur l'entrée de l'utilisateur ou la logique qui sélectionne dans une liste de possibilités.
Cela suppose, bien sûr, que Start()
est la méthode utile sur l'objet, et non un équivalent à une méthode Initialize()
. S'il est juste un moyen de définir plus de paramètres, cela ne devrait pas exister.
Code complet (et de nombreuses autres ressources en génie logiciel) mettent l'accent sur la correspondance de vos classes aux objets du monde réel. Je crois que la raison fondamentale est que cela rend la plus probable que vous ayez une véritable compréhension de ce que vous mettez en œuvre, plutôt que de pirater une idée intangible.
Si vous êtes abonné à cette théorie, je ne vois rien de mal à ajouter une méthode Start()
méthode à n'importe quelle classe qui devrait, était-ce un véritable objet, a également un état de repos. Si cela n'a aucun sens pour que votre objet n'existe pas tout en courant (ou n'a aucun sens pour que votre objet soit exécuté du tout), je dirais que c'est une mauvaise pratique.
Vous pouvez utiliser initialisation paresseuse.
Dans la programmation informatique, l'initialisation paresseuse est la tactique de retarder la création d'un objet, le calcul d'une valeur ou d'un autre processus coûteux jusqu'à la première utilisation.
de cette façon d'éviter l'accouplement temporel, ce qui signifie que le consommateur de votre classe doit appeler certaines méthodes dans certains ordres. avoir à appeler start()
Le premier est un moyen de savoir comment la classe fonctionne en interne, ce qui est mauvais parce que vous pouvez changer cela à l'avenir.
Retarder l'initialisation coûteuse jusqu'à ce qu'elle soit nécessaire.
exemple:
public class FooClass{
private ExpensiveResource resource;
private CheapResource cheap;
public FooClass(String someParameter){
// constructor: initialize CheapResource cheap
// but NOT ExpensiveResource resource
}
public ExpensiveResource getExpensiveResource(){
if (resource == null) {
this.initializeExpensiveResource();
}
return this.resource
}
public String getExpensiveResourceName(){
if (resource == null) {
this.initializeExpensiveResource();
}
return this.resource.getName();
}
public CheapResource getCheapResource(){
return this.cheap;
}
private initializeExpensiveResource(){
// do expensive initialization of field "resource"
}
}
public class Test{
public static void main (String args[]){
FooClass foo = new FooClass("some string");
CheapResource cr = foo.getCheapResource();
String s = foo.getExpensiveResourceName();
// just now is the expensive resource initialized
}
}