Artigos .NET Trabalhando com atributos de classe e Reflection em C#
Atributos com reflection

Figura 1: Atributos com reflection

Para aqueles que ainda não sabem ou até sabem, mas não tinham se dado conta, começamos este artigo com exemplos de atributos de classe.

Listagem 1: Um Atributo de Classe


  [Obsolete]
  public void Metodo();
  [Serializable]
  public class Classe();
  [WebMethod]
  public static void CallAjax();

Esses nomes entre chaves acima de cada nome de método ou declaração de classe são os atributos e servem para identificar e classificar classes e seus campos segundo alguns critérios, atribuindo-lhes propriedades específicas para utilização no contexto em que são utilizadas.

Por exemplo, o atributo Obsolete permite definir uma mensagem indicando que o método está obsoleto e indicando qual utilizar em seu lugar.

Então, assumindo que possuímos o conhecimento de reflexão, vamos partir para o entendimento de como criar atributos de classes.

Listagem 2: Criando um atributo simples


  [AttributeUsage(System.AttributeTargets.Method)]
  public class MethodAttribute : Attribute
  {
      private int _Variavel1 = 0;
      public string _Variavel2 = "";
      public MethodAttribute()
      {
      }
      public MethodAttribute(string metodo, string metodo1)
      {
      }
      public void Metodo()
      {
      }
      public void Metodo(string entrada)
      {
          
    }
  }

AttributeUsage()

Responsável pelas regras de como o atributo irá funcionar. Nele indicamos que o atributo servirá de assinaturas, para classes, métodos ou algumas outras opções encontradas na listagem 3.

Listagem 3: AttributeTargets Enum


  public enum AttributeTargets
    {
        Assembly ,
        Module,
        ClasS,
        Struct,
        Enum,
        Constructor,
        Method,
        Property,
        Field,
        Event,
        Interface,
        Parameter,
        Delegate,
        ReturnValue,
        GenericParameter,
        All = GenericParameter | ReturnValue | Delegate | Parameter | Interface | Event | Field | Property | Method | Constructor | Enum | Struct | Class | Module | Assembly
    }

Cada opção dessas habilita uma possibilidade diferente para o atributo gerado. Além do AttributeTargets, existem outros dois parâmetros dentro de AttributeUsage, são eles:

  • AllowMultiple: Habilita que o atributo seja assinado mais de uma vez, dentro do escopo definido para o mesmo, o valor padrão é false.
  • Inherited: Habilita que as classes derivadas herdem o atributo também, o valor padrão é true.

Muito rápido e simples, porém terá um grande ganho de automatização quando tudo estiver programado.

A Estrutura

A estrutura proposta para esse sistema é feita em 3 camadas e uma camada de reflexão. A ideia da estrutura não está no foco.

Estrutura da aplicação

Figura 2: Estrutura da aplicação

Repare que o Reflection é o ultimo passo, pois ele será o responsável (neste caso) por efetuar o envio das informações, por isso foi dito que a estrutura não é o foco, pois a DAL e até mesmo a Bussines, neste caso, simplesmente passam as informação para a próxima camada, não realizam tarefas.

Codificando os Atributos

Os atributos é a parte mais importante daqui e fácil de desenvolver. Os atributos são basicamente classes com construtores (não obrigatoriamente) e propriedades.

Existem atributos mais complexos que realizam tarefas de classes robustas, mas na grande maioria os atributos serão simples.

Toda classe de atributo herda de Attribute e a mesma é assinada com AttributeUsage com as definições que foram explicadas acima.

Para este exemplo, foram criados dois atributos, um se chama StoredProcedureAttributes e o outro FieldsAttributes.

