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

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;

Share Button

Com a crescente número de amigos que estão navegando em serviços
cambiáveis entre aplicativos (ou linguagens), serializar um TDataset pode ser
uma solução simples e “stander” de mercado para troca de informações.
Depois de muitas idas e vindas vou deixar o resultado do trabalho que já fiz
sobre o assunto

uses System.uJson, Data.DB.Helper;
function DatasetToJson( const ADataset:TDataset ) : string;
begin
result := ADataset.ToJson;
end;

Fonte: Data.DB.Helper.pas System.uJSON.pas