Pois bem, primeiro artigo aqui pro TechTips, serei breve(o quando for possível) e objetivo sobre o assunto em questão, e as dúvidas que surgirem envie-as na parte de comentários, okas?

Antes de começar, uma pequena explicação sobre as nomeclaturas: – Lista encadeada(Chained List) ou Lista ligada(Linked list) são a mesma coisa, em algums cursos um termo ou outro é usado mas o objetivo e estrutura não diferem.

Esse artigo está sendo escrito levando como base o desenvolvimento em Delphi 7, versões superiores a essa podem ter implementações nativas dessa estrutura ou mesmo disponibilizar facilitadores que fazem o código ser diferente.

Lista encadeada:

Algumas vezes quando precisamos guardar algumas informações picadas, como pacotes de dados de sockets ou audio, criamos uma lista encadeada que controla toda a informação sequencialmente e prove uma navegação nos dados guardados somente caminhando para frente ou para traz.

A estrutura de uma lista encadeada se divide em 2ª principais variáveis: Data(dados) e Next(ou Prior – Próximo ou Anterior – quando necessário), para cada item no seu encadeamento possue um dado(Ponteiro, valor ou alguma coisa que precisa guardar) e a referência para o próximo item ou anterior na lista. Lista encadeada não disponibiliza acesso direto os items, então você não poderá acessar um item sem navegar nos outros. Uma lista encadeada pode ser aperfeiçoada mas o principal objetivo é disponibilizar uma lista de capacidade quase infinita com a melhor performance do que outras técnicas.

Como você sabe, lista encadeadas não guardam indices para os itens(não tem acesso direto) e isso evita processos de reindexação(reorganização de indices) que consomem um grande tempo quando se tem uma lista grande de itens. Quando precisa-se remover um item de uma lista encadeada, você precisa de fazer a primeira melhoria na estrutura de encadeamento para segurar o item anterior e o próximo para cada item que tenha, e isso prove para você um caminho confortável para manipular os itens sem ter que escrever um monte de códigos e variáveis.

Escrevi a implementação abaixo para servir de base para criação de listas encadeadas com navegação frente-traz:

uses SysUtils;

type
  PPointer = ^Pointer;

  TChainedList = class
  private
    FFirst   : Pointer;
    FLast    : Pointer;
    FCurrent : Pointer;
    FCount   : Integer;
    function GetCurrent: PPointer;
  public
    constructor Create;
    destructor Destroy; override;

    function First : TChainedList;
    function Last  : TChainedList;
    function Prior : TChainedList;
    function Next  : TChainedList;

    function Add: TChainedList;
    function Remove: TChainedList; overload;
    function Remove(AChainedReleaser: Pointer): TChainedList; overload;

    property Current: PPointer read GetCurrent;
    property Count: Integer read FCount;
  end;

implementation

type
  PChainedItem = ^TChainedItem;
  TChainedItem = record
    Prior, Next: PChainedItem;
    Data: Pointer;
  end;

{ TChainedList }

constructor TChainedList.Create;
begin
  FCount := 0;
  FFirst := nil;
  FLast := nil;
  FCurrent := nil;
end;

destructor TChainedList.Destroy;
begin
  First;
  while Current <> nil do
    Remove;

  inherited;
end;

function TChainedList.GetCurrent: PPointer;
begin
  if FCurrent <> nil then
    Result := @PChainedItem(FCurrent).Data
  else
    Result := nil;
end;

function TChainedList.First: TChainedList;
begin
  FCurrent := FFirst;
  Result := Self;
end;

function TChainedList.Last: TChainedList;
begin
  FCurrent := FLast;
  Result := Self;
end;

function TChainedList.Prior: TChainedList;
begin
  if FCurrent <> nil then
    FCurrent := PChainedItem(FCurrent)^.Prior
  else
    FCurrent := nil;
  Result := Self;
end;

function TChainedList.Next: TChainedList;
begin
  if FCurrent <> nil then
    FCurrent := PChainedItem(FCurrent)^.Next
  else
    FCurrent := nil;
  Result := Self;
end;

function TChainedList.Add: TChainedList;
var
  pNew: PChainedItem;
begin
  New(pNew);
  pNew^.Prior := nil;
  pNew^.Next := nil;
  pNew^.Data := nil;

  if FFirst = nil then
  begin
    FFirst := pNew;
    FLast := pNew;
  end else
  begin
    pNew^.Prior := PChainedItem(FLast);
    PChainedItem(FLast)^.Next := pNew;
    FLast := pNew;
  end;

  FCurrent := FLast;
  Result := Self;
  Inc(FCount);
end;

function TChainedList.Remove: TChainedList;
var
  pCur: PChainedItem;
