Fala galera, finalmente acho que consegui voltar a escrever meus artigos, depois de tanto tempo de estudos e muuuito trampo...hehehehe.

Pois bem, pe√ßo desculpas pelos emails n√£o respondidos e pelos artigos n√£o finalizados, pensei at√© em finaliz√°-los, mas como muita coisa mudou de l√° pra c√°, resolvi n√£o mexer com eles. Sendo assim, prefiro ‚Äúinvestir‚ÄĚ em artigos mais interessantes.

 

Bem, para voltar com força total, resolvi escrever um artigo sobre Persistência de dados via Reflection, que será dividido em 2 etapas, primeiro vamos falar um pouco sobre Attribute, ver o que é e como criá-lo, logo depois iremos ver Reflection, alguns conceitos, suas classes e utilização.

 

 

Pois bem, um dos maiores problemas, sen√£o o maior de n√≥s desenvolvedores esta relacionado com a forma na qual os bancos de dados s√£o desenvolvidos, isto √©, n√≥s programamos OO (Orientado ao Objeto) enquanto os banco de dados s√£o ER (Entidades Relacionais), sendo assim, √© um ‚Äúsaco‚ÄĚ ficarmos escrevendo StoredProcedures, Instru√ß√Ķes SQL e tal...mudou uma tabela, l√° vamos n√≥s no c√≥digo e/ou na procedure. N√£o interessa qual foi a modifica√ß√£o, temos sempre que estar atentos √†s modifica√ß√Ķes feita no banco. Com uma programa√ß√£o utilizando Reflection, Attribute e algumas outras classes, podemos desenvolver nossos projetos sem nos preocuparmos com qual banco de dados iremos trabalhar. Com esse ‚Äúbum‚ÄĚ do .Net, n√≥s programadores podemos criar muitas classes que fazem coisas que n√£o eram poss√≠veis antigamente, devido a forma na qual os dados eram gerados(compilados). Precisar√≠amos de programa√ß√£o de baixo n√≠vel para certar coisas. Mas nem tudo est√° perdido, que venha o .Net!!!

 

Let¬īs go!!!

 

Inicialmente vamos ver o que é um Atributo, ou seja Attribute, como é conhecido em .Net.

N√£o existe uma forma de ‚Äúdefinirmos‚ÄĚ um Attribute, para que voc√™ possa entender melhor o que vem a ser, √© preciso utilizar. Mas para inicio de conversa, vamos dizer que um Attribute √© uma informa√ß√£o a mais que podemos acrescentar em nossos blocos de c√≥digo dentro de uma montagem, exemplo disso, temos os m√©todo, propriedades e classes.

 

Você deve estar se perguntando, onde encontro um Attribute? Bem, basta abrirmos um arquivo chamado AssemblyInfo.cs ou .vb para vermos Attributes em ação.

 

[assembly: AssemblyTitle("Persistencia")]

[assembly: AssemblyDescription("")]

[assembly: AssemblyCopyright("Copyright ¬©  2006")]

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

 

No exemplo acima temos os Attributes do arquivo AssemblyInfo.cs de nosso futuro projeto!.

 

Ainda temos Attributes Internos, mais comumente utilizados no Framework, s√£o eles:

 

         - System.Diagnostics.ConditionalAttribute

         - System.ObsoleteAttribute

         - System.SerializableAttribute

         - System.Reflection.AssemblyDelaySignAttribute

 

Estes Attributes são pertencem ao Net Framework, a idéia deste artigo é dar um visão geral dos mesmos, mas vamos nos concentrar em como criá-los e utilizar nossos próprios Atributos. Para saber mais sobre estes Attributes, dêem uma olhada na documentação do .Net Framework.

 

Para n√£o passarmos em branco, vou deixar aqui um exemplo de Attribute:

 

System.Diagnotics.ConditionalAttribute

 

 

using System;

using System.Collections.Generic;

using System.Text;

using System.Diagnostics; //Obrigatório para utilizar Conditional

 

namespace Pessoa

{

         class Program

         {

                   static void Main( string[] args )

                   {

                            Program p = new Program( );

                            p.Display( );

                            p.DisplayDebug( );

 

                            Console.Read( );

                   }

 

                   public void Display( )

                   {

                            Console.WriteLine( "Display Normal!" );

                   }

 

                   [Conditional( "DEBUG" )] //Diz ao compilador para executar este m√©todo somente no modo DEBUG

                   public void DisplayDebug( )

                   {

                            Console.WriteLine( "Estou no Attribute Debug!" );

                   }

}

}

 

Mudando a forma de compila√ß√£o de Debug para Release, voc√™s ir√£o observar que o m√©todo public void DisplayDebug( ); n√£o ser√° executado. Esta √© uma forma muito √ļtil para testarmos nosso programas antes de o colocarmos em produ√ß√£o.

Como disse, não vou entrar em detalhes, mas para os mais curiosos, abram o arquivo *.exe gerado com o ILDASM, assim vocês poderam observar como é uma montagem.

 

Então, como vocês viram esta é uma das formas na qual podemos utilizar atributos, mas eles vão muito alem disso, atributos agregados a Reflection, podemos gerar códigos bem mais interessantes, como iremos ver a partir de agora!!!

 

Criando nosso próprio Attribute.

 

Antes de criarmos nosso Attribute personalizado, devemos ter em mente que para cri√°-los devemos seguir duas regras b√°sicas, s√£o elas:

 

         - Nossa class deve derivar de System.Attribute;

         - Os construtores s√≥ poder√£o conter tipos que possam ser resolvidos, como strings e n√ļmeros inteiros.


 

