Atributos

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Veja neste artigo de Laércio Queiroz como usar atributos em aplicações .NET

personalizados
Trabalhando com atributos personalizados

Veremos neste artigo como desenvolver atributos personalizados no ambiente .NET e como utilizá-los em nossos aplicativos.

Metadados extensíveis

Os atributos .net são, em última análise, uma espécie de "metadados" dos elementos do nosso código (classes, métodos, propriedades e etc.). Dessa forma, os atributos são utilizados pelo ambiente .Net em tempo de execução para definir valores ou determinar o comportamento de alguns elementos.

Ex1.:

[Serializable]
public class Teste
{
  public Teste()
  {

  }
}

Observe no exemplo acima, a declaração de uma classe "Teste", marcada com o atributo Serializable. Informando que um objeto desta classe deverá ser serializado. Como foi dito anteriormente os atributos são empregados em vários elementos do nosso código. Reforçando esta idéia, observe o segundo exemplo:

Ex2.:

...
[WebMethod]
public string OlaMundo()
{
  return "Olá Mundo!";
}
...

Note que no exemplo acima o atributo "WebMethod" determina o comportamento do elemento (método OlaMundo). Neste caso, expondo-o no Web Service.

Criando atributos

Depois dos simples exemplos mostrados no tópico anterior, é notável o papel deste recurso no desenvolvimento das nossas aplicações. Sendo assim, é relevante que saibamos criar os nossos próprios atributos. Partiremos de um exemplo simples, no qual será visto os passos necessários para criar um nova marcação de atributo.

Um atributo é, técnicamente, uma classe .Net comum, que procede da classe base System.Attribute. Os atributos devem ser considerados um tipo de referência especial. Observe a declaração de uma classe-atributo:

Ex3.:

...
namespace WebMobile
{
  public class MeuAtributo: Attribute
  {
    private int _Value;
    private string _Name;
    public MeuAtributo(int Value, string Name)
    {
      _Value = Value;
      _Name = Name;
    }
   
   public ExibirValores()
   {
     Console.WriteLine("Atributo V
alue: "+Convert.ToString(_Value));
     Console.WriteLine("Atributo Name: "+Convert.ToString(_Name));
   }
 }
}

No trecho de código acima, implementamos uma classe chamada MeuAtributo - derivada da classe base Attribute, com dois elementos privados, e um construtor público utilizado no momento da definição do atributo na classe destinatária. Observe a fácil utilização do atributo em outra classe e o resultados na Figura1:

Ex4.:

...
[MeuAtributo(15,"Testando...")]
public class Testando
{
  public Testando() { }

  public string LerAtributos(object obj)
  {
    Type type = obj.GetType();

    MeuAtributo[] arrAtr = (MeuAtributo[]) type.GetCustomAttributes(typeof(MeuAtributo),false);
   
    Console.WriteLine("Lendo os atributos...");
  
    if (arrAtr.Length != 0)
    {
      foreach (MeuAtributo mat in arrAtr)
      {

        mat.ExibirValores();
      }
    }
    else
    {
      Console.WriteLine("Os atrubutos não foram definidos!")
    }
    Console.ReadLine();
  }
}

No exemplo acima, criamos uma classe chamada "Testando", assinalada com o nosso atributo "MeuAtributo". Em seguida, implementamos um método para ler e exibir os valores dos atributos personalizados. Vamos examinar agora o comportamento do nosso código. Em uma IDE for .Net de sua preferência, escreva o seguinte código (que também pode ser facilmente escrito em outra linguagem, pórem preferimos o C#):

Ex5.:

...
class Console
{
  [STAThread]
  static void Main(string[] args)
  {
     Testando t = new Testando();
     t.LerAtributos(t);
  }

}

Nota: No nosso exemplo de classe-atributo, escrevemos um método para ler os valores dos campos protegidos. Porém, esta estratégia pode ser substituída (recomendado que o faça) pelo uso de propriedades, dando mais flexibilidade, principalmente, na leitura dos dados.

Nível de ingerência de um atributo

Enquanto estamos escrevendo a nossa classe-atributo, podemos restringir a sua utilização a um elemento específico em nosso código. Por exemplo, podemos criar um atributo que "atue" em uma classe, outro específico para propriedades e assim por diante. Esta especificação é adquirida pela definição de um valor para o enum AttributeTargets do atributo AttributeUsage, declarado em nossa classe-atributo.

Ex6.:

...
[AttributeUsage(AttributeTargets.Class)]
public class MeuAtributo: Attribute
...

Com esta simples alteração em nosso código, criamos um atributo específico para classes. O que a princípio parece ser redundante - um atributo de um atributo - ajuda-nos a categorizar os nossos códigos.

Conclusão

Vimos neste artigo como escrever atributos personalizados, e como utilizá-los em nossas classes .Net. Para mais informações sobre o uso de atributos, examine o help do framework e fique ligado no Portal Web Mobile. Até logo!!

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Ficou com alguma dúvida?