|
Usuários |
|
52 Usuários Online
|
|
[Artigos]
Modelos Genéricos de Dados x Persistencia Real no Sistema |
Publicado por rboaro : Segunda, Outubro 15, 2012 - 04:51 GMT-3 (1106 leituras)
8 Comentários Enviar para um amigo Versão para impressão
|
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 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: 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.
|
por: Razielucas (razielucas@gmail.com) : Out 29, 2012 - 10:17 (Informações sobre o membro | Enviar uma mensagem) http://http:// | Olá Jucyber.
Um editor HTML como o Dreamweaver no Delphi?
Sinceramente não conheço uma ferramenta assim.
Porém no Rad Studio XE2 os arquivos Html/Htm podem ser editados também. Não sei se atende a sua necessidade.
Pode experimentar também o Rad PHP.
Qualquer dúvida/comentários estou a disposição. | [ Comentários não permitidos para usuários anônimos. Por gentileza, registre-se ou conecte-se ao sistema
|
|
Edição 112 |
|
|
50 Programas Fontes |
|
|
Produtos |
|
|