Atributos (C#)

Los atributos proporcionan un método eficaz para asociar metadatos, o información declarativa, con código (ensamblados, tipos, métodos, propiedades, etc.). Después de asociar un atributo con una entidad de programa, se puede consultar el atributo en tiempo de ejecución mediante la utilización de una técnica denominada reflexión. Para obtener más información, vea Reflexión (C#).

Los atributos tienen las propiedades siguientes:

• Los atributos agregan metadatos al programa. Los metadatos son información sobre los tipos definidos en un programa. Todos los ensamblados .NET contienen un conjunto de metadatos específico que describe los tipos y miembros de tipo definidos en el ensamblado. Puede agregar atributos personalizados para especificar cualquier información adicional que sea necesaria. Para obtener más información, vea Crear atributos personalizados (C#).
• Puede aplicar uno o más atributos a todos los ensamblados, módulos o elementos de programa más pequeños como clases y propiedades.
• Los atributos pueden aceptar argumentos de la misma manera que los métodos y las propiedades.
• El programa puede examinar sus propios metadatos o los metadatos de otros programas mediante la reflexión. Para obtener más información, consulte Acceder a atributos mediante reflexión (C#).

Uso de atributos

Los atributos se pueden colocar en la mayoría de las declaraciones, aunque un determinado atributo podría restringir los tipos de declaraciones en que es válido. En C#, para especificar un atributo se coloca su nombre entre corchetes ([]) por encima de la declaración de la entidad a la que se aplica.

En este ejemplo, el atributo SerializableAttribute se usa para aplicar una característica específica a una clase:

[Serializable]
public class SampleClass
{
    // Objects of this type can be serialized.
}

Un método con el atributo DllImportAttribute se declara como en el siguiente ejemplo:

[System.Runtime.InteropServices.DllImport("user32.dll")]
extern static void SampleMethod();

En una declaración se puede colocar más de un atributo, como se muestra en el siguiente ejemplo:

using System.Runtime.InteropServices;

void MethodA([In][Out] ref double x) { }
void MethodB([Out][In] ref double x) { }
void MethodC([In, Out] ref double x) { }

Algunos atributos se pueden especificar más de una vez para una entidad determinada. Un ejemplo de este tipo de atributos multiuso es ConditionalAttribute:

[Conditional("DEBUG"), Conditional("TEST1")]
void TraceMethod()
{
    // ...
}

Parámetros de atributo

Muchos atributos tienen parámetros, que pueden ser posicionales, sin nombre o con nombre. Los parámetros posicionales deben especificarse en un orden determinado y no se pueden omitir. Los parámetros con nombre son opcionales y pueden especificarse en cualquier orden. Los parámetros posicionales se especifican en primer lugar. Por ejemplo, estos tres atributos son equivalentes:

[DllImport("user32.dll")]
[DllImport("user32.dll", SetLastError=false, ExactSpelling=false)]
[DllImport("user32.dll", ExactSpelling=false, SetLastError=false)]

El primer parámetro, el nombre del archivo DLL, es posicional y siempre va primero; los demás tienen un nombre. En este caso, ambos parámetros con nombre tienen el estado false de forma predeterminada, por lo que se pueden omitir. Los parámetros posicionales corresponden a los parámetros del constructor de atributos. Los parámetros con nombre u opcionales corresponden a propiedades o campos del atributo. Consulte la documentación del atributo individual para obtener información sobre los valores de parámetro predeterminados.

Para obtener más información sobre los tipos de parámetro admitidos, vea la sección Atributos de la Especificación del lenguaje C#

Destinos de atributo

El destino de un atributo es la entidad a la que se aplica dicho atributo. Por ejemplo, puede aplicar un atributo a una clase, un método determinado o un ensamblado completo. De forma predeterminada, el atributo se aplica al elemento que sigue. Pero puede identificar explícitamente, por ejemplo, si se aplica un atributo a un método, a su parámetro o a su valor devuelto.

Para identificar un destino de atributo de forma explícita, use la sintaxis siguiente:

[target : attribute-list]

La lista de posibles valores target se muestra en la tabla siguiente.

Debe especificar el valor de destino field para aplicar un atributo al campo de respaldo creado para una propiedad implementada automáticamente.

En el ejemplo siguiente se muestra cómo aplicar atributos a ensamblados y módulos. Para obtener más información, vea Atributos comunes (C#).

using System;
using System.Reflection;
[assembly: AssemblyTitleAttribute("Production assembly 4")]
[module: CLSCompliant(true)]

En el ejemplo siguiente, se muestra cómo aplicar atributos a métodos, parámetros de método y valores devueltos por métodos en C#.

// default: applies to method
[ValidatedContract]
int Method1() { return 0; }

// applies to method
[method: ValidatedContract]
int Method2() { return 0; }

// applies to parameter
int Method3([ValidatedContract] string contract) { return 0; }

// applies to return value
[return: ValidatedContract]
int Method4() { return 0; }

Usos comunes de los atributos

La lista siguiente incluye algunos de los usos comunes de atributos en el código:

• Marcar métodos con el atributo WebMethod en los servicios web para indicar que el método debe ser invocable a través del protocolo SOAP. Para obtener más información, vea WebMethodAttribute.
• Describir cómo serializar parámetros de método al interoperar con código nativo. Para obtener más información, vea MarshalAsAttribute.
• Describir las propiedades COM para clases, métodos e interfaces.
• Llamar al código no administrado mediante la clase DllImportAttribute.
• Describir los ensamblados en cuanto a título, versión, descripción o marca.
• Describir qué miembros de una clase serializar para la persistencia.
• Describir cómo realizar asignaciones entre los miembros de clase y los nodos XML para la serialización XML.
• Describir los requisitos de seguridad para los métodos.
• Especificar las características utilizadas para reforzar la seguridad.
• Controlar optimizaciones mediante el compilador Just-In-Time (JIT) para que el código siga siendo fácil de depurar.
• Obtener información sobre el llamador de un método.

Secciones relacionadas

Para obtener más información, consulte:

• Crear atributos personalizados (C#)
• Acceder a atributos mediante reflexión (C#)
• Procedimiento para: Crear una unión de C/C++ mediante atributos (C#)
• Atributos comunes (C#)
• Información del llamador (C#)

Vea también

• Guía de programación de C#
• Reflexión (C#)
• Atributos
• Uso de atributos en C#