Aplicación de atributos

Use el siguiente proceso para aplicar un atributo a un elemento del código.

1. Defina un nuevo atributo o use un atributo .NET existente.

2. Aplique el atributo al elemento de código colocándolo inmediatamente antes del elemento .

   Cada lenguaje tiene su propia sintaxis de atributo. En C++ y C#, el atributo está rodeado de corchetes y separado del elemento por un espacio en blanco, que puede incluir un salto de línea. En Visual Basic, el atributo está rodeado por paréntesis angulares y debe estar en la misma línea lógica; el carácter de continuación de línea se puede usar si se desea un salto de línea.

3. Especifique parámetros posicionales y parámetros con nombre para el atributo .

   Se requieren parámetros posicionales y deben aparecer antes de cualquier parámetro con nombre; corresponden a los parámetros de uno de los constructores del atributo. Los parámetros con nombre son opcionales y corresponden a las propiedades de lectura y escritura del atributo. En C++, y C#, especifique para cada parámetro opcional, donde es el nombre de la propiedad. En Visual Basic, especifique name:=value.

El atributo se emite en metadatos al compilar el código y está disponible para Common Language Runtime y cualquier herramienta o aplicación personalizada a través de los servicios de reflexión en tiempo de ejecución.

Por convención, todos los nombres de atributo terminan con "Attribute". Sin embargo, varios lenguajes que tienen como destino el entorno de ejecución, como Visual Basic y C#, no requieren que especifique el nombre completo de un atributo. Por ejemplo, si desea inicializar , solo debe hacer referencia a él como Obsoleto.

Argumentos de atributo válidos

Al pasar argumentos a un atributo, use uno de los siguientes tipos de expresiones:

• Expresiones constantes (literales, valores y valores de enumeración).
• Expresiones de tipo (typeof en C#, GetType en Visual Basic).
• Expresiones de nombre (nameof en C#, NameOf en Visual Basic), que generan constantes de cadena en tiempo de compilación.
• Expresiones de creación de matrices de un tipo de parámetro de atributo que usan solo las expresiones anteriores como valores de elemento.

Los siguientes tipos son válidos como tipos de parámetros de atributo:

• Tipos simples (palabra clave de C#/ palabra clave Visual Basic o tipo de tiempo de ejecución de .NET):

  C#	Visual Basic	tipo de tiempo de ejecución de .NET
  bool	Boolean	Boolean
  byte	Byte	Byte
  char	Char	Char
  double	Double	Double
  float	Single	Single
  int	Integer	Int32
  long	Long	Int64
  short	Short	Int16
  string	String	String

• (en C#, cuando el valor es uno de los tipos de argumentos de atributo válidos o una matriz unidimensional de ellos).

• .

• Tipos de enumeración a los que se puede acceder en el sitio de uso.

• Matrices unidimensionales de cualquiera de los tipos anteriores.

En los ejemplos siguientes se muestran argumentos de atributo válidos:

[MyAttr(true)]                            // bool literal
[MyAttr(42)]                              // int literal
[MyAttr("hello")]                         // string literal
[MyAttr(MyEnum.Value)]                    // enum value
[MyAttr(typeof(string))]                  // typeof expression
[MyAttr(nameof(MyClass))]                 // nameof expression (string constant)
[MyAttr(new int[] { 1, 2, 3 })]          // array of constants
[MyAttr(new string[] { "a", "b" })]      // array of strings

<MyAttr(True)>                            ' Boolean literal
<MyAttr(42)>                              ' Integer literal
<MyAttr("hello")>                         ' String literal
<MyAttr(MyEnum.Value)>                    ' Enum value
<MyAttr(GetType(String))>                 ' GetType expression
<MyAttr(NameOf(MyClass))>                 ' NameOf expression (string constant)
<MyAttr(New Integer() {1, 2, 3})>         ' Array of constants

En los ejemplos siguientes se muestran argumentos que provocan un error del compilador:

string value = "test";
[MyAttr(value)]        // Error CS0182: not a constant expression
[MyAttr(GetValue())]   // Error CS0182: method calls aren't allowed

Aplicar un atributo a un método

En el ejemplo de código siguiente se muestra cómo usar , que marca el código como obsoleto. La cadena se pasa al atributo . Este atributo produce una advertencia del compilador que muestra la cadena pasada cuando se llama al código que describe el atributo.

public class Example
{
    // Specify attributes between square brackets in C#.
    // This attribute is applied only to the Add method.
    [Obsolete("Will be removed in next version.")]
    public static int Add(int a, int b)
    {
        return (a + b);
    }
}

class Test
{
    public static void Main()
    {
        // This generates a compile-time warning.
        int i = Example.Add(2, 2);
    }
}

Public Class Example
    ' Specify attributes between square brackets in C#.
    ' This attribute is applied only to the Add method.
    <Obsolete("Will be removed in next version.")>
    Public Shared Function Add(a As Integer, b As Integer) As Integer
        Return a + b
    End Function
End Class

Class Test
    Public Shared Sub Main()
        ' This generates a compile-time warning.
        Dim i As Integer = Example.Add(2, 2)
    End Sub
End Class

Aplicar atributos en el nivel de ensamblado

Si desea aplicar un atributo en el nivel de ensamblado, use la palabra clave assembly (Assembly en Visual Basic). El código siguiente muestra el aplicado en el nivel de ensamblado.

using System.Reflection;
[assembly:AssemblyTitle("My Assembly")]

Imports System.Reflection
<Assembly: AssemblyTitle("My Assembly")>

Cuando se aplica este atributo, la cadena se coloca en el manifiesto del ensamblado en la parte de metadatos del archivo. Puede ver el atributo mediante el desensamblador de IL (Ildasm.exe) o mediante la creación de un programa personalizado para recuperar el atributo.

Consulte también

• Atributos
• Recuperar información almacenada en atributos
• Conceptos
• Atributos (C#)
• Vista General de Attributes (Visual Basic)