Clique para saber mais...
  Home     Download     Produtos / Cursos     Revista     Vídeo Aulas     Fórum     Contato   Clique aqui para logar | 10 de Novembro de 2026
  Login

Codinome
Senha
Salvar informações

 Esqueci minha senha
 Novo Cadastro

  Usuários
52 Usuários Online

  Revista ActiveDelphi
 Assine Já!
 Edições
 Sobre a Revista

  Conteúdo
 Apostilas
 Artigos
 Componentes
 Dicas
 News
 Programas / Exemplos
 Vídeo Aulas

  Serviços
 Active News
 Fórum
 Produtos / Cursos

  Outros
 Colunistas
 Contato
 Top 10

  Publicidade

  [Artigos]  Modelos Genéricos de Dados x Persistencia Real no Sistema
Publicado por rboaro : Segunda, Outubro 15, 2012 - 04:51 GMT-3 (1106 leituras)
Comentários 8 Comentários   Enviar esta notícia a um amigo Enviar para um amigo   Versão para Impressão Versão para impressão
Lucas Chagas Quando pensamos em modelos de dados em um sistema, nos vem logo a cabeça "posso usar o MVC, nele eu tenho DAO" pensando de maneira rápida. O que acontece quando temos uma estrutura de dados em MVC que tem a premissa de ser “Genérica”? Ou quando iremos utilizar um dicionário de dados para interação com as estruturas de nosso banco de dados e fazer de suas tabelas as nossas amadas classes de regras de negócio? Levando o tema a sério e pesquisando MUITO, conhecemos através de vários artigos na Internet os Tipos Genéricos e Listas genéricas no Delphi, a princípio o primeiro pensamento foi “maravilha, problema resolvido!”. Aí que começa a realmente ter problemas entre concepção da idéia e execução. “Como assim? Qual seria o problema se o Delphi suporta tipos e listas genéricas?!” foi essa a primeira questão levantada. Pesquisando mais um pouco, chega-se a um ponto onde mesmo criando um tipo genérico (exemplo: Tvalor<T>), as listas (Tlist, TobjectList, TidctionaryList e outros) não aceitam a seguinte sintaxe: oLista := Tlist<Tvalor<T>>.Create.
Sendo assim qual a soluçao?
Uma divisão de responsabilidades dentro da estrutura de um campo de dados, uma classe genérica que guarda o valor e o tipo, uma interface para uso em listas, definindo alguns métodos gerais e uma genérica que possui uma classe que encapsula o valor genérico e que implemente a interface de campo. Complicado não é? Nem tanto. Vamos ao código.
Classe para encapsular o valor de modo genérico:

unit Model.ValorUnit;

interface

uses
System.TypInfo;

type
TValor<T> = class
private
FValor: T;
FTipo: TTypeKind;
function GetValor: T;
procedure SetValor(const Value: T);
function GetTipo: TTypeKind;
public
procedure AfterConstruction; override;
property Valor: T read GetValor write SetValor;
property Tipo: TTypeKind read GetTipo;
end;

implementation

{ TValor<T> }

procedure TValor<T>.AfterConstruction;
var
Info: PTypeInfo;
begin
Info := System.TypeInfo(T);
try
if Info <> nil then
FTipo := Info^.Kind;
finally
Info := nil;
end;
end;

function TValor<T>.GetTipo: TTypeKind;
begin
inherited;
result := FTipo;
end;

function TValor<T>.GetValor: T;
begin
result := FValor;
end;

procedure TValor<T>.SetValor(const Value: T);
begin
FValor := Value;
end;
end.

A classe Tvalor<T> encapsula somente os dados de valoração, ou seja, guarda o dado especificado na variável Fvalor e tem seu tipo definido de acordo com TypeInfo.
Interface de campos:

unit Model.ICampoUnit;

interface

uses
System.TypInfo;

