C# const vs. readonly: Der Unterschied für IT-Lernende

Stell dir vor, du programmierst im ersten Ausbildungsjahr als Fachinformatiker ein Bestellsystem. Du brauchst einen festen Mehrwertsteuersatz von 0,19. Logisch, dass du den nicht bei jedem Neustart neu eintippen willst. Du legst also eine feste Variable an. Doch plötzlich meldet der Compiler einen Fehler, weil du zur Laufzeit noch Änderungen vornehmen wolltest. Genau hier verrenken sich Azubis, Studenten und Berufseinsteiger regelmäßig.

In C# gibt es zwei Wege, Werte unveränderlich zu machen: `C# const readonly`. Beide sorgen dafür, dass sich ein Wert nach der Zuweisung nicht mehr ändert. Der entscheidende Unterschied liegt jedoch im Zeitpunkt, wann diese Zuweisung passiert und wie der Compiler damit umgeht.

Was ist const in C#?

`const` (Konstante) ist ein Wert, der bereits beim Kompilieren des Programms feststeht und sich danach nie wieder ändert.

Stell dir die Mehrwertsteuer vor. Dieser Prozentsatz ändert sich vielleicht alle paar Jahre durch den Gesetzgeber, aber während dein Programm läuft, bleibt er exakt gleich. Wenn du in C# ein Feld als `const` markierst, musst du es direkt bei der Deklaration initialisieren.

Der Grund dafür ist technisch: Der Compiler ersetzt jede Verwendung deiner Konstante im Code direkt durch den festen Wert. Das macht den Zugriff extrem schnell, bedeutet aber auch, dass der Wert schon vorhanden sein muss, bevor das Programm überhaupt startet.

public class Steuerberechnung
{
  // Der Wert muss direkt zugewiesen werden
  // Achtung: Umlaute im Code vermieden (ASCII-Sicherheit)
  public const double MwstSatz = 0.19;

  public double BerechneBruttopreis(double nettopreis)
  {
    // Der Compiler ersetzt "MwstSatz" hier durch 0.19
    return nettopreis + (nettopreis * MwstSatz);
  }
}

Wichtig: `const`-Felder sind implizit statisch. Das bedeutet, du kannst nicht mit `new Steuerberechnung()` darauf zugreifen, sondern nur über den Klassennamen (`Steuerberechnung.MwstSatz`). Ein zusätzliches `static` ist daher falsch und führt zu einem Fehler. Weitere Details zu den Sprachspezifikationen findest du in der offiziellen C# Dokumentation.

Was ist readonly in C#?

`readonly` erlaubt es dir, einen Wert genau einmal zur Laufzeit des Programms zuzuweisen - meistens im Konstruktor. Danach ist er für immer gesperrt.

Denk an ein Autokennzeichen. Wenn das Auto gebaut und zugelassen wird (das ist dein Konstruktor), wird das Kennzeichen fest zugewiesen. Während der Fahrt (Laufzeit des Programms) kannst du es nicht mehr ändern. Aber welches Kennzeichen genau es ist, steht erst fest, wenn das Auto tatsächlich vom Band rollt - und nicht schon auf dem Zeichenbrett des Ingenieurs (Kompilierzeit).

Das ist extrem praktisch, wenn du Werte aus einer Konfigurationsdatei, einer Datenbank oder per API laden musst. Diese Informationen stehen beim Kompilieren noch nicht fest.

using System;

public class BenutzerKonfiguration
{
  // Zur Kompilierzeit noch unbekannt
  public readonly int MaxLoginVersuche;

  // Der Konstruktor wird zur Laufzeit aufgerufen
  public BenutzerKonfiguration(int geladeneVersuche)
  {
    // Hier ist die einzige Stelle, wo wir zuweisen duerfen
    MaxLoginVersuche = geladeneVersuche;
  }

  public void NeuerVersuch()
  {
    // Das wuerde einen Compiler-Fehler werfen:
    // MaxLoginVersuche = 5;
  }
}

Was ist der Unterschied zwischen const und readonly?

Wenn du im Studium oder in der Umschulung eine Klausur schreibst, kommt genau diese Frage oft als Tabelle oder Multiple Choice vor. Hier ist die Gegenüberstellung der wichtigsten Eigenschaften, damit du den Unterschied im Blick behältst:

Die offizielle Dokumentation von Microsoft empfiehlt `readonly` für fast alle Szenarien, in denen du unsicher bist, da dieser Ansatz flexibler ist und weniger Fehler bei Bibliotheks-Updates verursacht.

Wie setzt man const und readonly in der Praxis ein?

Stell dir vor, du entwickelst ein Spiel. Es gibt fest eingebaute Spielregeln, die sich nie ändern, und Einstellungen, die beim Start geladen werden.

using System;

public class SpielEinstellungen
{
  // Konstanten fuer grundlegende Spielregeln (aendern sich nie)
  public const int MaxSpielerProLobby = 8;
  public const string SpielVersion = "1.0.4";

  // Readonly fuer Werte, die beim Start des Spiels geladen werden
  public readonly string ServerIp;
  public readonly DateTime SpielStart;

  public SpielEinstellungen(string ipAddresse)
  {
    // Werte werden zur Laufzeit festgelegt
    ServerIp = ipAddresse;
    SpielStart = DateTime.Now;
  }

