É um método "iniciar", "executar" ou "executar" uma boa prática?

Atualmente, estou trabalhando em uma base de código que possui muitas classes que implementam um método Start. Parece-me uma construção em duas fases, que eu sempre considerara uma prática ruim. Não sei dizer a diferença entre isso e um construtor.

Quando é apropriado usar um método start em vez da construção normal do objeto?

Quando devo preferir usar o construtor?

Edit: Eu não acho que seja relevante, mas a linguagem de programação é C #, poderia ser aplicada igualmente a Java ou C ++

Um Start()método (como Run(), Execute()ou algo semelhante) é apropriado quando o custo de construção do objecto é baixa, mas o custo de utilização é elevada. Por exemplo: Uma classe que encapsula um algoritmo de otimização do melhor caminho. É trivial configurá-lo com um conjunto de parâmetros ( Xquadrados por Yquadrados, com esse método de avaliação), mas pode demorar um pouco para ser executado. Se você deseja criar 20 desses objetos, pode atrasar a execução até que todos eles tenham sido criados - isso permite paralelizá-los mais facilmente, por exemplo.

Como alternativa, pode ser útil quando você não sabe quando o objeto será necessário para iniciar - talvez porque seja baseado na entrada do usuário ou na lógica que seleciona em uma lista de possibilidades.

Isso pressupõe, é claro, que Start()é o método útil no objeto, e não equivalente a um Initialize()método. Se é apenas uma maneira extra de definir mais parâmetros, ela não deveria existir.

O Code Complete (e muitos outros recursos de engenharia de software) enfatiza a correspondência de suas classes com objetos do mundo real. Acredito que a razão fundamental para isso é que torna mais provável que você tenha uma compreensão verdadeira do que está implementando, em vez de se esquivar de uma ideia intangível.

Se você é assinante dessa teoria, não vejo nada de errado em adicionar um Start()método a qualquer classe que, se fosse um objeto real, também tivesse um estado de repouso. Se não faz sentido que seu objeto exista enquanto não está em execução (ou não faz sentido que ele esteja em execução), então eu diria que é uma má prática.

Você pode usar a inicialização lenta.

Na programação de computadores, a inicialização lenta é a tática de atrasar a criação de um objeto, o cálculo de um valor ou algum outro processo caro até a primeira vez que for necessário.

Dessa forma, você evita o acoplamento temporal, o que significa que o consumidor de sua classe precisa chamar certos métodos em uma certa ordem. Ter que ligar start()primeiro é uma maneira de saber como a classe funciona internamente, o que é ruim, porque você pode mudar isso no futuro.

Atraso na inicialização cara até que seja necessário primeiro.

Exemplo:

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

    }
}