Anwenden von Attributen

Mit dem folgenden Verfahren wenden Sie ein Attribut auf ein Codeelement an.

1. Definieren Sie ein neues Attribut, oder verwenden Sie ein vorhandenes Attribut, indem Sie den entsprechenden Namespace aus .NET Framework importieren.

2. Wenden Sie das Attribut auf das Codeelement an, indem Sie es direkt 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 einen Leerraum, der einen Zeilenumbruch umfassen kann, vom Element getrennt. In Visual Basic ist das Attribut von spitzen Klammern umgeben, und es muss sich in derselben logischen Zeile befinden. Mithilfe des Zeilenfortsetzungszeichens kann bei Bedarf ein Zeilenumbruch eingefügt werden. In J# wird das Attribut mit einer besonderen Kommentarsyntax angefügt.

3. Geben Sie positionelle Parameter und benannte Parameter für das Attribut an.

   Positionelle Parameter sind erforderlich und müssen vor benannten Parametern stehen. Sie entsprechen den Parametern eines der Attributkonstruktoren. Benannte Parameter sind optional und entsprechen Lese-/Schreibeigenschaften des Attributs. In C++, C# und J# geben Sie für jeden optionalen Parameter name=value an, wobei name der Name der Eigenschaft ist. In Visual Basic geben Sie name:=value an.

Das Attribut wird beim Kompilieren von Code in Metadaten ausgegeben und ist über die Reflexionsdienste der Laufzeit für die Common Language Runtime sowie beliebige weitere benutzerdefinierte Tools und Anwendungen verfügbar.

Attributnamen enden üblicherweise auf "Attribute". Verschiedene Sprachen, die die Laufzeit unterstützen, z. B. Visual Basic und C#, erfordern jedoch nicht die vollständige Angabe eines Attributnamens. Wenn Sie z. B. System.ObsoleteAttribute initialisieren möchten, müssen Sie lediglich mit Obsolete darauf verweisen.

Anwenden eines Attributs auf eine Methode

Im folgenden Codebeispiel wird die Deklaration von System.ObsoleteAttribute dargestellt, mit dem Code als veraltet gekennzeichnet werden kann. Die Zeichenfolge "Will be removed in next version" wird an das Attribut übergeben. Dieses Attribut löst eine Compilerwarnung aus. Wenn vom Attribut beschriebener Code aufgerufen wird, wird die übergebene Zeichenfolge angezeigt.

using System;
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
{
    static void Main()
    {
        // This generates a compile-time warning.
        int i = Example.Add(2, 2);
    }
}

using namespace System;
public ref class Example
{
public:
    // Specify attributes between square brackets in C++.
    // This attribute is applied only to the Add method.
    [Obsolete("Will be removed in next version ")]
    static int Add(int a, int b)
    {
        return (a + b);
    }
};
void main()
{
    // This generates a compile-time warning.
    int i = Example::Add(2, 2);
    return;
}

Imports System 
Public Class Example
    ' Specify attributes between angle brackets in Visual Basic,
    ' and keep them on the same logical line.
    ' This attribute is applied only to the Add method.
    <Obsolete("Will be removed in next version ")> _
    Public Shared Function Add(ByVal a As Integer, ByVal b As Integer) As Integer
        Return a + b
    End Function
End Class
Module Test
    Sub Main()
        ' This generates a compile-time warning.
        Dim i As Integer = Example.Add(2, 2)
    End Sub
End Module

import System.*;
public class Example
{
    // Specify attributes with comment syntax in J#.
    // This attribute is applied only to the Add method.
    /** @attribute 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 MyInt = Example.Add(2,2); 
    }
}

Anwenden von Attributen auf Assemblyebene

Wenn Sie ein Attribut auf Assemblyebene anwenden möchten, verwenden Sie das Schlüsselwort Assembly. Im folgenden Codebeispiel wird AssemblyNameAttribute auf Assemblyebene angewendet.

using System.Reflection;
[assembly:AssemblyName("MyAssembly")]

using namespace System::Reflection;
[assembly:AssemblyName("MyAssembly")]

Imports System.Reflection
<Assembly:AssemblyName("MyAssembly")> 

import System.Reflection.*;
/** @assembly AssemblyName("MyAssembly") */

Beim Anwenden dieses Attributs wird die Zeichenfolge "MyAssembly" im Metadatenteil der Datei im Assemblymanifest platziert. Sie können das Attribut entweder mithilfe des MSIL Disassembler-Tools (Ildasm.exe) anzeigen lassen oder ein benutzerdefiniertes Programm erstellen, um das Attribut abzurufen.

Siehe auch

Referenz

Verwenden von Attributen (C#-Programmierhandbuch)
Anfügen von Attributen

Konzepte

Abrufen von Informationen aus Attributen
Anwendung von Attributen

Weitere Ressourcen

Erweitern von Metadaten mithilfe von Attributen
Attributed Programming Concepts