C# - Atributos

Un atributo es una etiqueta declarativa que se usa para transmitir información al tiempo de ejecución sobre el comportamiento de varios elementos como clases, métodos, estructuras, enumeradores, ensamblajes, etc. en su programa. Puede agregar información declarativa a un programa utilizando un atributo. Una etiqueta declarativa se representa mediante corchetes ([ ]) colocados sobre el elemento para el que se utiliza.

Los atributos se utilizan para agregar metadatos, como instrucciones del compilador y otra información, como comentarios, descripción, métodos y clases a un programa. .Net Framework proporciona dos tipos de atributos:los predefinidos atributos y diseño personalizado atributos.

Especificar un atributo

La sintaxis para especificar un atributo es la siguiente −

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

El nombre del atributo y sus valores se especifican entre corchetes, antes del elemento al que se aplica el atributo. Los parámetros posicionales especifican la información esencial y los parámetros de nombre especifican la información opcional.

Atributos predefinidos

.Net Framework proporciona tres atributos predefinidos −

Uso de atributo
Condicional
Obsoleto

Uso de atributo

El atributo predefinido AttributeUsage describe cómo se puede utilizar una clase de atributo personalizada. Especifica los tipos de elementos a los que se puede aplicar el atributo.

La sintaxis para especificar este atributo es la siguiente −

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

donde,

El parámetro validon especifica los elementos de idioma en los que se puede colocar el atributo. Es una combinación del valor de un enumerador AttributeTargets . El valor predeterminado es AttributeTargets.All .
El parámetro permitir múltiples (opcional) proporciona valor para AllowMultiple propiedad de este atributo, un valor booleano. Si esto es cierto, el atributo es multiuso. El valor predeterminado es falso (un solo uso).
El parámetro heredado (opcional) proporciona valor para el Heredado propiedad de este atributo, un valor booleano. Si es verdadero, el atributo lo heredan las clases derivadas. El valor predeterminado es falso (no heredado).

Por ejemplo,

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

Condicional

Este atributo predefinido marca un método condicional cuya ejecución depende de un identificador de preprocesamiento específico.

Provoca la compilación condicional de llamadas a métodos, según el valor especificado, como Depurar o Seguimiento . Por ejemplo, muestra los valores de las variables mientras se depura un código.

La sintaxis para especificar este atributo es la siguiente −

[Conditional(
   conditionalSymbol
)]

Por ejemplo,

[Conditional("DEBUG")]

El siguiente ejemplo demuestra el atributo −

Demostración en 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();
   }
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado −

In Main function
In Function 1
In Function 2

Obsoleto

Este atributo predefinido marca una entidad de programa que no debe utilizarse. Le permite informar al compilador que descarte un elemento de destino en particular. Por ejemplo, cuando se usa un método nuevo en una clase y si aún desea conservar el método anterior en la clase, puede marcarlo como obsoleto mostrando un mensaje que indica que se debe usar el método nuevo, en lugar del método anterior.

La sintaxis para especificar este atributo es la siguiente −

[Obsolete (
   message
)]

[Obsolete (
   message,
   iserror
)]

donde,

El parámetro mensaje , es una cadena que describe la razón por la cual el elemento está obsoleto y qué usar en su lugar.
El parámetro es un error , es un valor booleano. Si su valor es verdadero, el compilador debe tratar el uso del elemento como un error. El valor predeterminado es falso (el compilador genera una advertencia).

El siguiente programa demuestra esto −

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();
   }
}

Cuando intenta compilar el programa, el compilador da un mensaje de error que dice −

 Don't use OldMethod, use NewMethod instead

Creación de atributos personalizados

.Net Framework permite la creación de atributos personalizados que se pueden usar para almacenar información declarativa y se pueden recuperar en tiempo de ejecución. Esta información se puede relacionar con cualquier elemento de destino según los criterios de diseño y las necesidades de la aplicación.

La creación y el uso de atributos personalizados implican cuatro pasos −

Declarar un atributo personalizado
Construcción del atributo personalizado
Aplicar el atributo personalizado en un elemento de programa de destino
Acceso a los atributos a través de la reflexión

El último paso implica escribir un programa simple para leer los metadatos y encontrar varias notaciones. Los metadatos son datos sobre datos o información utilizada para describir otros datos. Este programa debe usar reflejos para acceder a los atributos en tiempo de ejecución. Esto lo discutiremos en el próximo capítulo.

Declaración de un atributo personalizado

Un nuevo atributo personalizado debe derivarse de System.Attribute clase. Por ejemplo,

//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

En el código anterior, hemos declarado un atributo personalizado llamado DeBugInfo .

Construcción del atributo personalizado

Construyamos un atributo personalizado llamado DeBugInfo , que almacena la información obtenida al depurar cualquier programa. Deja que almacene la siguiente información −

El número de código del error
Nombre del desarrollador que identificó el error
Fecha de la última revisión del código
Un mensaje de cadena para almacenar los comentarios del desarrollador

La DeBugInfo class tiene tres propiedades privadas para almacenar las tres primeras informaciones y una propiedad pública para almacenar el mensaje. Por lo tanto, el número de error, el nombre del desarrollador y la fecha de revisión son los parámetros posicionales de la clase DeBugInfo y el mensaje es un parámetro opcional o con nombre.

Cada atributo debe tener al menos un constructor. Los parámetros posicionales deben pasarse a través del constructor. El siguiente código muestra el DeBugInfo clase −

//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;
      }
   }
}

Aplicación del atributo personalizado

El atributo se aplica colocándolo inmediatamente antes de su destino −

[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());
   }
}

En el próximo capítulo, recuperaremos información de atributos utilizando un objeto de clase Reflection.

C# - E/S de archivos C# - Reflexión

Lenguaje C