Annotation (Programmierung)

Annotationen (vom Lateinischen für „Anmerkung“) sind ein Mittel zur Strukturierung von Programmquelltexten, bei der die Erzeugung von Programmtexten und mit der Programmierung verbundener Hilfsdateien teilweise automatisiert wird. Als Informationsgrundlage für die automatische Erzeugung der zusätzlichen Dateien werden Informationen aus dem Quelltext herangezogen, die man Metadaten oder Metainformationen, Anmerkungen und Kommentare oder Attribute nennt. Bei der Übersetzung vom Compiler werden die Informationen nicht beachtet.

Programmiersprachen, die diese Form der Einbindung von Metainformationen ermöglichen, sind unter anderem Java, C# und VB.NET. Mit Hilfe von Zusatzwerkzeugen lassen sich Metainformationen auch in Sprachen einbetten, wenn deren Syntax diese nicht explizit unterstützt. Die Metadaten werden dann üblicherweise in Kommentaren vor dem Compiler verborgen und mit den Zusatzwerkzeugen ausgewertet.

Attribute in C# und VB.NET

In C# und VB.NET werden Metadaten in Form von Attributen abgebildet. Attribute können für Assemblys, Klassen, Strukturen, Methoden, Parameter, Felder und Enumerationen angegeben werden. Jedes einzelne Attribut wird in eckigen (C#) beziehungsweise spitzen Klammern (VB.NET) vor dem jeweiligen Sprachelement angegeben. Attribut-Parameter werden in gleicher Weise verwendet wie Parameter von Methoden und Eigenschaften.

Das folgende Beispiel zeigt, wie die Attribute Obsolete zum Markieren von veralteten Code sowie DllImport zum Einbinden von unmanaged (nativen) Assemblys via COM-Interop verwendet werden.

// Eine Methode (hier Foo) als veraltet markieren.
// Der Parameter vom Typ System.String wird u. a. von IDEs als Hinweistext verwendet.
[Obsolete("Verwenden sie die Methode Bar.")]
public void Foo(string stringParam)
{
    //...
}

// Import der Win32 MessageBox.
// Der Konstruktor von DllImport nimmt hier ein Argument entgegen ("user32.dll"),
// die Klasse DllImport verfügt über eine Eigenschaft CharSet, der ein Wert zugewiesen wird.
[DllImport("user32.dll", CharSet = CharSet.Unicode)]
public static extern int MessageBox(IntPtr hWnd, String text, String caption, uint type);

Neben den Standard-Attributen, die das .NET-Framework bereitstellt, ist auch das Definieren eigener Attribute möglich. Hierzu muss eine eigene Klasse erstellt werden, die von System.Attribute ableitet.

Das folgende Beispiel zeigt die Definition eines einfachen Attributs Autor:

// Definieren des Attributs "Autor"
[System.AttributeUsage(System.AttributeTargets.Class |
                       System.AttributeTargets.Struct)
]
public class Autor : System.Attribute
{
    private string _vorname;
    private string _nachname;

    public Autor(string vorname, string nachname)
    {
        _vorname = vorname;
        _nachname = nachname;
    }
}

// Verwenden des Attributs "Autor"
[Autor("Max", "Mustermann")]
class BeispielKlasse
{
    //...
}

Annotationen in Java

Die Programmiersprache Java stellt mit Javadoc und den Annotationen zwei Mechanismen zum Einbinden von Metadaten zur Verfügung. Diese werden insbesondere im Jakarta-EE-Umfeld eingesetzt, um verschiedene Dateien automatisiert zu erzeugen. Dazu zählen beispielsweise SQL-Dateien, Deployment-Deskriptoren und die mit Enterprise Java Beans verbundenen Schnittstellen (Remote Interface, Home Interface …).

Javadoc

→ Hauptartikel: Javadoc

Javadoc ist ein Werkzeug zur Auswertung von Kommentaren im Quelltext, das mit Java 1.2 eingeführt wurde. Dazu werden Kommentare, die ausgewertet werden sollen mit der Zeichenkette /** eingeleitet. Innerhalb dieser Kommentare können dann spezielle Tags verwendet und diesen jeweils eine Zeichenkette als Wert zugewiesen werden.

Die Auswertung erfolgt mittels des gleichnamigen Werkzeugs Javadoc, das ursprünglich zur automatisierten Quelltext-Dokumentation entworfen wurde. Eine weitere Möglichkeit stellt das insbesondere im Jakarta-EE-Umfeld eingesetzte XDoclet dar. Das folgende Beispiel zeigt, wie man die Softwareversion mittels Javadoc angibt:

 /**
  * @version 1.5
  */
public class A {}

Annotationen (ab Java 5)

→ Hauptartikel: Annotation (Java)

Mit der Sprachversion Java 5 wurden Annotationen als ein eigenes Sprachelement geschaffen. Annotationen werden im Quelltext durch ein @-Zeichen gefolgt vom Namen der Annotation gekennzeichnet. Zusätzlich ist es auch möglich, Annotationen Parameter zu übergeben. Außerdem können den vorgegebenen Annotationen auch eigene hinzugefügt werden.

Annotationen können mittels des Annotation Processing Toolkits (APT) direkt im Quelltext oder mittels Reflexion zur Laufzeit eines Programms ausgewertet werden. Unter anderem dadurch entstehen weitere Einsatzmöglichkeiten im Vergleich zu Javadoc. So wertet beispielsweise der Compiler selbst einige Annotationen aus. Das folgende Beispiel zeigt, wie man eine Compiler-Warnung mittels der entsprechenden Annotation unterdrückt:

 public class A {
   @SuppressWarnings("unchecked")
   public void meineMethode() {}
}

Ab Java 6 ist das APT-Werkzeug bereits im Java-Compiler integriert und Teil des Standardkompilierungsprozesses. Ab Java 8 wird das APT-Werkzeug nicht mehr separat ausgeliefert, da die Annotation-Verarbeitung vollständig von der integrierten Compiler-API übernommen wird.