Share Button

Para aqueles momentos que quero varrer todos os componetes que estão no FORM para pegar quem são e aplicar um operador   AS que tal usar um metódo anônimo para isto….

Forma tradicional

A forma tradicional de se varrer todos os componentes que estão sobre responsabilidade do FORM é fazer um loop com FOR e avaliar um-a-um até encontrar o que se deseja.


var  i:integer;
begin
     for i := 0 to FormX.ComponentCount-1 do
     begin
           if FormX.Components[i] is TQuery then   // quero pegar so as TQuery
           with FormX.Components[i] as TQuery do
           begin   
               close;   // fechar a TQuery
           end;
     end;
 
end;

 

Loop de Componentes com Anonimous Methods

Utilizando “Anonimous Methods” é um modelo não tradicional de olhar a mesma questão. Entender a estrutura de um “Anonimous Method” pode simplificar muitas operações de codifição do dia-a-dia e como exemplo de fundo vamos varrer os componentes dos formulários…

  • Criando um HELPER para separar a lógica (o LOOP)
    type
      TComponentHelper = class Helper for TComponent
    
      public
        procedure ComponentsLoop(AProc: TProc<TComponent>; AChild: boolean = false);
      end;
    
    procedure TComponentHelper.ComponentsLoop(AProc: TProc<TComponent>; AChild: boolean = false);
    var
      i: integer;
    begin
      if assigned(AProc) then
        for i := 0 to ComponentCount - 1 do
        begin
          AProc(Components[i]);
          if AChild and (Components[i].ComponentCount > 0) then
            Components[i].ComponentsLoop(AProc, AChild);
        end;
    end;
    
  • Executando o LOOP utilizando o método anônimo do HELPER
    
    procedure TForm39.Button1Click(Sender: TObject);
    begin
      Memo1.Lines.Clear;
      ComponentsLoop(
        Procedure(AComp: TComponent)
        begin
          // fecha todos os TDataset  (TQuery)
          if AComp is TDataset then
            with AComp as TDataset do
                close;
    
        end, false);
    
    end;
    
    

 

Usando  Anonimous LOOP para um TList (genérico)

Quando vezes precisou fazer um loop em um TList….

  • Implementando um LOOP “anonimous” para o TList na classe HELPER
    procedure TComponentHelper.ListLoop(AList: TList; AProc: TProc<TObject>);
    var
      i: integer;
    begin
      for i := 0 to AList.Count - 1 do
        AProc(AList[i]);
    end;
    
    
  • Aplicando o LOOP “anonimous” em um TList
    procedure TForm39.Button3Click(Sender: TObject);
    var
      FList: TList;
    begin
      memo1.Lines.Clear;
      FList := TList.create;
      try
        PopularALista(FList);
    
        // fazer um LOOP usando Anonimous
        ListLoop(FList,
          procedure(AObj: TObject)
          begin
            memo1.Lines.Add( AObj.ClassName );
          end);
    
      finally
        FList.Free;
      end;
    end;
    
    

Parece Simples !!! Quantas vezes precisou escrever um LOOP em um TDataset (aka TQuery, TClientDataset)???

Código Exemplo  Helper para TDataset

 

 

Share Button

Assim como Class Helper extende classes, Record Helper permite extender
Records.

Quantas vezes já precisou fazer: total := total + x;
Utilizando helper poderia escrever assim: total.add( x );

Código Fonte no GIT

Share Button

A introdução de Class Helper no delphi ajudou o desenvolvedor a incluir novas
funcionalidades nas classes nativas do delphi – você tem uma idéia de um
recursos dos sonhos e gostaria de implementar lá na classe base, use Class
Helper.

Extendendo o TDataset:

TDatasetHelper = class helper for TDataset
public
   procedure Run(AProc:TProc<TDataset>);
end;

procedure TDatasetHelper.Run(AProc: TProc<TDataset>);
begin // executa em um thread separada
     TThread.CreateAnonymousThread(
         procedure begin
            if assigned(AProc) then
               AProc(self);
         end
     ).Start;
end;

O exemplo implementa a capacidade de uso da “procedure” RUN(…) por
qualquer classe com herança de TDataset.

Trabalhando com o novo procedimento:

O procedimento RUN por finalidade executar em um processo paralelo (uma
nova TThread) a rotina que estiver implementando no TProc.

var total:double;
begin
        query1.run(
                   procedure (ds:TDataset) // rotina a executar em paralelo.
                     begin
                       ds.first;
                       while ds.eof=false do
                       begin
                          total := total + xxxxx;
                          ds.next;
                       end;
                  end);
end;