begin
  pCur := FCurrent;
  if pCur^.Data <> nil then
    raise Exception.Create('Current item memory leak detected.');

  if pCur^.Next <> nil then
    pCur^.Next^.Prior := pCur^.Prior;

  if pCur^.Prior <> nil then
    pCur^.Prior^.Next := pCur^.Next;

  if pCur = FFirst then
  begin
    FFirst := pCur^.Next;
    FCurrent := FFirst;
  end else if pCur = FLast then
  begin
    FLast := pCur^.Prior;
    FCurrent := FLast;
  end else
    FCurrent := pCur^.Next;

  Result := Self;
  Dispose(pCur);
  Dec(FCount);
end;

function TChainedList.Remove(AChainedReleaser: Pointer): TChainedList;
type
  TRelease = procedure(APointer: Pointer);
var
  PdrRelease: TRelease;
begin
  @PdrRelease := AChainedReleaser;
  PdrRelease(PChainedItem(FCurrent)^.Data);
  PChainedItem(FCurrent)^.Data := nil;
  Remove;
end;

O entendimento e utilização:

Fiz utilização de ^(circunflexo)s para evidenciar que o acesso é atravez de ponteiro(No caso desse código desde o Delphi 5 a optimização de código já consegue compilar corretamente sem necessidade de uso do ^).

Como vocês podem observar, a classe TChainedList é bastante robusta e prove um controle bem extenso sobre a lista criada, suas caracteristicas são:

1. Navegação Frente-Traz, Inicio e Fim
2. Acesso ao dados guardados no item atraves da propriedade Current
3. Controle de quantidade de items na lista
4. Métodos de adicão e remoção de items, sendo que a remoção disponibiliza um callback para liberação de memória dos dados guardados

Sendo assim, o que é possível fazer com a utilização da TChainedList?
- Vamos ao exemplo prático da utilização, veja abaixo:

Passos para iniciar a utilização de teste:

1. Iniciar um projeto Win32 no Delphi
2. nomear o Form principal para frmMain
3. Adicionar um TEdit: edtWord
4. Adicionar um TButton: btnAdd – Caption = “Adicionar”
5. Adicionar um TLabel: lblPhrase
6. Adicionar um TButton: btnClean – Caption = “Limpar”
7. Criar uma variável tipo TChainedList de escopo publico em frmMain de nome Phrase
8. Criar um método chamado UpdateList de escopo publico em frmMain

Código:

uses ChainedListCtrl;

type
  TfrmMain = class(TForm)
    edtWord: TEdit;
    btnAdd: TButton;
    lblPhrase: TLabel;
    btnClean: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btnAddClick(Sender: TObject);
    procedure btnCleanClick(Sender: TObject);
  private
    { Private declarations }
  public
    Phrase: TChainedList;
    procedure UpdateList;
  end;

var
  frmMain: TfrmMain;

implementation

{$R *.dfm}

Linkando o evento FormCreate do frmMain o Phrase deve ser criado:

{ Note: Create the Chain List Control Object
}
procedure TfrmMain.FormCreate(Sender: TObject);
begin
  Phrase := TChainedList.Create;
end;

Linkando o evento FormDestroydo frmMain o Phrase deve ser destruído:
OBS: A destruição do objeto Pharse não está associada a liberação de memória dos items, então caso a o aplicativo seja fechado e o Pharse destruido sem limpar a lista ocorrerá vazamento de memória(vide btnCleanClick para liberação dos items)

{ Note: Destroy the Chain Object
}
procedure TfrmMain.FormDestroy(Sender: TObject);
begin
  Phrase.Free;
end;

Codificando o método UpdateList. Esse método é o responsável por exibir a frase, listando as palavras adicionadas na lista.

{ Note: Update the Label to hold all the words
        included on the Chained list
}
procedure TfrmMain.UpdateList;
var
  sPhrase: string;
begin
  sPhrase := '';
  Phrase.First;
  while Phrase.Current <> nil do
  begin
    if sPhrase <> '' then
      sPhrase := sPhrase + ' ';

    sPhrase := sPhrase + PChar(Phrase.Current^);
    Phrase.Next;
  end;
  lblPhrase.Caption := sPhrase;
end;

Linkando o evento OnClick do btnAdd o texto escrito em edtWord deve ser adicionado a lista Phrase:

{ Note: Add the text on the Chain
   p.s: StrNew create a copy of the string that will be managed
        out of the garbage collector(str refcount structure)
}
procedure TfrmMain.btnAddClick(Sender: TObject);
begin
  Phrase.Add.Current^ := StrNew(PChar(edtWord.Text));
  UpdateList;
end;

Linkando o evento OnClick do btnClean a lista Phrase deve ser limpa e os items devem ser removidos para evitar vazamento memória.

{ Note: Clean the Chain list
   p.s: StrDispose release the memory of the create string
        to avoid memory leaks
}
procedure TfrmMain.btnCleanClick(Sender: TObject);
begin
  Phrase.Last;
  while Phrase.Current <> nil do
    Phrase.Remove(@StrDispose);
  UpdateList;
end;

Os comentários em inglês no código estão presentes porque o artigo é uma transcrição do artigo Delphi: Chained List juntamente com a publicação do Delphi: Utils :: TChainedList.

