Anwenden von Attributen

Verwenden Sie den folgenden Prozess, um ein Attribut auf ein Element Ihres Codes anzuwenden.

Definieren Sie ein neues Attribut, oder verwenden Sie ein vorhandenes .NET-Attribut.
Wenden Sie das Attribut auf das Codeelement an, indem Sie es unmittelbar vor dem Element platzieren.

Jede Sprache verfügt über eine eigene Attributsyntax. In C++ und C# ist das Attribut von eckigen Klammern umgeben und durch Leerraum vom Element getrennt, wobei dieser Leerraum auch einen Zeilenumbruch enthalten kann. In Visual Basic wird das Attribut von spitzen Klammern umgeben und muss sich in derselben logischen Zeile befinden; das Zeilenfortsetzungszeichen kann verwendet werden, wenn ein Zeilenumbruch gewünscht wird.
Geben Sie Positionsparameter und benannte Parameter für das Attribut an.

Positionsparameter sind erforderlich und müssen vor benannten Parametern vorliegen; sie entsprechen den Parametern eines der Konstruktoren des Attributs. Benannte Parameter sind optional und entsprechen Lese-/Schreibeigenschaften des Attributs. Geben Sie in C++ und C# für jeden optionalen Parameter an name=value , wobei name es sich um den Namen der Eigenschaft handelt. Geben Sie in Visual Basic name:=value an.

Das Attribut wird in Metadaten ausgegeben, wenn Sie Ihren Code kompilieren und für die Common Language Runtime und alle benutzerdefinierten Tools oder Anwendungen über die Laufzeitreflektionsdienste verfügbar sind.

Standardmäßig enden alle Attributnamen mit "Attribut". Für mehrere Sprachen, die auf die Laufzeit abzielen, z. B. Visual Basic und C#, müssen Sie jedoch nicht den vollständigen Namen eines Attributs angeben. Wenn Sie z. B. System.ObsoleteAttribute initialisieren möchten, müssen Sie nur als Obsolete referenzieren.

Gültige Attributargumente

Wenn Sie Argumente an ein Attribut übergeben, verwenden Sie eine der folgenden Arten von Ausdrücken:

Konstantenausdrücke (Literale, const/Const Werte und Enumerationswerte).
Typausdrücke (typeof in C#, GetType in Visual Basic).
Namensausdrücke (nameof in C#, NameOf in Visual Basic), die zur Kompilierungszeit Zeichenfolgenkonstanten erzeugen.
Arrayerstellungsausdrücke eines Attributparametertyps, die nur die vorstehenden Ausdrücke als Elementwerte verwenden.

Die folgenden Typen sind als Attributparametertypen gültig:

Einfache Typen (C#-Schlüsselwort / Visual Basic Schlüsselwort / .NET Laufzeittyp):

C#	Visual Basic	.NET Laufzeittyp
`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# wenn der Wert einer der gültigen Attributargumenttypen ist oder ein eindimensionales Array davon).
Type.
Enum-Typen, die an der Verwendungsstelle zugänglich sind.
Eindimensionale Arrays eines der vorherigen Typen.

Hinweis

Die Typen sbyte, , ushort, uint, ulong, decimalund nintnuint sind keine gültigen Attributparametertypen, obwohl sie Literalkonstanten unterstützen.

Die folgenden Beispiele zeigen gültige Attributargumente:

[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

Die folgenden Beispiele zeigen Argumente, die einen Compilerfehler verursachen:

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

Anwenden eines Attributs auf eine Methode

Das folgende Codebeispiel zeigt, wie man System.ObsoleteAttribute verwendet, um Code als obsolet zu markieren. Die Zeichenfolge "Will be removed in next version" wird an das Attribut übergeben. Dieses Attribut verursacht eine Compilerwarnung, die die übergebene Zeichenfolge anzeigt, wenn Code, den das Attribut beschreibt, aufgerufen wird.

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