C# - Atributos

Um atributo é uma tag declarativa que é usada para transmitir informações ao tempo de execução sobre os comportamentos de vários elementos como classes, métodos, estruturas, enumeradores, assemblies etc. em seu programa. Você pode adicionar informações declarativas a um programa usando um atributo. Uma tag declarativa é representada por colchetes ([ ]) colocados acima do elemento para o qual ela é usada.

Os atributos são usados para adicionar metadados, como instruções do compilador e outras informações, como comentários, descrição, métodos e classes a um programa. O .Net Framework oferece dois tipos de atributos:os pré-definidos atributos e construídos sob medida atributos.

Especificando um atributo

A sintaxe para especificar um atributo é a seguinte −

[attribute(positional_parameters, name_parameter = value, ...)]
element

O nome do atributo e seus valores são especificados entre colchetes, antes do elemento ao qual o atributo é aplicado. Os parâmetros posicionais especificam as informações essenciais e os parâmetros de nome especificam as informações opcionais.

Atributos predefinidos

O .Net Framework fornece três atributos pré-definidos −

Uso do atributo
Condicional
Obsoleto

Uso do atributo

O atributo predefinido AttributeUsage descreve como uma classe de atributo customizada pode ser usada. Especifica os tipos de itens aos quais o atributo pode ser aplicado.

A sintaxe para especificar este atributo é a seguinte −

[AttributeUsage (
   validon,
   AllowMultiple = allowmultiple,
   Inherited = inherited
)]

Onde,

O parâmetro validon especifica os elementos de linguagem nos quais o atributo pode ser colocado. É uma combinação do valor de um enumerador AttributeTargets . O valor padrão é AttributeTargets.All .
O parâmetro allowmultiple (opcional) fornece valor para o AllowMultiple propriedade deste atributo, um valor booleano. Se isso for verdade, o atributo é multiuso. O padrão é false (uso único).
O parâmetro herdado (opcional) fornece valor para Herdado propriedade deste atributo, um valor booleano. Se for verdadeiro, o atributo é herdado por classes derivadas. O valor padrão é false (não herdado).

Por exemplo,

[AttributeUsage(
   AttributeTargets.Class |
   AttributeTargets.Constructor |
   AttributeTargets.Field |
   AttributeTargets.Method |
   AttributeTargets.Property, 
   AllowMultiple = true)]

Condicional

Este atributo predefinido marca um método condicional cuja execução depende de um identificador de pré-processamento especificado.

Causa a compilação condicional de chamadas de método, dependendo do valor especificado, como Depurar ou Rastrear . Por exemplo, ele exibe os valores das variáveis durante a depuração de um código.

A sintaxe para especificar este atributo é a seguinte −

[Conditional(
   conditionalSymbol
)]

Por exemplo,

[Conditional("DEBUG")]

O exemplo a seguir demonstra o atributo −
Demonstração ao vivo

#define DEBUG
using System;
using System.Diagnostics;

public class Myclass {
   [Conditional("DEBUG")]
   
   public static void Message(string msg) {
      Console.WriteLine(msg);
   }
}
class Test {
   static void function1() {
      Myclass.Message("In Function 1.");
      function2();
   }
   static void function2() {
      Myclass.Message("In Function 2.");
   }
   public static void Main() {
      Myclass.Message("In Main function.");
      function1();
      Console.ReadKey();
   }
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

In Main function
In Function 1
In Function 2

Obsoleto

Este atributo predefinido marca uma entidade de programa que não deve ser usada. Ele permite que você informe ao compilador para descartar um determinado elemento de destino. Por exemplo, quando um novo método está sendo usado em uma classe e você ainda deseja manter o método antigo na classe, você pode marcá-lo como obsoleto exibindo uma mensagem de que o novo método deve ser usado, em vez do método antigo.

A sintaxe para especificar este atributo é a seguinte −

[Obsolete (
   message
)]

[Obsolete (
   message,
   iserror
)]

Onde,

O parâmetro mensagem , é uma string que descreve o motivo pelo qual o item está obsoleto e o que usar no lugar.
O parâmetro iserror , é um valor booleano. Se seu valor for true, o compilador deve tratar o uso do item como um erro. O valor padrão é false (o compilador gera um aviso).

O programa a seguir demonstra isso -

using System;

public class MyClass {
   [Obsolete("Don't use OldMethod, use NewMethod instead", true)]
   
