Skip to content

Home

Jump to bottom
Jerson Seling edited this page Aug 10, 2020 · 4 revisions

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;

Clone this wiki locally