A partir da√≠ podemos criar nossos atributos, lembrando que Attributes s√£o nada menos que uma classe especial que segue os padr√Ķes acima citados.

 

Vamos l√°.

 

Para iniciarmos, iremos criar as classes, conforme código abaixo.

Para aqueles que irão copiar e colar o código, atente para os comentários entre as classes, eles não fazem parte do código!!!

 

Neste código criamos 3 classes que são: TableAttribute, ColumnAttribute e KeyAttribute.

 

TableAttribute ‚Äď respons√°vel por informar o nome de nossa Tabela no banco

ColumnAttribute ‚Äď respons√°vel pelas colunas em nosso banco.

KeyAttribute ‚Äď respons√°vel pelas chaves prim√°rias em nossas colunas.

 

using System;

using System.Collections.Generic;

using System.Text;

 

namespace Persistencia

{

 

Na classe TableAttribute, definimos seu construtor para receber apenas o nome da tabela (tableName), bem como para recuperarmo seu valor, chamamos a propriedade TableName. Veja no código abaixo:

 

         [AttributeUsage( AttributeTargets.Class, AllowMultiple = false, Inherited = false )]

         public class TableAttribute : Attribute

         {

                   private string _tableName;

 

                   public string TableName

                   {

                            get {   return _tableName; }

                   }

 

                   public TableAttribute( string tableName )

                   {

                            this._tableName = tableName;

                   }

         }

 

 

Na classe acima ColumnAttribute, definimos seu construtor para receber o nome da coluna, seu tipo e um tamanho, isto por que iremos utilizar futuramente.

 

         [AttributeUsage( AttributeTargets.Property, AllowMultiple = false, Inherited = true )]

         public class ColumnAttribute : Attribute

         {

                   private string _columnName;

                   private ColumnType _cType;

                   private int _columnSize;

 

                   public int ColumnSize

                   {

                            get {   return _columnSize; }

                            set { _columnSize = value; }

                   }

 

                   public ColumnType CType

                   {

                            get { return _cType; }

                            set { _cType = value; }

                   }

 

                   public string ColumnName

                   {

                            get { return _columnName; }

                   }

 

                   public ColumnAttribute( string columnName, ColumnType type, int size )

                   {

                            this._columnName = columnName;

                            this._cType = type;

                            this._columnSize = size;

                   }

 

         }

 

Nessa parte, criamos uma Enumeração (enum) de tipos, para serem setados no tipo da coluna ColumnType

 

         /// <summary>

         /// Tipos de campos para as colunas

         /// </summary>

         public enum ColumnType

         {

                   Int32,

                   String,

                   DateTime

         }

 

Para a classe KeyAttribute, definimos somente o nome da chave keyName

 

         [AttributeUsage(AttributeTargets.Property, AllowMultiple=false, Inherited=true)]

         public class KeyAttribute : Attribute

         {

                   private string _keyName;

 

                   public string KeyName

                   {

                            get { return _keyName; }

                            set { _keyName = value; }

                   }

 

                   public KeyAttribute( string key )

                   {

                            this._keyName = key;

                   }

         }

}

 

Observem que todas as classes (TableAttribute, ColumnAttribute e KeyAttribute) herdam de System.Attribute, pois sem essa heran√ßa n√£o conseguiremos criar nossos atributos. Para que possamos criar nossos atributos, devemos tamb√©m utilizar atributos prontos, como √© o caso de  AttributeUsage, que ir√° definir em qual parte de c√≥digo nosso atributo ser√° aceito, dentre eles temos AttributeTargets.Class, Method, Property, Enum, Event, Delegates dentre outros. Observem o c√≥digo abaixo:

 

[AttributeUsage( AttributeTargets.Class, AllowMultiple = false, Inherited = false )]

public class TableAttribute : Attribute

 

Nele definimos alguns itens a mais, como mostrado:

 

AllowMultiple ‚Äď define se o usu√°rio poder√° acrescentar mais de um atributo ao mesmo elemento.

Inherited ‚Äď define se ser√° poss√≠vel de ser herdado, ou seja, caso a class seja herdada seu atributo ir√° ser herdado tamb√©m

 

Para as classes ColumnAttribute e KeyAttribute definimos AllowMultiple com sendo false e Inherited como sendo true, assim nossos atributos Colum e Key não aceitarão outros atributos na mesma propriedade, porém eles podem ser herdados.

 

Estas classes que acabamos de criar ir√£o definir nossos atributos personalizado, onde atrav√©s deles iremos criar nossa ‚ÄúClass de Persist√™ncia‚ÄĚ via Reflection.

 

Como disse, não entrei em detalhes, pois acho que uma boa pesquisada na Internet sobre o assunto, poderá clarear mais a idéia de vocês.

 

Este artigo, foi bem simples, n√£o entramos em detalhes complexos, mas creio que deva ter dado para introduzi-los no mundo dos Attributes.

 

Para aqueles que não entenderam, peço um pouco de paciência, pois verão que é muito produtivo trabalharmos com Attribute e Reflection.

 

 

Aguardem o pr√≥ximo artigo, ele estar√° ‚Äúfelomenau‚ÄĚ, como diria um amigo meu..rsrs!!

 

Espero que tenham gostado!

Segue o c√≥digo fonte, clique aqui para baixar. 

 

 

Abraço a todos