Fala ai Radizeiros e Radizeiras, tudo bem com vocês?

Quantas você ao gerar um relatório, ou uma pesquisa no banco de dados encontrou uma certa lentidão?

Até mesmo você gerar uma barra de progresso, mas mesmo assim se depara com aquelas travas que lhe dão maior dor de cabeça.

Qualquer rotina que venha se comunicar com o banco de dados é demorado, dependendo da quantidade de dados.

E com isso gerando insatisfação do usuário.

No post de hoje estarei mostrando para vocês como criar um Loading para o banco de dados usando Task.

E sei que muitos de vocês precisam disso, e estou aqui para mostrar isso para vocês.

E irei mostrar para vocês utilizando o que já fizemos no post anterior.

E com essa técnica nós vamos fazer isso aqui.

Criaremos um Loading do banco de dados.

Iremos fazer isso dentro desse post, como fazer um loading, onde iremos carregar os dados do banco, mas mostrando esse Loading bonitinho para o usuário.

Tudo isso respeitando a experiência do usuário, para que o mesmo não tenha a impressão que a aplicação travou.

Isso é se importar com a experiência do usuário.

E com essa técnica que irei mostrar hoje, você já consegue aplicar os Loading em seus projetos.

Você pode observar que ao clicar em buscar de dados apareceu aquele Loading que encontramos em diversos sistemas web, muito legal não é?

Isso tudo na VCL.

Esse Loading aguardando os dados chegarem do banco, e assim que os dados chegam este Loading sai da tela, trazendo todos os dados.

Vou mostra como foi feito num passo a passo.

Primeira coisa é o Loading.

Primeira coisa que foi feito, foi a criação de um form para o Loading.

E é muito simples deixarmos este Loading bonito como vocês viram no exemplo, com uma animação, sem aquele Loading padrão do Delphi.

Então, o que temos aí é um Gif.

Isso mesmo, fui no Google e simplesmente busquei por um Gif com fundo transparente.

Então adicionei esse Gif dentro de um TImage.

Só que, naturalmente um Gif dentro do TImage não funciona, ele não ativa, o que você tem que fazer, é adicionar uma linha de código.

procedure TForm2.Form2.FormCreate(Sender: TObject);
begin
    TGIFImage(Image1.Picture.Graphic).Animate := True;
end;

Eu chamo um TGIFImage, e passo o meu TImage, e depois passo o Animate True.

Só isso o GIF já vai estar funcionando.

Isso eu adiciono no Create do Form que mostrei na imagem acima.

E para o form ficar transparente você precisa primeiro tirar todas as bordas do form, bastando ir na propriedade BordeStyle passando None.

Depois você pega uma cor mais esquisita, isso mesmo, uma cor que você não irá usar de jeito nenhum dentro do seu projeto, e definir para esse form.

Dessa forma meu form todo irá ter essa cor.

E nas propriedades TransparentColor e TransparentColorValue, onde eu defino o Transparentcolor para true, e no TransparentColorValue você diz qual será a cor que irá deixar transparente, nesse caso a mesma cor do form.

Dessa forma todo o lugar que tiver essa cor irá ser transparente.

Assim temos o nosso form transparente.

Agora você deve estar se perguntando como foi feito a programação disso tudo.

Eu tenho normalmente nesse form um DBGrid, com FDConnectio, FDTabela, DataSource, uma tela normal, do jeito que muitos de vocês já trabalham.

O que fiz foi simplesmente utilizar o mesmo array de Tasks.

private
    AllTasks: array of ITask;
    FLoading: TForm3;
public
    procedure RunTask(var aTask: ITask);
    procedure ExibirLoading;

Observe que dentro do private também possui uma variável para o meu form de Loading.

E logo em seguida criei dos métodos, o RunTask, igual que fizemos em posts anteriores, e o ExibirLoading.

O que acontece quando eu clico para exibir os dados?

procedure TFom1.Button1Click(Sender: TObject);
begin
    SetLength(AllTasks, 1);
    RunTask(AllTasks[0]);
    ExibirLoading;
end;

Observe que eu aumento o array, pois se você observar eu não defini o tamanho dele.

Então todas as vezes que eu executar aumento esse array para mais uma Task.

Logo em seguida eu executo a Task, onde é nesse momento que busco so dados no banco.

Após isso eu chamo o ExibirLoading.

Então eu executo uma tarefa separada para buscar os dados, e o Exibir loading está em outro lugar trabalhando.

Observe o código da RunTask.

procedure TForm1.RunTask(var aTask: ITask);
begin
    aTask := TTask.Run(
    procedure
    begin
        FDTable1.Close;
        Sleep(10000);
        TThread.Synchronize(nil,
        procedure
        begin
            FDTable1.Open;
        end);
    end);
end;

Simplesmente eu chamo a Task.Run, como fiz no post anterior, fecho a tabela, e aí como os dados estão tudo local e não vai demorar tanto, eu coloquei um Sleep de propósito para demorar uns 10 segundos, logo após eu uso o Thread.Synchronize pois irei trabalhar com componente que não é Thread safe, que é o FDTable, dentro dele chamo um open.

E o Loading está trabalhando eu uma outra Task separada.

procedure TForm1.ExiirLoading;
begin
    TTask.Run(
    procedure
    begin
        TThread.Synchronize(TThread.CurrentThread,
        procedure
        begin
            FLoading := TForm2.Create(nil);
            FLoading.Show;
        end);
        TTask.WaitForAll(AllTasks);
        TThread.Queue(TThread.CurrentTHread,
        procedure
        begin
            FLoading.Close;
            FLoading.Free;
        end);
    end);
end;

Observe que ele está executando uma tarefa, dentro dessa tarefa ele está chamando o Thread.Synchronize, porque irei trabalhar com o formulário, onde a primeira coisa nessa tarefa é, criar o formulário de Loading e joga para tela.

Logo em seguida eu mando ele aguardar até que todas as tarefas do array de Tasks sejam finalizadas, e somente após todas essas tarefas de acesso ao banco terminar que irá jogar num Thread.Queue, ou seja, uma fila de Thread, usando a Thread principal para fechar o formulário e dar um Free nele, tirando ele da memória.

Muito legal né?

É a mesma técnica que usamos no post anterior.

Você percebeu que na mesma técnica que utilizamos para executar um exemplo simples, já conseguimos reproduzir num exemplo um pouco mais avançado.

E aí é esse resultado que vocês estão vendo.

 

Enquanto o Loading está em execução a minha aplicação não está travada, podendo trabalhar com demais informações tranquilamente.

Muito legal e prático.

Então é só pegar o que estamos mostrando aqui no blog e levar para o seu dia a dia, e eu tento ao máximo levar conteúdos para vocês que se apliquem ao seu dia a dia.

Esse conteúdo e dentre outros você consegue encontrar completo dentro do CLUBE DOS PROGRAMADORES EM DELPHI, uma gama de aulas com diversos temas que irá lhe auxiliar e muito no seu dia a dia.

E caso você tenha interesse de conhecer mais sobre PPL acessa o nosso portal do CLUBE DE PROGRAMADORES EM DELPHI, onde você não só terá conteúdos relacionados aos generics, mas uma quantidade enorme de conteúdos que poderá lhe ajudar muito no seu dia a dia, é uma verdadeira NETFLIX para os programadores Delphi.

CLIQUE AQUI E SAIBA MAIS SOBRE O CLUBE DOS PROGRAMADORES DELPHI