Share Button

Interfaces disponíveis através de TTASK que se encontra na unit System.Threading…
Enquanto ITask aguarda uma chamada x.start; para iniciar o processamento em uma thread
própria… o IFuture já inicia o processamento de imediato e aceita aguardar uma resposta após o
término de execução.

Exemplo ITask: (aguarda start para iniciar)

   tsk := TTask.create( procedure begin
        // código a ser executado
      end);
   tsk.start;
   //pode ou não pedir para aguardar conclusão:
   tsk.wait( 1000000);</pre>

Exemplo IFuture: (inicia assim que for criado)

tsk = TTask.Future:boolean(
   function:boolean
   begin
       // código.....
       result := true; // resposta para o processamento
   end);

   resposta := tsk.value; // aguarda a thread terminal e pega o resultado

Se precisar retornar mais de um valor, pode usar um RECORD:

TPessoa = record
  nome:string;
  idade:integer;
 end;

tsk = TTask.Future:TPessoa(
    function:TPessoa
    begin
          // código.....
       result.nome := 'Nome'; // resposta para o processamento
       result.idade := 18;
    end);

resposta := tsk.value; // aguarda a thread terminar e pega o resultado
if resposta.idade&gt;18 then
    xxxxx

Share Button

Na versão XE7 foi incorporado ao Delphi o conceito de processamento paralelo. Antes já era
possível fazer algo parecido utilizando bibliotecas de terceiros
[http://www.omnithreadlibrary.com/index.htm http://andy.jgknet.de/blog/bugfix-units/asynccalls-
29-asynchronous-function-calls/].
Para tentar simplificar o conceito, diz paralelo quando consegue executar dois ou mais processos ao
mesmo tempo, daí o nome “paralelo”.

Exemplo utilizando TTask:

var
tsk: array [0 .. 2] of ITask;
i, n: integer;
begin
   tsk[0] := TTask.create(
       procedure
        begin
          TThread.Queue(nil, procedure
             begin
               caption := 'xxx'; // sincronizar a atualização da janela.
             end);
        end);
   tsk[0].Start; // inicia o processamento antes de criar as TTask seguintes
   tsk[2] := TTask.create(
       procedure
          var
          k: integer;
          begin
             i := 1;
             sleep(1000);
             for k := 0 to 10000 do
                inc(i);
          end);
tsk[1] := TTask.create(
          procedure
          var
          k: integer;
          begin
              n := n;
              for k := 0 to 1000 do
                inc(n);
              add( 'N');
          end);
tsk[2].Start; // inicia o processamento
tsk[1].Start;
TTask.WaitforAll(tsk); // quando quer aguardar o termino de todas as TTasks

Share Button

Houve um tempo que executar tarefas em “background” era um tortura.
Com a evolução de hardware e software, fazer uso de computação paralela passou a ser tão
fácil quanto um desafio em resistir ao seu uso.

Introduzida na versão XE7, um “thread” passou a rodar considerando o balanceamento entre
os processadores presentes na unidade de processamento.

Associar o uso de métodos anônimos facilitou em muito todo o trabalho:

TThread.CreateAnonymousThread(
procedure begin
    // execute aqui o seu código
      ....
    // se precisar sincronizar atualização de 
    // controles da janela
    TThread.Queue(nil,
             procedure begin
                     // aqui deve incluir a atualização 
                     //      dos controles da janela;
                     // ex: label1.caption := 'texto';
             end);
         end).Start;

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;

Share Button

Usando a System.ZIP para gerar arquivo ZIPContinuar lendo

Share Button

Para descompactar um arquivo ZIPContinuar lendo

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

Share Button

O uso de Datasnap como cliente de acesso ao servidor JSON é resultante de uma combinação de componentes do delphi para completar a chamada. Se do lado do Servidor há um Datasnap então o lado cliente é facilitado ao coletar informações dos métodos exportados pelo servidor e geração do cliente automático. A implementação do servidor JSON pode apresentar uma variedade muito grande de formato de publicação (ou não) dos seus métodos, o que pode se tornar bastante trabalhoso a implementação do cliente.

Simplificando o trabalho:

TRESTSocialClient


Encapsula os componentes necessário para efetivar uma troca de informações entre do servidor para o cliente.

 public
    function Response: TRESTResponse;
    function Request: TRESTRequest;
    function Auth2: TOAuth2Authenticator;
    property AccessToken: string read GetAccessToken write SetAccessToken;
    procedure Clear; virtual;
    constructor create(ow: TComponent); override;
    destructor destroy; override;
    function Get(url: string; AResource: string = ''): string; virtual;
    function GetStream(AUrl: string; AResource: string; AStream: TStream)
      : integer; virtual;
    function SendStream(AUrl, AResource: string; AStream: TStream)
      : integer; virtual;
    function Post(url: string; AResource: string = ''): string; virtual;

 

 var rsp:string;
  with TRESTSocialClient.create(nil) do
  try
    rsp := Get('http://meuservidor/xxxx', '/GetCliente?codigo=1');  // chama o servidor                                                                 para pegar GetCliente.... finally
     free;
  end;

TRESTSocialClientDataset


Herança de TRESTSocialClient que associa a resposta do servidor um Dataset.

  with TRESTSocialClientDataset.create(nil) do
  try
    // pode indica um DATASET, para obter o retorno
    Dataset := MeuDataset;   // se nao for informado retorna um Dataset   TFDMemTable
    rootElement := 'result';  // espera um Array com as linhas da tabela;  
    rsp := Get('http://meuservidor/xxxx', '/GetCliente?codigo=1');  
                                                         // chama o servidor                                                                para pegar GetCliente....  
  finally
     free;
  end;

Exemplo:  REST.Social