Entendendo a estrutura de uma Lista encadeada:

Estou complementando aqui o artigo, o que vai diferir do artigo em inglês será essa parte, pois agora explicarei a estrutura da lista encadeada de forma mais programática.

De acordo com os exemplos e explicações acima podemos concluir que a lista é criada através dos itens existentes e relacionados e não por um outro objeto que controla os items individualmente, ou seja, um item sabe que o(s) “vizinho(s)” existe(m) sem precisar sair do seu escopo.

O funcionamento disso em programação é a base de referências(ponteiro), pois assim a movimentação de memória e consumo da mesma fica estrito a modificações nos itens e não na gerência da lista. Mas o que isso quer dizer?
- Quer dizer que para se remover um item você precisa apenas avisar seu(s) vizinho(s) que ele não está mais na lista. Programaticamente falando o resultado disso é:

Lista:
    Item1
      Next -> Item2
                Next -> Item3
                          Next -> nil

Remoção do Item2
    Item1
      Next -> Item2.Next -> Item3
                              Next -> nil

              Item2(Removido)
                Next -> Item3

O que foi feito acima foi somente a assimilação do Next do Item1 com o Next do Item2, resultando em uma lista que caminha do Item1 para o Item3, sendo que o Item2 ficará fora da sequência.

Outro fato importante é que trabalhando com referências, você não terá objetos repetidos, ou seja, se você modificar o Item3 seja pelo Item2.Next ou seja depois da remoção pelo Item1.Next você estará acessando o mesmo ponto da memória. Mas essas explicações não serão contempladas nesse artigo para não estender muito o assunto e perder o foco. Mas vale a dica de entendimento de referências(Pointeiros) para todos que não compreendem bem o estrutura da memória.

Exemplo com descendência (mais código, menos dificuldade):

Para simplificar um pouco as coisas, deixar a utilização dos ponteiros centralizada, você pode estender a classe da forma que precisar em seu projeto, neste caso vou exemplificar como seria a extensão de TChainedList para o nosso exemplo:

type
  TPhraseChainedList = class(TChainedList)
  public
    procedure AddWord(const AWord: string);
    procedure RemoveWord;
    procedure Clear;
    function CurrWord: string;
  end;

{ TPhraseChainedList }

procedure TPhraseChainedList.AddWord(const AWord: string);
begin
  Add.Current^ := StrNew(PChar(AWord));
end;

procedure TPhraseChainedList.RemoveWord;
begin
  Remove(@StrDispose);
end;

procedure TPhraseChainedList.Clear;
begin
  Last;
  while Current <> nil do
    RemoveWord;
end;

function TPhraseChainedList.CurrWord: string;
begin
  Result := PChar(Current^);
end;

Assim, na hora de utilizar, 4 métodos do nosso exemplo anterior vão ser modificados: FormCreate, UpdateList, btnAddClick e btnCleanClick;

{ Note: Create the Chain List Control Object
}
procedure TfrmMain.FormCreate(Sender: TObject);
begin
  Phrase := TPhraseChainedList.Create;
end;

{ Note: Update the Label to hold all the words
        included on the Chained list
}
procedure TfrmMain.UpdateList;
var
  sPhrase: string;
begin
  sPhrase := '';
  Phrase.First;
  while Phrase.Current <> nil do
  begin
    if sPhrase <> '' then
      sPhrase := sPhrase + ' ';

    sPhrase := sPhrase + Phrase.CurrWord;
    Phrase.Next;
  end;
  lblPhrase.Caption := sPhrase;
end;

{ Note: Add the text on the Chain
}
procedure TfrmMain.btnAddClick(Sender: TObject);
begin
  Phrase.AddWord(edtWord.Text);
  UpdateList;
end;

{ Note: Clean the Chain list
}
procedure TfrmMain.btnCleanClick(Sender: TObject);
begin
  Phrase.Clear;
  UpdateList;
end;

Caso seja interessante podemos estender ainda mais, criando uma função que me retorna a frase, assim não teriamos que nos preocupar com a geração da frase quando for preciso pegar o valor em outro local.

  TPhraseChainedList = class(TChainedList)
  public
    ...
    function ThePhrase: string;
  end;

function TPhraseChainedList.ThePhrase: string;
begin
  Result := '';
  First;
  while Current <> nil do
  begin
    if Result <> '' then
      Result := Result + ' ';

    Result := Result + CurrWord;
    Next;
  end;
end;

O UpdateList ficaria assim, ou mesmo deixaria de existir porque não teria uma grande utilidade após a implementação acima:

{ Note: Update the Label to hold all the words
        included on the Chained list
}
procedure TForm1.UpdateList;
begin
  lblPhrase.Caption := Phrase.ThePhrase;
end;

Agradecimentos:

