-
Notifications
You must be signed in to change notification settings - Fork 2
Home
Jerson Seling edited this page Aug 10, 2020
·
4 revisions
- 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)?
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;