Une méthode «démarrer», «exécuter» ou «exécuter» est-elle une bonne pratique?

Je travaille actuellement sur une base de code qui a de nombreuses classes qui implémentent une méthode Start. Cela me semble être une construction en deux phases, que j'avais toujours considérée comme une mauvaise pratique. Je ne peux pas faire la différence entre cela et un constructeur.

Quand est-il approprié d'utiliser une méthode de démarrage au lieu d'une construction d'objet normale?

Quand devrais-je préférer utiliser le constructeur?

Edit: Je ne pense pas que ce soit pertinent mais le langage de programmation est C #, il pourrait également s'appliquer à Java ou C ++

Une Start()méthode (comme Run(), Execute()ou quelque chose de similaire) est appropriée lorsque le coût de construction de l'objet est faible, mais le coût de l' utilisation est élevée. Par exemple: Une classe qui encapsule un algorithme d'optimisation du meilleur chemin. Il est trivial de le configurer avec un ensemble de paramètres ( Xcarrés par Ycarrés, avec une telle méthode d'évaluation), mais son exécution peut prendre un certain temps. Si vous souhaitez créer 20 de ces objets, vous souhaiterez peut-être retarder l'exécution jusqu'à ce qu'ils soient tous créés - cela vous permet par exemple de les paralléliser plus facilement.

Alternativement, cela pourrait être utile lorsque vous ne savez pas quand l'objet sera nécessaire pour démarrer - peut-être parce qu'il est basé sur une entrée utilisateur ou une logique qui sélectionne dans une liste de possibilités.

Cela suppose, bien sûr, que Start()c'est la méthode utile sur l'objet, et non l'équivalent d'une Initialize()méthode. Si c'est juste un moyen supplémentaire de définir plus de paramètres, cela ne devrait pas exister.

Code Complete (et de nombreuses autres ressources d'ingénierie logicielle) met l'accent sur la correspondance de vos classes avec des objets du monde réel. Je crois que la raison fondamentale de cela est qu'il rend plus probable que vous compreniez vraiment 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 Start()méthode à une classe qui devrait, si elle était un véritable objet, avoir également un état de repos. Si cela n'a aucun sens que votre objet existe lorsqu'il n'est pas en cours d'exécution (ou n'a aucun sens pour que votre objet fonctionne), je dirais que c'est une mauvaise pratique.

Vous pouvez utiliser l' initialisation paresseuse.

En programmation informatique, l'initialisation paresseuse est la tactique de retarder la création d'un objet, le calcul d'une valeur ou un autre processus coûteux jusqu'à la première fois qu'il est nécessaire.

De cette façon, vous évitez le couplage temporel, ce qui signifie que le consommateur de votre classe doit appeler certaines méthodes dans un certain ordre. Avoir à appeler en start()premier est un moyen de savoir comment fonctionne la classe en interne, ce qui est mauvais car vous pourriez changer cela à l'avenir.

Retardez 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

    }
}