type
ICampo = Interface
// GUID
['{CB875B5A-35E6-4A2A-9688-5994B5803CE3}']
// functions
function GetNomeCampo: String; stdCall;
function GetTipo: TTypeKind; stdCall;
// procedures
procedure SetNomeCampo(const Value: String); stdCall;
// propriedades
property Tipo: TTypeKind read GetTipo;
property NomeCampo: String read GetNomeCampo write SetNomeCampo;
End;

implementation

end.

Esta Interface ira ser utilizada para as Listas genéricas. Como assim?! Isso mesmo. Como em toda a programação delphi, pode-se utilizar interfaces e criar N implementações para a mesma, legal né?
Classe genérica que implementa a interface e possui o encapsulamento de valores:

unit Model.CampoUnit;

interface

uses
Model.ICampoUnit, Model.ValorUnit, System.TypInfo;

type
TCampo<T> = class(TInterfacedObject, ICampo)
private
var
FNomeCampo: TValor<String>;
FCampo: TValor<T>;
function GetNomeCampo: string; stdcall;
function GetTipo: TTypeKind; stdcall;
procedure SetNomeCampo(const Value: string); stdcall;
function GetValor: T;
procedure SetValor(const Value: T);
public
procedure AfterConstruction; override;
procedure BeforeDestruction; override;
property Tipo: TTypeKind read GetTipo;
property NomeCampo: String read GetNomeCampo write SetNomeCampo;
property Valor: T read GetValor write SetValor;
end;

implementation

{ TCampo<T> }

procedure TCampo<T>.AfterConstruction;
begin
inherited;
FCampo := TValor<T>.create;
FNomeCampo := TValor<String>.Create;
end;

procedure TCampo<T>.BeforeDestruction;
begin
if (FCampo <> Nil) then
begin
FCampo.Destroy;
FCampo := Nil;
end;

if (FNomeCampo <> Nil) then
begin
FNomeCampo.Destroy;
FNomeCampo := Nil;
end;
end;

function TCampo<T>.GetNomeCampo: string;
begin
result := FNomeCampo.Valor
end;

function TCampo<T>.GetTipo: TTypeKind;
begin
result := FCampo.Tipo
end;

function TCampo<T>.GetValor: T;
begin
result := FCampo.Valor
end;

procedure TCampo<T>.SetNomeCampo(const Value: string);
begin
FNomeCampo.Valor := Value
end;

procedure TCampo<T>.SetValor(const Value: T);
begin
FCampo.Valor := Value
end;
end.

A classe Tcampo<T> é a classe que irá se valer da Interface Icampo e do Encapsulamento de Tvalor, sendo que o tipo repassado a Tvalor é o mesmo T da classe Tcampo. Também se pode notar que outro campo FnomeCampo existe na classe e o mesmo utiliza o encapsulamento de Tvalor, só que dessa vez repassando String.
Utilizando a UML temos uma visão melhor do relacionamento:



Show de bola, temos nossa estrutura de campos definida, mas onde eu iremos implementar a Lista de campos? Simples, em uma estrutura de tabela.

unit Model.TabelasUnit;

interface

uses
Model.CampoUnit, Model.ICampoUnit, System.Generics.Collections;

type
TTabelas = class
private
var
fCampos: TList<ICampo>;
public
procedure AfterConstruction; override;
procedure BeforeDestruction; override;
procedure AdicionaCampo(const ACampo: ICampo);
function RetornaCampo(const ANomeCampo: String): ICampo;
end;

implementation

{ TTabelas }

procedure TTabelas.AdicionaCampo(const ACampo: ICampo);
begin
fcampos.Add(aCampo)
end;

procedure TTabelas.AfterConstruction;
begin
inherited;
fCampos := TList<ICampo>.Create;
end;

procedure TTabelas.BeforeDestruction;
begin
inherited;
if (Fcampos <> Nil) then
begin
fCampos.Clear;
fCampos.Destroy;
fCampos := Nil;
end;
end;

