C# Attributes einfach erklärt: Was sie sind & wie du sie nutzt

Du öffnest das Projekt eines Kollegen und siehst plötzlich sowas hier:

[Obsolete("Diese Methode ist veraltet. Nutze BerechnePreisNeu().")]
public decimal BerechnePreisAlt()
{
  return 0m;
}

Eckige Klammern über einer Methode - und Visual Studio streicht den Aufruf grün durch. Ob in deiner Ausbildung, im Studium oder im ersten Job: Irgendwann begegnen dir diese Klammern überall. Sie heißen C# Attributes und gehören zu den Dingen, die in vielen Kursen nur am Rande erwähnt werden. Zeit, das zu ändern.

Was sind Attributes in C#?

Attributes sind Metadaten - zusätzliche Informationen, die du an Klassen, Methoden, Properties oder Parameter hängst, ohne deren Code zu verändern.

Stell dir ein Paket vor: Der Inhalt ist dein Code. Ein Attribute ist das Etikett außen drauf. Es sagt anderen (dem Compiler, einem Framework oder deinem eigenen Code): "Achte besonders auf das hier." Das Paket selbst bleibt unverändert.

Merke: Ein Attribute verändert deinen Code nicht selbst. Es liefert nur Informationen - der Compiler, ein Framework oder dein eigener Code entscheidet, was damit passiert.

Die Syntax ist immer gleich: Der Name in eckigen Klammern, direkt über dem Element, das du beschreiben willst.

Welche vordefinierten Attributes gibt es?

C# und das .NET-Ökosystem bringen eine ganze Sammlung fertiger Attributes mit. Die wichtigsten für den Anfang:

Das bekannteste Beispiel ist `[Obsolete]`. Es zeigt jedem, der deinen Code nutzt: "Finger weg, es gibt etwas Besseres." Details dazu findest du in der API-Referenz zu ObsoleteAttribute.

public class Rechner
{
  // Markiert die Methode als veraltet - Nutzer erhalten eine Warnung
  [Obsolete("Nutze Addiere() - diese Methode wird im naechsten Release entfernt.")]
  public int AddiereAlt(int a, int b)
  {
    return a + b;
  }

  public int Addiere(int a, int b)
  {
    return a + b;
  }
}

Ruft jetzt irgendwo jemand `AddiereAlt()` auf, erscheint beim Kompilieren eine Warnung mit deinem Hinweistext. Mit `[Obsolete("...", true)]` machst du daraus sogar einen Fehler - der Code kompiliert dann gar nicht mehr.

Was ist Reflection und was hat sie mit Attributes zu tun?

Reflection ist die Fähigkeit von C#, zur Laufzeit (also während das Programm läuft) Informationen über Typen auszulesen - etwa welche Methoden eine Klasse hat und welche Attributes daran hängen.

Kernidee: Attributes lösen selbst nichts aus. Ihre Wirkung entsteht erst dadurch, dass sie jemand auswertet.

Wer liest Attributes also aus? Drei Möglichkeiten:

• Der Compiler: `[Obsolete]` erzeugt Warnungen, `[AttributeUsage]` erzeugt Fehler bei falscher Platzierung.

• Ein Framework: ASP.NET Core ruft bei `[HttpGet]` die Methode auf, wenn die passende URL angefragt wird. xUnit führt jede `[Fact]`-Methode als Test aus.

• Dein eigener Code: eigene Attributes, ausgelesen per Reflection.

Die offizielle Doku dazu findest du auf Microsoft Learn.

Wie erstellst du ein eigenes Attribute?

Zeit für die Praxis. Stell dir vor, du willst im Team dokumentieren, wer welche Methode geschrieben hat - direkt im Code, auslesbar per Reflection.

Drei Schritte:

1. Eine Klasse erstellen, die von `System.Attribute` erbt

2. Mit `[AttributeUsage]` festlegen, wo sie nutzbar ist

3. Per Reflection auslesen

using System;
using System.Reflection;