   static void OldMethod() {
      Console.WriteLine("It is the old method");
   }
   static void NewMethod() {
      Console.WriteLine("It is the new method"); 
   }
   public static void Main() {
      OldMethod();
   }
}

Quando você tenta compilar o programa, o compilador fornece uma mensagem de erro informando -

 Don't use OldMethod, use NewMethod instead

Criando atributos personalizados

O .Net Framework permite a criação de atributos personalizados que podem ser usados para armazenar informações declarativas e podem ser recuperados em tempo de execução. Essas informações podem ser relacionadas a qualquer elemento de destino, dependendo dos critérios de design e da necessidade de aplicação.

Criar e usar atributos personalizados envolve quatro etapas -

Declarando um atributo personalizado
Construindo o atributo personalizado
Aplicar o atributo personalizado em um elemento de programa de destino
Acessando atributos por meio da reflexão

A última etapa envolve escrever um programa simples para ler os metadados e encontrar várias notações. Metadados são dados sobre dados ou informações usadas para descrever outros dados. Este programa deve usar reflexões para acessar atributos em tempo de execução. Isso discutiremos no próximo capítulo.

Declarando um atributo personalizado

Um novo atributo personalizado deve ser derivado do System.Attribute classe. Por exemplo,

//a custom attribute BugFix to be assigned to a class and its members
[AttributeUsage(
   AttributeTargets.Class |
   AttributeTargets.Constructor |
   AttributeTargets.Field |
   AttributeTargets.Method |
   AttributeTargets.Property,
   AllowMultiple = true)]

public class DeBugInfo : System.Attribute

No código anterior, declaramos um atributo personalizado chamado DeBugInfo .

Construindo o atributo personalizado

Vamos construir um atributo personalizado chamado DeBugInfo , que armazena as informações obtidas pela depuração de qualquer programa. Deixe-o armazenar as seguintes informações -

O número do código do bug
Nome do desenvolvedor que identificou o bug
Data da última revisão do código
Uma mensagem de string para armazenar as observações do desenvolvedor

O DeBugInfo A classe tem três propriedades privadas para armazenar as três primeiras informações e uma propriedade pública para armazenar a mensagem. Portanto, o número do bug, o nome do desenvolvedor e a data da revisão são os parâmetros posicionais da classe DeBugInfo e a mensagem é um parâmetro opcional ou nomeado.

Cada atributo deve ter pelo menos um construtor. Os parâmetros posicionais devem ser passados pelo construtor. O código a seguir mostra o DeBugInfo classe -

//a custom attribute BugFix to be assigned to a class and its members
[AttributeUsage(
   AttributeTargets.Class |
   AttributeTargets.Constructor |
   AttributeTargets.Field |
   AttributeTargets.Method |
   AttributeTargets.Property,
   AllowMultiple = true)]

public class DeBugInfo : System.Attribute {
   private int bugNo;
   private string developer;
   private string lastReview;
   public string message;
   
   public DeBugInfo(int bg, string dev, string d) {
      this.bugNo = bg;
      this.developer = dev;
      this.lastReview = d;
   }
   public int BugNo {
      get {
         return bugNo;
      }
   }
   public string Developer {
      get {
         return developer;
      }
   }
   public string LastReview {
      get {
         return lastReview;
      }
   }
   public string Message {
      get {
         return message;
      }
      set {
         message = value;
      }
   }
}

Aplicando o atributo personalizado

O atributo é aplicado colocando-o imediatamente antes de seu alvo −

[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused variable")]
class Rectangle {
   //member variables
   protected double length;
   protected double width;
   public Rectangle(double l, double w) {
      length = l;
      width = w;
   }
   [DeBugInfo(55, "Zara Ali", "19/10/2012", Message = "Return type mismatch")]
   
   public double GetArea() {
      return length * width;
   }
   [DeBugInfo(56, "Zara Ali", "19/10/2012")]
   
   public void Display() {
      Console.WriteLine("Length: {0}", length);
      Console.WriteLine("Width: {0}", width);
      Console.WriteLine("Area: {0}", GetArea());
   }
}

No próximo capítulo, recuperamos informações de atributos usando um objeto da classe Reflection.

C# - E/S de arquivo C# - Reflexão

Linguagem C