Quero aqui agradecer ao pessoal de bem que sempre está em contato comigo me dando apoio.
Ao Leonel que deixou eu escrever esse monte de coisas aqui.
Ao Itamar Bermond que fornece a hospedagem do meu site, porque sem isso talvez nem escreveria nada de útil na internet.
À meus punhos e cérebro.

E lembrando: Fé move montanhas e a programação move o futuro.

Abraços e agradeço a paciência.

      Na maioria dos componentes Grids, de terceiros, você pode observar que o usuário pode mover colunas e linhas usando o mouse. Aliás, o usuário espera este comportamento de um Grid. Então, como fazer isso usando um TStringGrid?

      Como sempre, se é isso que você estava querendo implantar em seu aplicativo, mais uma vez “seus pobrêma se acabaram-se”,  apresentamos o incrível GridColumnRowMoveitor Tabajara.

      Mais uma vez… mão na massa e chega de enrolação.

      Primeiro de tudo, se você der uma olhada mais aprofundada no componente TCustomGrid você verá que os métodos MoveColumn e MoveRow estão lá, fazem parte do componente, mas eles estão ocultos no TStringGrid, eles são herdados do ancestral TCustomGrid porém não estão acessíveis no descendente, o motivo?? Ora, vai lá saber o que se passa na cabeça dos garotos da Codegear…

      Como resolver esse problema? Simples e fácil, sem maiores complicações, basta fazer uma herança de TStringGrid e redeclarar estes métodos como public.

type
    TNovoGrid = class(TStringGrid)
    public
    procedure MoveColumn(FromIndex, ToIndex: LongInt);
    procedure MoveRow(FromIndex, ToIndex: LongInt);
   end;

   Para implementar estes métodos é muito simples, basta na implementação, chamar o ancestral e passar para ele o comando:

procedure TNovoGrid.MoveColumn(FromIndex, ToIndex: LongInt);
begin
    inherited;
end;

procedure TNovoGrid.MoveRow(FromIndex, ToIndex: LongInt);
begin
    inherited;
end;

     Você não precisa registrar este componente na paleta de componentes. Use o TStringGrid ou qualquer descendente de TCustomGrid normalmente como já faz hoje, e quando você precisar usar estes métodos, simplesmente faça um typecast (conversão de tipos) para a nova classe, e pronto. Veja o exemplo abaixo:

procedure TForm1.Button1Click(Sender: TObject);
begin
       TNovoGrid(StringGrid1).MoveColumn(2, 5);
end;

    Bom, é isso aí, até a próxima.
    www.spectrus.com.br

      Bom, você certamente já pesquisou algum endereço pelo google maps, e ficou imaginando que colocar aquilo no seu aplicativo seria uma boa idéia.
      Pois agora, seus problemas “acabaram-se”, com o novo googlemapeitorparaseuaplicativeitor Tabajara, as coisas finalmente vão acontecer.

      Veja abaixo como fazer para colocar o Google para trabalhar para você, e mostrar para seus clientes, ou para o chefe, como você é esperto (Não tanto quanto o Larry Page e o Sergey Brin, pois eles ganham fortunas com o Google, e você ainda está bem distante de conseguir comprar 1 Boeing só para fazer baladas nos céus como eles fazem).

     Mãos à obra entonces:

     Temos uma tabela de Clientes, 4 campos desta tabela nos interessam, que contém os dados que usaremos para pesquisar no mapa.

    Logradouro = Contém o nome do logradouro do endereço, por exemplo “Rua Jesuíno Arruda”.
    Numero = Contém o número do endereço, apenas o número e não o complemento (sala, loja, etc), por exemplo: 769 
    Cidade = O nome da cidade, por exemplo: São Paulo
    UF = A sigla do estado, exemplo SP.

Vamos criar uma função que vai fazer o trabalho, é simples, prático e bem rápido.

procedure TForm1.CarregaMapa;
begin
  ShellExecute(0, Nil,
    PChar(‘http://maps.google.com.br/maps?f=q&source=s_q&hl=pt-BR&geocode=&q=’ +Clientes.FieldByName(‘Logradouro’).AsString + ‘, ‘ + Clientes.FieldByName(‘Numero’).AsString + ‘, ‘ +
      Clientes.FieldByName(‘Cidade’).AsString + ‘-’ + Clientes.FieldByName(‘UF’).AsString + ‘&jsv=143c&sll=-23.186453,-46.884453′ +
      ‘&sspn=0.478436,0.545883&g=&ie=UTF8&ct=clnk&cd=1′), Nil, Nil, 0);
end;

    Basta chamar a função e será carregado o browser com o mapa correspondente ao endereço passado.

    No próximo post vamos ver como fazer para, além de mostrar o mapa, traçar a rota entre dois endereços.

    Como sempre falo : Google é seu amigo, use-o.
    www.spectrus.com.br

Normalmente quando compilamos um aplicativo com a opção “Build with runtime packages” marcada, no mínimo teremos que redistribuir os pacotes rtlxx.bpl e vclxx.bpl (onde o “xx” equivale à versão do Delphi, pelo menos até o Delphi 7), mais os pacotes referenciados pelas units da vcl e/ou de terceiros.