Listagem 4: Codificando os atributos


  public enum ProcedureTypeCommand
      {
          Insert,
          Delete,
          Update
      }
  
      [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
      public class StoredProcedureAttributes : Attribute
      {
          public string ProcedureName { get; set; }
          public ProcedureTypeCommand ProcedureType { get; set; }
          public String[] ProcParams { get; set; }
  
          public StoredProcedureAttributes(string procName, ProcedureTypeCommand procType, params String[] param)
          {
              ProcedureName = procName;
              ProcedureType = procType;
              ProcParams = param;
          }
      }
  
  [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = false)]
      public class FieldsAttributes : Attribute
      {
          public string FieldName { get; set; }
          public SqlDbType FieldType { get; set; }
          public int Length { get; set; }
          public object Value { get; set; }
  
          public FieldsAttributes()
          {
          }
          public FieldsAttributes(string FieldName, SqlDbType FieldType)
          {
              this.FieldName = FieldName;
              this.FieldType = FieldType;
          }
          public FieldsAttributes(string FieldName, SqlDbType FieldType, int Length)
          {
              this.FieldName = FieldName;
              this.FieldType = FieldType;
              this.Length = Length;
          }
      }

Simples assim foram definidos dois atributos, um é assinatura de método e o outro como assinatura de propriedades. Caso tente colocar um atributo definido para propriedade em uma classe, por exemplo, o interpretador e o compilador Visual Studio irá exibir um erro.

O atributo StoredProcedureAttributes, recebe os dados do Procedure do banco de dados, o tipo de evento DML que ele realiza e os parâmetros existentes no procedure (obrigatórios ou não).

O atributo FieldsAttributes recebe o nome do Parâmetro correspondente na entrada do procedure, o tipo de dado que a coluna foi definida no banco de dados e o length (para Varchar, Char e etc) para definir o tamanho da informação máxima que o parâmetro pode conter.

Codificando as Camadas

As camadas não tem mistério, com exceção da camada de Entity. Nesta camada estão todas as assinaturas dos atributos e é por ela que o Reflection consegue definir o tipo de ação a ser realizada e os parâmetros passados.

Entity

A Entity é um espelho da tabela de dados e possui as regras de “DML” amarradas a ela. Nesta camada estão as definições das assinaturas.

Listagem 5: Entidade e os atributos


      public class Titulos
      {
          #region Propriedades
          private int _id;
          private string _nome;
          private int _idCategoria;
          private string _categoria;
          private string _duracaoFilme;
  
          [FieldsAttributes("@ID", System.Data.SqlDbType.Int)]
          public int ID
          {
              get { return _id; }
              set { _id = value; }
          }
  
          [FieldsAttributes("@NOME", System.Data.SqlDbType.VarChar, 30)]
          public string Nome
          {
              get { return _nome; }
              set { _nome = value; }
          }
          [FieldsAttributes("@IDCATEGORIA", System.Data.SqlDbType.Int)]
          public int IdCategoria
          {
              get { return _idCategoria; }
              set { _idCategoria = value; }
          }
  
         [FieldsAttributes("@CATEGORIA", System.Data.SqlDbType.VarChar, 30)]
          public string Categoria
          {
              get { return _categoria; }
              set { _categoria = value; }
          }
          [FieldsAttributes("@DURACAOFILME", System.Data.SqlDbType.VarChar, 20)]
          public string DuracaoFilme
          {
              get { return _duracaoFilme; }
              set { _duracaoFilme = value; }
          }
          #endregion
          private TitulosBLL titulosBLL;
          public Titulos()
          {
              titulosBLL = new TitulosBLL();
          }
  
          #region Metodos Assinados
          [StoredProcedureAttributes("STP_INS_TITULOS", ProcedureTypeCommand.Insert, "@NOME", "@IDCATEGORIA", "@CATEGORIA", "@DURACAOFILME")]
          public void Salvar()
          {
              titulosBLL.Salvar(this);
          }
          [StoredProcedureAttributes("STP_DEL_TITULOS", ProcedureTypeCommand.Delete, "@ID")]
          public void Deletar()
          {
              titulosBLL.Deletar(this);
          }
          #endregion
      }

Veja como ficaram os atributos criados, em cima das propriedades apenas o atributo para propriedade e o mesmo para os métodos. Toda a declaração que seria feita na camada de DAL foi transportado para a entidade, isso é um exemplo para a funcionalidade do Reflection.

Observação: Muitos devotos por patterns e outros, com certeza não aprovariam um modelo desses.

Camada de Reflection

A última camada do escopo realiza a reflexão do objeto passado pela entidade e captura as demais informações para realizar a ação em questão (salvar, deletar).

Primeiramente vamos entender alguns métodos de reflexão dessa classe.

