C# Academy · Lektion

Konstanten und readonly-Felder

Unterscheiden Sie const von static readonly.

Konstanten und readonly-Felder ist eine kostenlose C# Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C# Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Zwei Möglichkeiten, Werte unveränderlich zu machen

C# bietet const und readonly für Werte, die sich nicht ändern sollen. Sie sehen ähnlich aus, verhalten sich aber sehr unterschiedlich. In dieser Lektion werden sie verglichen.

using System;

class Config
{
    public const double Pi = 3.14159;
    public static readonly DateTime StartedAt = DateTime.Now;
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Pi = " + Config.Pi);
    }
}

const: Konstante zur Compilezeit

Ein const-Wert muss bei der Deklaration mit einem Literalwert versehen werden und wird zur Compilezeit fest eingebaut. Er ist implizit statisch.

using System;

class Circle
{
    public const double Pi = 3.14159;

    public static double Area(double r) => Pi * r * r;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Circle.Area(2).ToString("0.00"));
    }
}

const muss ein Literal sein

Da der Wert zur Compilezeit aufgelöst wird, kann ein const nur einen konstanten Ausdruck enthalten: Zahlen, Zeichenfolgen, boolesche Werte oder andere const-Werte.

using System;

class Limits
{
    public const int MaxRetries = 3;
    public const int Timeout = MaxRetries * 1000;   // const expression OK
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Limits.MaxRetries + ", " + Limits.Timeout);
    }
}

readonly: Konstante zur Laufzeit

Ein readonly-Feld wird entweder bei der Deklaration oder in einem Konstruktor einmal festgelegt und kann anschließend nicht mehr geändert werden. Sein Wert kann zur Laufzeit berechnet werden.

using System;

class Session
{
    public readonly string Id;

    public Session(string id)
    {
        Id = id;   // allowed: inside constructor
    }
}

class Program
{
    static void Main()
    {
        var s = new Session("abc-123");
        Console.WriteLine("Session: " + s.Id);
    }
}

readonly kann Laufzeitwerte verwenden

Anders als const kann ein readonly-Feld einen Wert enthalten, der erst beim Ausführen des Programms bekannt ist, etwa eine generierte ID oder die aktuelle Zeit.

using System;

class Order
{
    public readonly Guid OrderId;

    public Order()
    {
        OrderId = Guid.NewGuid();
    }
}

class Program
{
    static void Main()
    {
        var o = new Order();
        Console.WriteLine("Has id: " + (o.OrderId != Guid.Empty));
    }
}

static readonly

Kombinieren Sie static readonly für einen klassenweiten Wert, der einmalig zur Laufzeit berechnet wird. Dies ist der übliche Ersatz für ein const, wenn der Wert kein Literal ist.

using System;

class AppInfo
{
    public static readonly string[] Roles = { "admin", "user", "guest" };
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Roles: " + Roles());
    }

    static int Roles() => AppInfo.Roles.Length;
}

Warum const über Assembly-Grenzen hinweg riskant sein kann

Da const-Werte zur Kompilierzeit in den aufrufenden Code eingebettet werden, müssen bei einer Änderung eines öffentlichen const-Werts in einer Bibliothek alle Aufrufer neu kompiliert werden. static readonly vermeidet dieses Problem.

using System;

class Lib
{
    public const int Version = 2;              // inlined into callers
    public static readonly int Build = 100;     // read at runtime
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Lib.Version + "." + Lib.Build);
    }
}

Keines von beiden kann neu zugewiesen werden

Nach der Initialisierung können weder ein const-Feld noch ein readonly-Feld geändert werden. Ein entsprechender Versuch führt zu einem Kompilierungsfehler.

using System;

class Demo
{
    public const int A = 10;
    public readonly int B;

    public Demo() { B = 20; }
    // A = 11;  // would not compile
    // B = 21;  // would not compile outside constructor
}

class Program
{
    static void Main()
    {
        var d = new Demo();
        Console.WriteLine(Demo.A + ", " + d.B);
    }
}

Die richtige Wahl treffen

Verwenden Sie const für echte Literale, die sich nie ändern (Pi, MaxInt). Verwenden Sie readonly, wenn der Wert zur Laufzeit berechnet wird oder sich je nach Instanz unterscheiden kann.

using System;

class Physics
{
    public const double Gravity = 9.81;          // universal literal
    public readonly double Mass;                  // per object

    public Physics(double mass) { Mass = mass; }
    public double Weight() => Mass * Gravity;
}

class Program
{
    static void Main()
    {
        var p = new Physics(10);
        Console.WriteLine("Weight: " + p.Weight());
    }
}

Besonderheit bei readonly-Referenzen

readonly sperrt das Feld, nicht das Objekt, auf das es verweist. Eine readonly-Listenreferenz kann nicht neu zugewiesen werden, aber ihr Inhalt kann weiterhin geändert werden.

using System;
using System.Collections.Generic;

class Cart
{
    public readonly List<string> Items = new List<string>();
}

class Program
{
    static void Main()
    {
        var c = new Cart();
        c.Items.Add("Pen");   // allowed: mutating the object
        c.Items.Add("Book");
        Console.WriteLine("Items: " + c.Items.Count);
    }
}

Alles zusammenführen

Eine typische Klasse verwendet const für feste Literale und readonly für Werte, die zum Erstellungszeitpunkt je Instanz festgelegt werden.

using System;

class Account
{
    public const decimal MinBalance = 0m;
    public readonly string Owner;

    public Account(string owner)
    {
        Owner = owner;
    }
}

class Program
{
    static void Main()
    {
        var a = new Account("Rin");
        Console.WriteLine(a.Owner + " min=" + Account.MinBalance);
    }
}

Kurze Überprüfung

Testen Sie Ihr Verständnis von const und readonly.

Zusammenfassung

const ist ein Kompilierzeitliteral, implizit statisch und wird in die Aufrufer eingebettet. readonly wird einmal bei der Deklaration oder in einem Konstruktor festgelegt und kann Laufzeitwerte verwenden. Verwenden Sie const für echte Literale und static readonly für zur Laufzeit berechnete gemeinsame Werte. Denken Sie daran: readonly sperrt die Referenz, nicht das Objekt.

using System;

class Demo
{
    public const int Max = 100;
    public readonly int Created;
    public Demo(int c) { Created = c; }
}

class Program
{
    static void Main()
    {
        var d = new Demo(7);
        Console.WriteLine(Demo.Max + ", " + d.Created);
    }
}

Häufig gestellte Fragen

Ist die Lektion „Konstanten und readonly-Felder“ kostenlos?

Ja — der vollständige Text von „Konstanten und readonly-Felder“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C# Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C# Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Konstanten und readonly-Felder“?

Unterscheiden Sie const von static readonly. Du übst C# Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C# Academy zu starten?

Keine Vorkenntnisse erforderlich. C# Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Konstanten und readonly-Felder“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C# Academy-Lektion Code schreiben und ausführen?

Ja. Jede C# Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C# Academy