Appliquer des attributs

Utilisez le processus suivant pour appliquer un attribut à un élément de votre code.

Définissez un nouvel attribut ou utilisez un attribut .NET existant.
Appliquez l’attribut à l’élément de code en le plaçant immédiatement avant l’élément.

Chaque langage a sa propre syntaxe d’attribut. En C++ et C#, l’attribut est encadré par des crochets et séparé de l’élément par un espace blanc, ce qui peut inclure un saut de ligne. Dans Visual Basic, l’attribut est entouré de crochets et doit se trouver sur la même ligne logique ; le caractère de continuation de ligne peut être utilisé si un saut de ligne est souhaité.
Spécifiez les paramètres positionnels et les paramètres nommés pour l’attribut.

Les paramètres positionnels sont requis et doivent être fournis avant tous les paramètres nommés ; ils correspondent aux paramètres de l’un des constructeurs de l’attribut. Les paramètres nommés sont facultatifs et correspondent aux propriétés de lecture/écriture de l’attribut. Dans C++et C#, spécifiez name=value pour chaque paramètre facultatif, où name est le nom de la propriété. Dans Visual Basic, spécifiez name:=value.

L’attribut est émis dans des métadonnées lorsque vous compilez votre code et qu’il est disponible pour le Common Language Runtime et tout outil ou application personnalisé via les services de réflexion du runtime.

Par convention, tous les noms d’attributs se terminent par « Attribut ». Toutefois, plusieurs langages qui ciblent le runtime, tels que Visual Basic et C#, ne nécessitent pas que vous spécifiiez le nom complet d’un attribut. Par exemple, si vous souhaitez initialiser System.ObsoleteAttribute, vous devez uniquement la référencer comme obsolète.

Arguments d’attribut valides

Lorsque vous passez des arguments à un attribut, utilisez l’un des types d’expressions suivants :

Expressions constantes (littéraux, const/Const valeurs et valeurs enum).
Expressions de type (typeof en C#, GetType dans Visual Basic).
Expressions de nom (nameof en C#, NameOf dans Visual Basic), qui produisent des constantes de chaîne au moment de la compilation.
Expressions de création de tableau d’un type de paramètre d’attribut qui utilisent uniquement les expressions précédentes comme valeurs d’élément.

Les types suivants sont valides en tant que types de paramètres d’attribut :

Types simples (mot clé C# / mot clé Visual Basic / type d’exécution .NET) :

C#	Visual Basic	type d’exécution .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 (en C#, lorsque la valeur est l’un des types d’arguments d’attribut valides ou un tableau unidimensionnel d’entre eux).
Type.
Types d’énumération accessibles sur le site d’utilisation.
Tableaux unidimensionnels de l’un des types précédents.

Note

Les types sbyte, ushort, uint, ulong, decimal, nint et nuint ne sont pas des types de paramètres d’attribut valides, même s’ils prennent en charge les constantes littérales.

Les exemples suivants montrent des arguments d’attribut valides :

[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

Les exemples suivants montrent les arguments qui provoquent une erreur du compilateur :

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

Appliquer un attribut à une méthode

L’exemple de code suivant montre comment utiliser System.ObsoleteAttribute, qui marque le code comme obsolète. La chaîne "Will be removed in next version" est passée à l’attribut. Cet attribut provoque un avertissement du compilateur qui affiche la chaîne passée lorsque le code décrit par l’attribut est appelé.

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