Applicare attributi

Usare il processo seguente per applicare un attributo a un elemento del codice.

Definire un nuovo attributo o usare un attributo .NET esistente.
Applicare l'attributo all'elemento di codice posizionandolo immediatamente prima dell'elemento .

Ogni linguaggio ha la propria sintassi degli attributi. In C++ e C#, l'attributo è racchiuso tra parentesi quadre e separato dall'elemento da uno spazio vuoto, che può includere un'interruzione di riga. In Visual Basic, l'attributo è racchiuso tra parentesi angolari e deve trovarsi nella stessa linea logica. Il carattere di continuazione della riga può essere utilizzato se si desidera un'interruzione di riga.
Specificare i parametri posizionali e i parametri denominati per l'attributo.

I parametri posizionali sono obbligatori e devono venire prima di qualsiasi parametro denominato; corrispondono ai parametri di uno dei costruttori dell'attributo. I parametri denominati sono facoltativi e corrispondono alle proprietà di lettura/scrittura dell'attributo. In C++ e C# specificare name=value per ogni parametro facoltativo, dove name è il nome della proprietà. In Visual Basic, specificare name:=value.

L'attributo viene generato nei metadati quando si compila il codice ed è disponibile per il Common Language Runtime e per qualsiasi strumento o applicazione personalizzata tramite i servizi di reflection della runtime.

Per convenzione, tutti i nomi degli attributi terminano con "Attribute". Tuttavia, diversi linguaggi destinati al runtime, ad esempio Visual Basic e C#, non richiedono di specificare il nome completo di un attributo. Ad esempio, se si vuole inizializzare System.ObsoleteAttribute, è sufficiente farvi riferimento come Obsoleto.

Argomenti di attributo validi

Quando si passano argomenti a un attributo, usare uno dei tipi di espressioni seguenti:

Espressioni costanti (valori letterali, valori const/Const e valori di enumerazione).
Espressioni di tipo (typeof in C#, GetType in Visual Basic).
Espressioni nome (nameof in C#, NameOf in Visual Basic), che producono costanti di stringa in fase di compilazione.
Espressioni di creazione di matrici di un tipo di parametro di attributo che usano solo le espressioni precedenti come valori di elemento.

I tipi seguenti sono validi come tipi di parametri di attributo:

Tipi semplici (parola chiave C# / parola chiave Visual Basic / tipo di runtime .NET):

C#	Visual Basic	tipo di runtime .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

object (in C#, quando il valore è uno dei tipi di argomento di attributo validi o una matrice unidimensionale di essi).
Type.
Tipi di enumerazione accessibili nel sito di utilizzo.
Matrici unidimensionali di uno qualsiasi dei tipi precedenti.

Annotazioni

I tipi sbyte, ushort, uintulong, decimal, nint, e nuint non sono tipi di parametri di attributo validi, anche se supportano costanti letterali.

Gli esempi seguenti mostrano argomenti di attributo validi:

[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

Negli esempi seguenti vengono illustrati gli argomenti che causano un errore del compilatore:

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

Applicare un attributo a un metodo

Nell'esempio di codice seguente viene illustrato come usare System.ObsoleteAttribute, che contrassegna il codice come obsoleto. La stringa "Will be removed in next version" viene passata all'attributo . Questo attributo genera un avviso del compilatore che visualizza la stringa passata quando viene chiamato il codice descritto dall'attributo.

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