Atributos en C#: Mejora tu código con metadatos

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

Los atributos se usan para agregar metadatos, como instrucciones al compilador y otra información: comentarios, descripciones, métodos y clases. El .Net Framework proporciona dos tipos: predefinidos y personalizados.

Especificación de un atributo

Sintaxis:

[atributo(parámetros_posicionales, parámetro_nombre = valor, ...)] elemento

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

Atributos predefinidos

.Net Framework proporciona tres atributos predefinidos:

• AttributeUsage
• Conditional
• Obsolete

AttributeUsage

Describe cómo se puede usar una clase de atributo personalizado. Especifica los tipos de elementos a los que se puede aplicar.

Sintaxis:

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

Donde:

• validon: Elementos de lenguaje donde se puede colocar el atributo. Combinación de valores del enumerador AttributeTargets. Por defecto: AttributeTargets.All.
• allowmultiple (opcional): Booleano para propiedad AllowMultiple. Si true, el atributo es de uso múltiple. Por defecto: false (un solo uso).
• inherited (opcional): Booleano para propiedad Inherited. Si true, el atributo se hereda en clases derivadas. Por defecto: false (no heredado).

Ejemplo:

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

Conditional

Marca un método condicional cuya ejecución depende de un identificador de preprocesamiento especificado. Causa compilación condicional de llamadas a métodos, según el valor especificado como Debug o Trace.

Sintaxis:

[Conditional(símbolo_condicional)]

Ejemplo:

#define DEBUG
using System;
using System.Diagnostics;

public class MiClase {
    [Conditional("DEBUG")]
    public static void Mensaje(string msg) {
        Console.WriteLine(msg);
    }
}

class Prueba {
    static void Función1() {
        MiClase.Mensaje("En Función 1.");
        Función2();
    }
    
    static void Función2() {
        MiClase.Mensaje("En Función 2.");
    }
    
    public static void Main() {
        MiClase.Mensaje("En función Main.");
        Función1();
        Console.ReadKey();
    }
}

Resultado:

En función Main
En Función 1
En Función 2

Obsolete

Marca una entidad de programa que no debería usarse. Permite informar al compilador para descartar un elemento objetivo. Por ejemplo, cuando un nuevo método se usa en una clase y quiere retener el antiguo, márquelo como obsoleto mostrando un mensaje de que se debe usar el nuevo.

Sintaxis:

[Obsolete(mensaje)]
[Obsolete(mensaje, esError)]

Donde:

• mensaje: Cadena que describe por qué el elemento es obsoleto y qué usar en su lugar.
• esError: Booleano. Si true, el compilador trata el uso como error. Por defecto: false (genera advertencia).

Ejemplo:

using System;

public class MiClase {
    [Obsolete("No use OldMethod, use NewMethod en su lugar", true)]
    static void OldMethod() {
        Console.WriteLine("Es el método antiguo");
    }
    
    static void NewMethod() {
        Console.WriteLine("Es el nuevo método");
    }
    
    public static void Main() {
        OldMethod();
    }
}

Al compilar, el compilador da error:

No use OldMethod, use NewMethod en su lugar

Creación de atributos personalizados

.Net Framework permite crear atributos personalizados para almacenar información declarativa y recuperarla en tiempo de ejecución.

Crear y usar atributos personalizados implica cuatro pasos:

1. Declarar un atributo personalizado
2. Construir el atributo personalizado
3. Aplicar el atributo en un elemento objetivo
4. Acceder a atributos a través de Reflection

El último paso implica escribir un programa para leer metadatos y encontrar notaciones. Los metadatos son datos sobre datos. Este programa debe usar reflexión para acceder a atributos en tiempo de ejecución.

Declaración de un atributo personalizado

Un nuevo atributo personalizado debe derivar de System.Attribute.

// Atributo personalizado BugFix para clase y sus miembros
[AttributeUsage(
    AttributeTargets.Class | AttributeTargets.Constructor | 
    AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Property, 
    AllowMultiple = true)]
public class DeBugInfo : System.Attribute

Construcción del atributo personalizado

Construyamos DeBugInfo para almacenar información de depuración:

• Número de código del bug
• Nombre del desarrollador que identificó el bug
• Fecha de última revisión
• Mensaje para observaciones del desarrollador

La clase tiene tres propiedades privadas para los primeros tres y una pública para el mensaje. El número de bug, nombre del desarrollador y fecha son parámetros posicionales; el mensaje es parámetro opcional/nombrado.

Cada atributo debe tener al menos un constructor. Los parámetros posicionales se pasan por el constructor.

[AttributeUsage(
    AttributeTargets.Class | AttributeTargets.Constructor | 
    AttributeTargets.Field | AttributeTargets.Method | AttributeTargets.Property, 
    AllowMultiple = true)]
public class DeBugInfo : System.Attribute {
    private int bugNo;
    private string desarrollador;
    private string últimaRevisión;
    public string mensaje;
    
    public DeBugInfo(int bg, string dev, string d) {
        this.bugNo = bg;
        this.desarrollador = dev;
        this.últimaRevisión = d;
    }
    
    public int BugNo { get { return bugNo; } }
    public string Desarrollador { get { return desarrollador; } }
    public string ÚltimaRevisión { get { return últimaRevisión; } }
    public string Mensaje { get { return mensaje; } set { mensaje = value; } }
}

Aplicación del atributo personalizado

El atributo se aplica colocándolo inmediatamente antes de su objetivo:

[DeBugInfo(45, "Zara Ali", "12/8/2012", Message = "Return type mismatch")]
[DeBugInfo(49, "Nuha Ali", "10/10/2012", Message = "Unused variable")]
class Rectángulo {
    protected double longitud;
    protected double ancho;
    
    public Rectángulo(double l, double w) {
        longitud = l; ancho = w;
    }
    
    [DeBugInfo(55, "Zara Ali", "19/10/2012", Message = "Return type mismatch")]
    public double GetÁrea() { return longitud * ancho; }
    
    [DeBugInfo(56, "Zara Ali", "19/10/2012")]
    public void Mostrar() {
        Console.WriteLine("Longitud: {0}", longitud);
        Console.WriteLine("Ancho: {0}", ancho);
        Console.WriteLine("Área: {0}", GetÁrea());
    }
}

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