Home

Refatoração

• Codificamos para outras pessoas, eventualmente para a máquina.
• Quanto tempo o fonte é usado por máquinas? Quanto tempo é usado por humanos?
• A manutenibilidade do código precede seu desempenho.
• Em vez de validar parâmetros Null em cada método, deve-se garantir que eles não são nulos antes de se passar para o método. Isso é tornar o código mais robusto.
• Validar parâmetros nulos é como colocar escoras no método. Será que justifica-se em um legado onde você não tem controle de onde vem o parâmetro ou não tem tempo de procurar? Ou numa biblioteca onde você não sabe como o programador vai usar? Isso compromete a filosofia de fail fast.
• Fazer essa validação e executar o negócio compromete a responsabilidade única do método segundo o SOLID.
• Um método com nome muito longo significaria que ele pode ser separado em outra classe? Um nome comprido geralmente envolve nomeações de escopos que seriam a(s) nova(s) classe(s)?

SOLID e Injeção de dependência

Não é bom, classe faz mais de uma coisa, fere o Principio da Responsabilidade Única (SRP) do SOLID

TMinhaClasse = class
private
 procedure FazIsto; //se for usada herança para sobreescrever é pior ainda
 procedure FazAquilo;
public
 procedure FazCoisa;
end;

procedure TMinhaClasse.FazCoisa;
begin
 FazIsto;
 FazAquilo;
end;

É melhor, mas cria dependência de outras implementações

TMinhaClasse = class
public
 procedure FazCoisa;
end;

uses
 uClasseFazIsto, uClasseFazAquilo;

procedure TMinhaClasse.FazCoisa;
begin
 TClasseFazIsto.FazIsto(params); //não necessáriamente um método estático
 TClasseFazAquilo.FazAquilo(params);
end;

É melhor ainda, não fere o SRP e nem cria dependências

uses
 uInterfaceFazIsto, uInterfaceFazAquilo;
 
TMinhaClasse = class
private
 FIFazIsto: IFazIsto;
 FIFazAquilo: IFazAquilo;
public
 procedure FazCoisa;
end;

//injeção de dependência através de composição de objetos
//elimina a dependência das implementações e 
//dependências (dependências de dependências) das outras classes;
//Torna a classe mais reutilizável e
//independente/agnóstica ("desconhecedora") de outras implementações.
constructor TMinhaClasse.Create(_AIFazIsto: IFazIsto; _AIFazAquilo: IFazAquilo);
begin
 FIFazIsto := _AIFazIsto;
 FIFazAquilo := _AIFazAquilo;
end;

procedure TMinhaClasse.FazCoisa(_AParams: TTipoParam);
begin
 FIFazIsto.FazIsto(_AParams); 
 FIFazAquilo.FazAquilo(_AParams);
end;

Ou

uses
 uInterfaceFazIsto, uInterfaceFazAquilo;
 
TMinhaClasse = class
public
 procedure FazCoisa(_AParams: TTipoParam; _AIFazIsto: IFazIsto; _AIFazAquilo: IFazAquilo);
end;

//injeção de dependência no método, pode acabar criando uma lista de parâmetros considerável
procedure TMinhaClasse.FazCoisa(_AParams: TTipoParam; _AIFazIsto: IFazIsto; _AIFazAquilo: IFazAquilo);
begin
 _AIFazIsto.FazIsto(_AParams); 
 _AIFazAquilo.FazAquilo(_AParams);
end;