Agora imagine um projeto grande, onde temos vários componentes de terceiros empregados. Quantos arquivos extras se tornariam dependências para o aplicativo?

Procurando uma maneira simples para minimizar o número de arquivos a serem distribuídos em conjunto com um aplicativo que use runtime packages, me deparo com o excelente tutorial de Keith Johnson, ao qual não posso acrescentar muita coisa, por já ser muito completo e didático. Contento-me a simplificá-lo e torná-lo útil para a realidade de muitos aqui.

Direto ao ponto

Figura 1 – Aplicativo com pacotes dinâmicos de forma convencional.

Figura 2 – Aplicativo com pacotes dinâmicos carregando de um único pacote.

Abra o Delphi, crie um novo aplicativo e salve o projeto. Adicione os componentes necessários de forma natural, como se fosse um projeto comum e salve.

Agora você pode fechar seu projeto e criar um novo package, ou criá-lo no mesmo grupo de projetos. Para simplificar, vou usar a segunda opção. Crie uma Unit vazia dentro deste novo package.

Você deverá percorrer TODOS os forms do seu projeto, vasculhando as cláusulas Uses para que todas as units referenciadas sejam adicionadas àquela unit do nosso pacote. Nosso objetivo será fazer com que o pacote importe todas essas units implicitamente para dentro dele, para que o executável tenha apenas ele como dependência. Para isso vá até Project -> Options e escolha a opção “Directories/Conditionals”, altere o “Output directory” e o “DCP directory” para uma pasta onde estará seu executável (o “DCP directory” é necessário na hora da compilação do executável, pois ele vai procurar pelo arquivo .dcp do pacote, mas em tempo de execução, ele só precisará do arquivo .bpl), ou onde ele tenha acesso pelo path do Windows.

É preferível deixar junto ao executável como numa pasta “bin” do seu projeto para facilitar a localização e distribuição, evitando um “bpl hell”. Clique em Ok e vá até aquela unit que você criou dentro do pacote. Adicione uma cláusula Uses a ela e coloque todas as units referenciadas pelo seu aplicativo.

No diretório de saída que você acabou de configurar, coloque uma cópia da SysInit.dcu, que se encontra em $(BDS)\lib (ex: C:\Arquivos de programas\CodeGear\RAD Studio\5.0\lib). Esta unit faz-se necessária, pois se você tentar compilar seu projeto sem ela, vai disparar uma exceção, informando que não foi possível encontrar SysInit.dcu (lembre-se: o search path que você configurou sobrepõe o default do Delphi, daí ele não achar). Mesmo assim, esta unit não deve ser adicionada na sessão uses da unit do pacote, deverá apenas permanecer lá na pasta de destino. Vá até a sessão “requires” do seu pacote lá no Project manager e elimine TODAS as referências a outros packages, deixando-a vazia.

Agora compile seu pacote. Irá aparecer uma mensagem, dizendo que você deve incluir os packages da lista para manter compatibilidade com outros pacotes já instalados.

É agora que vem o segredo: Escolha “Cancel” para que as units referenciadas sejam importadas para dentro de nosso pacote, e não as referências aos seus respectivos packages. Outro diálogo aparecerá com a mensagem: “If these changes are not applied, errors may occur when the package is loaded. Cancel changes?”.

Escolha “Yes” agora. Toda vez que esse pacote for recompilado você deverá seguir estes passos.

Se você verificar o resultado, poderá comprovar um package de até vários megabytes na pasta de destino (em um projeto que temos por aqui, está em torno de 13MB). Então, acabou? Ainda não, só mais uns ajustes no executável.

Considerando que você seguiu meu conselho e criou uma pasta só para os binários (“bin”, onde estarão .exe, .dcp, .bpl), selecione o projeto do executável agora, vá até Project -> Options e escolha a opção “Directories/Conditionals”, lá em “Search path”, coloque o caminho da pasta Bin do seu projeto e faça o mesmo para o “Output directory”.

Ainda nesta tela, escolha a opção “Packages”, marque a opção “Build with runtime pakages” e no Edit, limpe tudo, para adicionar apenas o nome do seu pacote.

Clique em Ok e dê um build no seu aplicativo. Com isso, você já poderá notar uma redução de até 90% no tamanho do executável.

Como já dito antes, para a distribuição do nosso aplicativo teste, apenas os 2 arquivos acima marcados serão necessários.

Conclusão

Quais as vantagens que podemos tirar deste método? Teremos todas as vantagens de se utilizar pacotes dinâmicos em um aplicativo, como velocidade na compilação (lembre-se que na maioria das vezes, você compilará apenas o código associado diretamente ao seu aplicativo, pois o código dos componentes já está embutido no pacote), executáveis e dlls muito menores (muito mais simples e rápido para atualizar seu aplicativo junto aos clientes) e maior facilidade para implementação de plugins, seja com dlls ou bpls. Se você colocar regras de negócio em um pacote ou fizer uso de rotinas muito sigilosas, poderá distribuir apenas os bpls do pacote livremente entre os desenvolvedores do projeto sem medo, pois estará fazendo uso do encapsulamento de código a seu favor.