O GetFieldsAttributes é um método responsável por capturar do objeto passado para a camada todas as propriedades as quais levam a assinatura definida anteriormente.

Listagem 6: Código do GetFieldsAttributes


  private void GetFieldsAttributes(System.Type type, object obj)
    {
      ListFields.Clear();
      foreach (var propertyInfo in type.GetProperties())
      {
        foreach (Attributes.FieldsAttributes customAttribute in propertyInfo.GetCustomAttributes(typeof(Attributes.FieldsAttributes), false))
        {
          customAttribute.Value = propertyInfo.GetValue(obj, null);
          ListFields.Add(customAttribute);
        }
      }
    }

O GetStoredProcedureAttributes, por sua vez, é o método responsável por capturar do objeto passado para a camada todas as propriedades as quais levam a assinatura de StoredProcedureAttributes.

Listagem 7: GetStoredProcedureAttributes


  private void GetStoredProcedureAttributes(Type type)
    {
      listProcMethods.Clear();
      foreach (var methodInfo in type.GetMethods())
      {
        foreach (Attributes.StoredProcedureAttributes storedProcedureAttributes in methodInfo.GetCustomAttributes(typeof(Attributes.StoredProcedureAttributes), false))
        {
          listProcMethods.Add(storedProcedureAttributes);
        }
      }
    }

Eles juntam as informações em listas distintas definidas na classe como static. Essas listas de informações são necessárias para a filtragem dos parâmetros corretos na hora do envio das informações.

O evento Salvar recebe uma variável genérica para permitir receber qualquer objeto dentro do escopo definido.

Sem mais delongas, segue:

Listagem 8: Método Salvar


  public void Salvar<T>(T obj)
       {
           var type = typeof(T);
           GetFieldsAttributes(type, obj);
           GetStoredProcedureAttributes(type);
           Attributes.StoredProcedureAttributes StoredProcedure = listProcMethods.First(p => p.ProcedureType == Attributes.ProcedureTypeCommand.Insert);
           Salvar(StoredProcedure);
       }
       private void Salvar(Attributes.StoredProcedureAttributes storedProcSalvar)
       {
           SqlCommand cmd = new SqlCommand();
           try
           {
               cmd.CommandType = System.Data.CommandType.StoredProcedure;
               cmd.CommandText = storedProcSalvar.ProcedureName;
               cmd.Connection = GetConnection();
               cmd.Parameters.Clear();
               foreach (string procParam in storedProcSalvar.ProcParams)
               {
                   var field = ListFields.First(whe => whe.FieldName == procParam);
                   cmd.Parameters.Add(new SqlParameter(field.FieldName, field.FieldType, field.Length) { Value = field.Value });
               }
               cmd.ExecuteNonQuery();
           }
           catch (Exception ex)
           {
               throw ex;
           }
           finally
           {
               cmd.Connection.Close();
           }
       }

Observação: Na linha onde é feito o First para definir qual o procedure deve ser utilizado, poderia ser feito de outra forma, utilizando atributos específicos para cada evento.

Veja como é simples e reutilizável tudo isso. A reflection é capaz de ler os atributos da classe e os valores das propriedades definidos no objeto, minerando toda essa informação e facilitando na automatização do processo de envio.

Essa camada, nesse exemplo, entende os parâmetros que o procedure receberá e e dentro do foreach é feita a separação do que é preciso para a chamada do procedure.

Conclusão

Os atributos são uma vantagem para as aplicações, com eles conseguimos automatizar processos rotineiros, encapsular e reutilizar tarefas repetitivas para todos os desenvolvedores de uma célula. Neste caso do CRUD facilitará em constantes acessos ao banco de dados e em termos de produtividade gera um ganho, pois é possível reutilizar os atributos e a classe de reflexão em qualquer projeto.

Portanto pesquisem mais ainda sobre o assunto. Baixem o código fonte para ver o funcionamento!

Foi disponibilizado uma base dentro do App_Data, caso a mesma falhe, utilize o script de banco de dados e stored procedures disponibilizado dentro do arquivo zip, não se esqueça de editar o web.config para o endereço do banco corretamente.

Obrigado.

Referência