  public void ZeigeInfo()
  {
    Console.WriteLine($"Version: {SpielVersion} (Kompiliert)");
    Console.WriteLine($"Server: {ServerIp} (Gestartet um {SpielStart})");
  }
}

In diesem Beispiel ist `SpielVersion` perfekt als `const` geeignet, da sie sich für diesen Build nie ändert. Die `ServerIp` hingegen ist `readonly`, da sie je nach Umgebung (Testserver oder Live-Server) unterschiedlich sein kann, sobald das Programm läuft.

Welche Fallstricke gibt es bei const und readonly?

Fehler machen wir alle. Aber bei diesen beiden Keywords passieren in der Praxis fast immer die gleichen Dinge. Hier sind die zwei häufigsten Stolpersteine.

Fehler 1: Komplexe Objekte als const deklarieren

Du möchtest ein vorgefertigtes Array oder eine Liste als Konstante anlegen.

// FALSCH: Arrays sind Referenztypen und koennen nicht const sein
public const int[] StandardWerte = { 1, 2, 3 };

Warum geht das nicht? Weil `const` verlangt, dass der Wert direkt vom Compiler in den Code geschrieben werden kann. Das geht nur bei sogenannten "primitiven" Typen (Wertetypen wie int, bool) oder Strings. Ein Array ist ein komplexes Objekt im Speicher.

Lösung: Nutze `static readonly`.

// RICHTIG: Ueber static readonly zur Laufzeit verfuegbar gemacht
public static readonly int[] StandardWerte = { 1, 2, 3 };

Fehler 2: Das "Versioning Problem" (Versions-Konflikt)

Das ist ein klassischer Fallstrich im Berufseinstieg. Du hast eine Klassenbibliothek (DLL) mit einer `const`-Variable geschrieben. Ein anderes Projekt nutzt diese DLL.

Wenn du nun den Wert der Konstanten in der Bibliothek änderst und nur die DLL austauschst (ohne das Hauptprojekt neu zu kompilieren), stürzt das Programm nicht ab. Es nutzt einfach weiter den *alten* Wert.

Warum? Weil der Compiler den alten Wert damals direkt in den Code des Hauptprojekts "eingebrannt" hat. Bei `readonly` passiert das nicht, da der Wert erst zur Laufzeit aus der DLL gelesen wird. Das macht `readonly` in großen Projekten sicherer.

Übungstipp: Finde den Fehler

Öffne deine Entwicklungsumgebung (Visual Studio, Rider oder VS Code) und schreibe eine kleine Klasse `Auto`.

1. Lege eine Konstante `MaxTachostand` vom Typ `int` an (z.B. 300).

2. Lege ein `readonly` Feld für die `Fahrgestellnummer` vom Typ `string` an.

3. Schreibe einen Konstruktor, der die `Fahrgestellnummer` entgegennimmt.

4. Versuche nun, in einer Methode `MaxTachostand` um 10 zu erhöhen und die `Fahrgestellnummer` zu ändern.

Beobachte, wo der Compiler rote Wellenlinien zieht. Dieser praktische Versuch brennt sich sofort in dein Gedächtnis ein. Du merkst schnell: Methoden können keine neuen Werte zuweisen, Konstruktoren hingegen schon - aber eben nur bei `readonly`.

FAQ: C# const readonly

Hier findest du die Antworten auf die Fragen, die uns in der IT-Nachhilfe am häufigsten gestellt werden.

Kann ich readonly im Konstruktor neu zuweisen?

Ja, das ist genau der Hauptzweck von `readonly`. Du kannst den Wert im Konstruktor genau einmal setzen oder bei der Deklaration. Danach verhindert der Compiler jede weitere Änderung. Das ist ideal für die Abhängigkeitsinjektion (Dependency Injection).

Warum schlägt der Compiler bei const DateTime fehl?

Ein `DateTime` ist in C# eine Struktur (struct) und kein simpler "Compile-time Constant"-Typ. Der C# Compiler erlaubt bei `const` nur eingebaute primitive Typen wie `int`, `double`, `bool` oder `string`. Für `DateTime` musst du zwingend `static readonly` verwenden.

Kann man const oder readonly vererben?

Da `const` implizit statisch ist, gibt es keine Vererbung im klassischen Sinne - es gehört zur Klasse, nicht zur Instanz. `readonly` kann vererbt werden, ist aber in der abgeleiteten Klasse nicht "überschreibbar", sondern einfach vorhanden (oder versteckt durch `new`), solange es nicht `private` war.

Was ist besser für Performance?

`const` ist marginal schneller, da der Wert direkt im Code steht (keine Speicherabfrage nötig). Der Unterschied ist in modernen Anwendungen jedoch kaum messbar. Die Flexibilität und Sicherheit von `readonly` überwiegen in fast allen professionellen Szenarien.

Die Unterscheidung zwischen `C# const readonly` klingt anfangs wie Haarspalterei, rettet dir aber später bei großen Softwareprojekten den Kopf. Setze `const` nur für echte, niegendnutzende Naturkonstanten oder Versionsnummern ein. Nimm `readonly` für alles, das zur Laufzeit einmal festgenagelt werden muss.

Wenn du bei C# Projekten feststeckst, Konzepte der objektorientierten Programmierung noch nicht richtig sitzen oder dich auf eine IHK-Abschlussprüfung vorbereitest, musst du das nicht allein durchziehen. Hol dir professionelle Unterstützung bei study-it.education.