E as desvantagens? Se você considerar todos os benefícios desta abordagem, o fato de ter que atualizar um pacote de 13MB (se compactar pode cair para 4MB ou 5MB) toda vez que mudar algum componente não pesará tão contra assim.

Este exemplo criou um único pacote com todas as units utilizadas pelo aplicativo, mas se você preferir poderá criar 2, 3 ou quantos pacotes precisar, separando-os por categoria, como pacotes de componentes visuais, acesso a dados, regras de negócio ou outra categoria que for necessária para seu projeto.

Este é o meu primeiro post, e espero que seja útil para quem precisar aplicar tais conceitos.

Closure é a união do código com o seu escopo. Isso quer dizer que o novo método tem acesso às variáveis locais do método que o criou, mesmo depois que ele terminou. Vamos ver como isso funciona com um exemplo:

type
  TContador = reference to function: Integer;

function CriaContador(Inicial, Final: Integer): TContador;
var
  i: Integer;
begin
  i := Inicial;
  Result := function: Integer
  begin
    Result := i;
    Inc(i);
    if i > Final then
      i := Inicial;
  end;
end;

var
  Contador: TContador;
  i: Integer;
begin
  Contador := CriaContador(5, 12);
  for i := 0 to 20 do
    WriteLn(Contador);
end.

Antes de ver a listagem da saída do programa, Vamos entender o código. TContador é um tipo que representa uma referência a uma função que retorna um número. Neste caso, vai retornar uma sequência de números, um número novo cada vez que for chamada. CriaContador é uma função que retorna um método desse tipo, recebendo os valores inicial e final que a sequência vai ter. Repare que o corpo de CriaContador tem apenas duas linhas de código que serão executadas quando ela for chamada: ela inicializa o contador, e atribui um novo método para o resultado.

No corpo do programa criamos um novo contador na faixa 5 até 12, e chamamos essa função 21 vezes, escrevendo o resultado no console.  Em cada chamada da função, ela retorna o valor atual de i, o incrementa, e caso tenha passado do valor final, volta ao primeiro.

Quais serão os 21 números escritos no console?

5
6
7
8
9
10
11
12
5
6
7
8
9
10
11
12
5
6
7
8
9

Ou seja, o programa funciona exatamente como descrevi.

Cada instância do método captura o escopo daquele momento. Se criarmos dois contadores:

var
  Contador, Contador2: TContador;
  i: Integer;
begin
  Contador := CriaContador(5, 8);
  Contador2 := CriaContador(1, 3);
  for i := 0 to 5 do
    WriteLn(Contador,':',Contador2);
end.

podemos ver que eles funcionam de forma completamente independente:

5:1
6:2
7:3
8:1
5:2
6:3

Essa é uma nova técnica possível no Delphi 2009. Para implementar o equivalente sem este recurso, seria necessário criar classes para o contador, construir instâncias e liberá-las. Ou seja, muito mais código e complicação.

O Craig Stuntz escreveu um exemplo muito interessante utilizando esse método pra implementar o Crivo de Eratóstenes. Ele entrou no assunto da técnica de currying, que vai ficar para o próximo artigo.

type
  TComparaString = reference to function(const S1, S2: string): Integer;

Esse tipo pode ser usado como qualquer outro tipo procedural:

procedure TLista.Ordena(Compara: TComparaString);
var
  i, j: Integer;
begin
  for i := 0 to FItems.Count - 2 do
    for j := FItems.Count - 1 downto i + 1 do
      if Compara(FItems[j], FItems[i]) < 0 then
         Troca(i, j);
end;

(Perdoem-me o Bubble Sort)

Não precisamos mais declarar um método separadamente para cada forma diferente de ordenação que for necessária. O código abaixo ordena uma lista alfabeticamente, depois de forma inversa, e finalmente de acordo com o tamanho da string:

  Lista := TLista.Create;
  try
    Lista.Adiciona('Um');
    Lista.Adiciona('Dois');
    Lista.Adiciona('Tres');
    Lista.Adiciona('Quatro');
    Lista.Adiciona('Cinco');
    Lista.Ordena(function(const S1, S2: string): Integer
                 begin
                   Result := CompareStr(S1, S2);
                 end);
    WriteLn(Lista.Texto);
    Lista.Ordena(function(const S1, S2: string): Integer
                 begin
                   Result := CompareStr(S2, S1);
                 end);
    WriteLn(Lista.Texto);
    Lista.Ordena(function(const S1, S2: string): Integer
                 begin
                   Result := Length(S1) - Length(S2);
                   if Result = 0 then
                     Result := CompareStr(S1, S2);
                 end);
    WriteLn(Lista.Texto);
  finally
    Lista.Free;
  end;