function TTabelas.RetornaCampo(const ANomeCampo: String): ICampo;
var
oCampo: ICampo;
begin
for oCampo in fCampos do
if oCampo.NomeCampo = ANomeCampo then
begin
result := oCampo;
break;
end;
end;
end.

A classe Ttabela representa de uma maneira simplista uma tabela e seus campos, é somente um esqueleto básico. Como podemos ver, a lista de campos – Flist – utiliza a implementação de Tlist<Icampo>. O objeto Tlist<T> só recebe um único tipo, sendo que em caso de campos de tabelas podemos ter vários tipos(integer, varchar, float entre outros). Utilizando o tipo Icampo, esta restrição não ocorre, desde que seja enviado para a lista um tipo Icampo sempre. Um exemplo de como ficaria esta implementação:

procedure Tform1.Teste;
var
oCampo: ICampo;
oTabela: TTabelas;
begin
oTabela := TTabelas.Create;
try
oCampo := TCampo<String>.Create;
TCampo<String>(oCampo).NomeCampo := 'Teste';
TCampo<String>(oCampo).Valor := 'Campo genérico';

oTabela.AdicionaCampo(oCampo);
finally
oTabela.Destroy;
oTabela := Nil;
end;
end;

Na implementação acima, um objeto Icampo e um objeto Ttabela estão declarados no procedimento de forma local. Ao instanciar Ttabela, a classe já cria a lista de campos automaticamente, não havendo a necessidade de informar que a lista deve ser criada. Com o objeto Icampo, a história é um pouco diferente, mas você deve estar se perguntando “Porque?”. O objeto oCampo deve ser criado com base na interface Icampo. Verificando o exemplo vemos que foi criado um Tcampo<String>, mas como assim? Vamos re-lembrar que, Tcampo implementa Icampo, aí vem a seguinte pergunta: “Como definir o valor de oCampo, sendo que o mesmo é do tipo Icampo?”. Simples, lembrai-vos da toda poderosa RTTI do Delphi. Se olharmos atentamente o exemplo, TCampo<String>(oCampo) é um casting de Tcampo<String> para Icampo, assim podendo definir o valor do campo e o nome do campo. Se a rotina for executada em modo debug, poderá ser visto como o compilador interpreta a chamada.



Estou aberto a sugestões sobre o tema e próximos artigos sobre este tópico. Acho interessante e não vi nada desse tipo ainda na rede.

Abraços.

E-mail: razielucas@gmail.com




Comentários Comentários
   Ordem:  
Comentários pertencem aos seus respectivos autores. Não somos responsáveis pelo seus conteúdos.


por: brainlock (herminiolpaesjr@gmail.com) : Out 16, 2012 - 01:39
(Informações sobre o membro | Enviar uma mensagem)
eu já tinha lido algo sobre isso, mas não com tanta clareza e objetividade como está no seu artigo, já estou ansioso pelo próximo, irei acompanhar até o fim. Valeu pelo artigo.


por: GabrielLampa (gabriellampa@gmail.com) : Out 25, 2012 - 10:58
(Informações sobre o membro | Enviar uma mensagem) http://lampasoftware.com.br
Mas um exelente Artigo de um Excelente novo Colunista da comunidade Delphi.
Parabéns Lucas Chagas,tenho certeza que voce vai somar muito para esta comunidade.


por: Jucyber (ju_cyber@yahoo.com.br) : Out 27, 2012 - 01:20
(Informações sobre o membro | Enviar uma mensagem)
você sabe de um programa editor de html como o Dreamweaver no delphi?

se você souber, por favor, teria como enviar-me o código fonte para este e-mail: ju.cyber20@gmail.com ou ju.cyber@hotmail.com

Um abraço.
  Edição 112

Revista ActiveDelphi

  50 Programas Fontes


  Produtos

Conheça Nossos Produtos

Copyright© 2001-2016 – Active Delphi – Todos os direitos reservados