Czy metoda „start”, „uruchom” lub „uruchom” jest dobrą praktyką?

Obecnie pracuję nad bazą kodu, która ma wiele klas, które implementują metodę Start. Wydaje mi się to konstrukcją dwufazową, co zawsze uważałem za złą praktykę. Nie umiem odróżnić tego od konstruktora.

Kiedy należy zastosować metodę początkową zamiast normalnej konstrukcji obiektu?

Kiedy powinienem używać konstruktora?

Edycja: Nie sądzę, że jest to tak istotne, ale językiem programowania jest C #, może on również mieć zastosowanie do Java lub C ++

Start()Sposób (jak Run(), Execute()lub coś podobnego) jest odpowiedni, gdy koszt budowy obiekt jest niska, a koszty stosując jest wysoki. Na przykład: Klasa, która zawiera algorytm optymalizacji najlepszej ścieżki. Ustawienie go z zestawem parametrów ( Xkwadraty za Ykwadraty, przy użyciu takiej metody oceny) jest trywialne , ale wykonanie może zająć trochę czasu. Jeśli chcesz utworzyć 20 takich obiektów, możesz opóźnić wykonanie, aż wszystkie zostaną utworzone - pozwala to na przykład łatwiej zrównoleglić je.

Alternatywnie może być przydatny, gdy nie wiesz, kiedy obiekt będzie potrzebny do uruchomienia - być może dlatego, że jest oparty na danych wejściowych użytkownika lub logice, która wybiera z listy możliwości.

Zakłada się oczywiście, że Start()jest to użyteczna metoda na obiekcie, a nie odpowiednik Initialize()metody. Jeśli jest to dodatkowy sposób na ustawienie większej liczby parametrów, nie powinien istnieć.

Code Complete (i wiele innych zasobów inżynierii oprogramowania) kładzie nacisk na dopasowanie twoich klas do rzeczywistych obiektów. Uważam, że podstawową przyczyną tego jest fakt, że bardziej prawdopodobne jest, że naprawdę rozumiesz, co wdrażasz, niż przekłamywanie nienamacalnego pomysłu.

Jeśli jesteś subskrybentem tej teorii, nie widzę nic złego w dodawaniu Start()metody do dowolnej klasy, która powinna, gdyby był to prawdziwy obiekt, również mieć stan spoczynku. Jeśli nie ma sensu istnienie obiektu podczas jego działania (lub w ogóle nie ma sensu, aby obiekt działał), powiedziałbym, że jest to zła praktyka.

Możesz użyć leniwej inicjalizacji.

W programowaniu komputerowym leniwa inicjalizacja to taktyka opóźniania tworzenia obiektu, obliczania wartości lub innego kosztownego procesu do momentu, gdy jest to potrzebne.

W ten sposób unikasz łączenia czasowego, co oznacza, że ​​konsument twojej klasy musi wywoływać określone metody w określonej kolejności. start()Najpierw musisz zadzwonić , aby dowiedzieć się, jak działa klasa, co jest złe, ponieważ możesz to zmienić w przyszłości.

Opóźnij kosztowną inicjalizację, dopóki nie będzie potrzebna.

Przykład:

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

    }
}