A resultado do programa é:

Cinco
Dois
Quatro
Tres
Um

Um
Tres
Quatro
Dois
Cinco

Um
Dois
Tres
Cinco
Quatro

Até aí, o recurso não é nada demais – permite economizar algumas linhas em troca de uma sintaxe discutivelmente mais confusa. Ele fica realmente interessante quando se nota que é, de fato, uma Closure, que exploraremos no próximo artigo.

Apesar de o principal novo recurso ser o total suporte de Unicode na VCL, vários outros novos recursos chamam a atenção:

• Novos controles na VCL, com destaque ao Ribbons estilo Office 2007.
• Melhorias na ImageList, incluindo suporte a PNG.
• Novos recursos de linguagem, com destaque a Generics e Anonymous Methods.
• VCL pra Web atualizada com suporte a AJAX e Silverlight.
• DataSnap 2009, que simplifica o desenvolvimento de aplicações três camadas sem uso de COM.

Vale a pena conferir a lista de componentes de terceiros que já foram atualizados para ter suporte ao Delphi 2009.

Pretendo detalhar os novos recursos em futuros artigos, portanto aguarde atualizações.

function FileAccessTime(FileName: String): TDateTime;
var
  FileHandle: Integer;
  LTime,
  FTimeA: TFileTime;
  STime: TSystemTime;
begin
  FileHandle := FileOpen(FileName,fmShareDenyNone);

  if FileHandle >= 0 then
  begin
    // Accessado
    GetFileTime(FileHandle,nil, @FTimeA, nil);
    FileClose(FileHandle);
    FileTimeToLocalFileTime(FTimeA,LTime);

    if FileTimeToSystemTime(LTime,STime) then
    begin
      Result := EncodeDate(STime.wYear,STime.wMonth,STime.wDay);
      Result := Result + EncodeTime(STime.wHour,STime.wMinute,STime.wSecond,STime.wMilliSeconds);
    end;
  end;
end;

procedure TForm1.Button1Click(Self);