// Schritt 1: Eigenes Attribute - erbt immer von Attribute
[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class TaskInfoAttribute : Attribute
{
  public string Author { get; }
  public string Description { get; set; }

  // Konstruktor-Parameter sind "positionsbezogene" Parameter
  public TaskInfoAttribute(string author)
  {
    Author = author;
    Description = "Keine Beschreibung vorhanden";
  }
}

public class ReportService
{
  [TaskInfo("Anna", Description = "Berechnet die Monatszahlen")]
  public void CalculateMonthlyReport()
  {
    Console.WriteLine("Report wird berechnet...");
  }

  [TaskInfo("Ben")]
  public void CleanupOldData()
  {
    Console.WriteLine("Alte Daten werden geloescht...");
  }
}

class Program
{
  static void Main()
  {
    // Schritt 3: Reflection - alle Methoden der Klasse durchlaufen
    MethodInfo[] methods = typeof(ReportService).GetMethods();

    foreach (MethodInfo method in methods)
    {
      TaskInfoAttribute info = method.GetCustomAttribute<TaskInfoAttribute>();

      if (info != null)
      {
        Console.WriteLine($"{method.Name}: Autor={info.Author}, Info={info.Description}");
      }
    }
  }
}

Die Ausgabe:

CalculateMonthlyReport: Autor=Anna, Info=Berechnet die Monatszahlen
CleanupOldData: Autor=Ben, Info=Keine Beschreibung vorhanden

Zwei Details fallen auf:

• Die Klasse heißt `TaskInfoAttribute`, benutzt wird sie aber als `[TaskInfo]`. C# erlaubt dir, das Suffix "Attribute" im Namen wegzulassen. Beide Schreibweisen funktionieren.

• `"Anna"` ist ein positionsbezogener Parameter (landet im Konstruktor), `Description = "..."` ist ein benannter Parameter (landet in einer Property oder einem Feld).

Details dazu liefert die API-Referenz zum AttributeUsageAttribute auf Microsoft Learn.

Häufige Fehler bei C# Attributes

Fehler 1: Erwarten, dass ein Attribute "Magie" auslöst

Der klassische Anfängerfehler: Ein Attribute angebracht und gewartet, dass etwas passiert. Tut es nicht. `[Obsolete]` wirkt nur, weil der Compiler es auswertet - dein eigenes `[TaskInfo]` wirkt nur, weil dein Reflection-Code es liest. Ohne Leser ist ein Attribute nur ein Zettel, den niemand ansieht.

Fehler 2: Attribute am falschen Element anbringen

// Falsch: TaskInfo ist nur fuer Methoden freigegeben
[TaskInfo("Anna")]
public class ReportService  // Compiler-Fehler CS0592
{
}

`[AttributeUsage(AttributeTargets.Method)]` schränkt ein, wo das Attribute erlaubt ist. Verstoßest du dagegen, meldet der Compiler Fehler CS0592. Das ist kein Bug, sondern ein Sicherheitsnetz - genau wie Zugriffsmodifikatoren, die regeln, wer auf Code zugreifen darf.

Fehler 3: Variablen statt Konstanten übergeben

Attribute-Parameter müssen zum Compile-Zeitpunkt bekannt sein. Variablen oder berechnete Werte gehen nicht:

// Falsch: Variablen oder Methodenaufrufe gehen nicht
[TaskInfo(autorName)]

// Richtig: Literale oder const-Konstanten
[TaskInfo("Anna")]

Warum? Weil die Attribute-Daten bereits in der kompilierten Assembly (der .dll oder .exe) landen - und die existiert erst nach dem Kompilieren.

Übungstipp: Attribute im eigenen Projekt testen

Nimm ein altes Übungprojekt - etwa deinen Taschenrechner aus dem OOP-Grundlagen-Thema - und markiere zwei bis drei Methoden mit `[Obsolete("...")]`. Ruf sie danach bewusst auf und beobachte die Warnungen. Danach baust du das `[TaskInfo]`-Attribute nach und ergänzt eine Property `Date`. Ziel: Nach 30 Minuten gibt dein Programm eine komplette Methoden-Übersicht per Reflection aus. So verstehst du den Mechanismus besser als durch jedes Tutorial.

FAQ: Häufige Fragen zu C# Attributes

Was sind Attributes in C#?

Attributes sind Metadaten in eckigen Klammern, die du an Klassen, Methoden, Properties oder Parameter hängst. Sie liefern Zusatzinformationen für den Compiler, Frameworks oder deinen eigenen Code - verändern das Verhalten des Elements aber nicht selbst.

Was macht [Obsolete] in C#?

`[Obsolete]` markiert Code als veraltet. Bei Nutzung erscheint eine Compiler-Warnung mit optionalem Hinweistext. Mit `[Obsolete("...", true)]` wird die Nutzung zum Fehler und der Code kompiliert nicht mehr.

Wie erstellst du ein eigenes Attribute in C#?

Du erstellst eine Klasse, die von `System.Attribute` erbt, versiehst sie optional mit `[AttributeUsage]` und definierst Konstruktor-Parameter und Properties. Auslesen kannst du sie zur Laufzeit per Reflection mit `GetCustomAttribute<T>()`.

Warum kann man das Suffix "Attribute" weglassen?

C# erlaubt beide Schreibweisen: `[TaskInfo]` und `[TaskInfoAttribute]` verweisen auf dieselbe Klasse `TaskInfoAttribute`. Die Kurzform ist die gängige Konvention.

Wo werden Attributes typischerweise eingesetzt?

In ASP.NET Core (Routing mit `[HttpGet]`), bei Unit-Tests (`[Fact]`, `[TestMethod]`), bei Datenvalidierung (`[Required]`, `[MaxLength]`) und in der Serialisierung. Wenn du später mit Web-APIs oder Tests arbeitest, kommst du an ihnen nicht vorbei.

Fazit

C# Attributes sind ein einfaches Konzept mit großer Wirkung: Etiketten, die Informationen an deinen Code hängen. Die meisten liest der Compiler oder ein Framework für dich aus - bei eigenen Attributes übernimmst du das per Reflection. Verstehst du das Prinzip einmal, verstehst du auch, warum in ASP.NET-Core-Projekten plötzlich überall eckige Klammern stehen.

Übrigens: Attributes sind auch ein beliebtes Thema in Prüfungen und Vorstellungsgesprächen für Fachinformatiker. Wenn du bei C# noch Lücken hast - etwa bei Generics oder Exception Handling - hilft dir individuelle Nachhilfe weiter. Schau bei study-it.education vorbei und bring dein C# auf das nächste Level.