begin

  ShowMessage(DateTimeToStr(FileAccessTime(‘c:\windows\areia.bmp’));

end;

Veja o vídeo aqui.

BlackfishSQL para .Net

BlackfishSQL é um novo banco de dados, para .Net, escrito 100% em código gerenciado, sem qualquer dependência de DLLs do windows. Você já pode ter ouvido falar sobre o BlackfishSQL com os nomes NDataStore e SqlDataStore.

Ele possui um código unificado com o BlackfishSQL para Java, anteriormente JDataStore, sendo completamente compatível em protocolo e formato do arquivo de banco de dados. Na prática, ao usar BlackfishSQL, você pode ter um servidor em qualquer plataforma que possua uma VM .Net ou Java. Outro ponto importante é que, apesar de BlackfishSQL para .Net ser um novo produto, é na prática versão 8.0 (seguindo o JDataStore 7), tendo um núcleo maduro, testado e já bastante utilizado.

Um dos recursos mais interessantes do BlackfishSQL é poder escrever Stored Procedures e triggers em Delphi, dentro da IDE, como você sempre fez com suas aplicações. Isso permite também depurar as stored procedures usando o debugger do Delphi, como se você estivesse depurando sua própria aplicação. Basta colocar os breakpoints e iniciar a sessão de depuração. É sem dúvida uma forma muito mais eficiente e produtiva de colocar sua regra de negócio no banco de dados do que aprender um dialeto SQL específico dos outros bancos de dados.

Existem três drivers para o BlackfishSQL. Os dois primeiros são para aplicações .Net, sendo um Local, onde o servidor roda no próprio processo e acessa o banco de dados diretamente, e um Remoto, que utiliza TCP/IP para acessar um servidor Blackfish rodando na mesma máquina ou remotamente. É interessante notar que a distribuição de uma aplicação que utiliza um driver Ado.Net Local para Blackfish é copiar e rodar – não é necessária nenhuma configuração ou instalação.

Isso torna BlackfishSQL para .Net uma escolha bastante interessante para distribuir aplicações Asp.Net – o seu servidor de hospedagem não precisa ter um servidor de banco de dados instalado, e você não precisa pagar a mais por isso – basta copiar a versão Local do driver .Net, o arquivo de banco de dados (ou deixar sua aplicação criá-lo com os novos recursos de metadados que vou mostrar mais pra frente), e sua aplicação web está pronta pra funcionar.

O Blackfish SQL Developer Guide está disponível para download no CodeCentral – 205 páginas de documentação, exemplos e bastante informação pra quem está interessado em ver o que o BlackfishSQL oferece.

DbxClient

A terceira forma de acessar um servidor BlackfishSQL é um protocolo JSON/RPC implementado por um novo driver dbExpress, chamado DbxClient, através de aplicações VCL para Win32 ou .Net. Isso permite você acessar um servidor BlackfishSQL, com suas regras de negócio escritas em Delphi, através de clientes Win32, sem precisar depender do framework .Net em cada estação.

Isso torna BlackfishSQL o nono banco de dados que dbExpress suporta diretamente nessa nova versão, para .Net e Win32. DbxClient é mais um driver escrito em Delphi e que possui todo o código fonte incluído no produto.

Por enquanto BlackfishSQL é o unico servidor que é acessível pelo protocolo DbxClient, mas aguarde notícias sobre esse assunto – na minha opinião, é um tópico bastante promissor.

DbxReadOnlyMetadata e DbxMetadata

DBX4 continua a evoluir, e desta vez é criando uma base sólida de metadados bastante ricos, completamente escrita em Delphi e com o código fonte disponível.

DbxReadOnlyMetadata é uma extensão do dbExpress permitindo ler metadados, de uma forma fácil, prática e comum, de qualquer um dos nove banco de dados suportados. Está disponível em Win32 e .Net. Além de informações sobre a conexão (se ela diferencia maisculas e minusculas, se possui schemas, quais os caracteres de inicio e fim de aspas, etc), é possível obter as seguintes informações sobre o banco:

1. Tipos de Dados
2. Catalogs
3. Schemas
4. Tabelas
5. Views
6. Synonms
7. Colunas (de tabelas, views, etc)
8. Indices
9. Campos que compõe cada indice
10. Chaves Extrangeiras
11. Campos que compõe cada chave extrangeira
12. Stored Procedures
13. Código Fonte de Stored Procedures
14. Parametros de Stored Procedures
15. Package Stored Procedures
16. Código Fonte de Package Stored Procedures
17. Parametros de Package Stored Procedures
18. Usuários
19. Roles
20. Palavras Reservadas

Os itens em negrito são comandos novos de metadatados introduzidos nessa nova versão. Todos eles podem ser acessados utilizando uma query com o CommandType Metadata, e o resultado vem como um resultado comum de query, podem ser manipulado com os componentes que já estamos acostumados, ou exibido em grid e assim por diante.

DbxMetadata é a versão de escrita de metadados. Ela gera commandos SQL de Create, Alter e Drop de acordo com coleções que são passadas, gerando tabelas, indices, e vários outros objetos. Extremamente útil para quem quer escrever um aplicação independende de banco de dados, não precisando se preocupar com o sintaxe especifica de cada banco. Criar uma tabela é mais ou menos assim:

begin
  MetaDataTable := TDBXMetaDataTable.Create;
  MetaDataTable.TableName := 'TABELA';
  MetaDataTable.AddColumn(TDBXInt32Column.Create(’Coluna1′));
  MetaDataTable.AddColumn(TDBXDecimalColumn.Create(’Coluna2′, 10, 2));
  MetaDataTable.AddColumn(TDBXUnicodeCharColumn.Create(’Coluna3′, 32));
  MetaDataProvider.CreateTable(MetaDataTable);
end;

A parte de escrita de DbxMetadata só está disponível para a plataforma .Net nessa versão, mas nada impede que seja disponibilizado para Win32 no futuro.

Certified Test Suite e Geradores de Dados

Tendo como objetivo a melhor qualidade possível dos drivers dbExpress incluidos no produto e dos de terceiros, foi criada uma suite de testes automatizados de certificação para dbExpress. Completamente escrita em Delphi e com todo o código fonte disponível. Não é só quem escreve drivers que vai se interessar em aproveitar essa suite – as extensões para o DUnit e as rotinas para trabalhar com dados podem ser usadas por qualquer um que efetue testes automatizados em aplicações de bancos de dados – ou quem está pensando em começar.

Entre o conteúdo dessa suíte, vale um destaque para o TDbxDataGenerator e classes relacionadas. Ela auxilia o controle de qualidade gerando valores para popular tabelas para testes, depois que foram criadas com as rotinas de DbxMetadata mostradas acima, de acordo com o tipo de cada coluna.

AdoDbxClient

Para quem escreve aplicações Asp.Net ou ECO, está disponível o AdoDbxClient. Ele é um provider Ado.Net 2.0 nativo que permite a utilização de drivers dbExpress diretamente em Ado.Net 2.0. Não é mais necessário utilizar classes ou componentes diferentes como era com o BDP – basta programar utilizando DbConnection, DbCommand e afims, de uma forma independente de banco de dados, podendo determinar em tempo de execução se será utilizado os providers do framework .net (SqlClient, OracleClient), os do BlackfishSQL para ADO.Net (Local e Remote), ou qualquer um dos nove drivers suportados em dbExpress.

E Tudo o Mais

Além de tudo isso existem diversas pequenas melhorias e correções de problemas, parte de um processo constante de aperfeiçoamento.

Essa versão, apesar de ser um produto .Net completando o RAD Studio com o Delphi para Win32 e C++Builder já existentes, possui recursos que podem interessar a vários tipos de desenvolvedores, inclusive os que só trabalham com código nativo. Não deixe de conferir a nova versão!