C# static: statische Klassen, Methoden, Felder und Konstruktoren

static kennzeichnet einen Member, der zum Typ gehört, nicht zu einem Objekt. Ein Instanzfeld existiert einmal pro Objekt; ein statisches Feld existiert einmal, Punkt. Eine Instanzmethode läuft auf einem Objekt (order.Ship()); eine statische Methode läuft auf dem Typ (Math.Round(x)) und braucht überhaupt kein Objekt.

Statische Felder: eine Kopie, geteilt

Am klarsten zeigt ein Zähler den Unterschied. Jede Order hat ihre eigene Id, aber die Anzahl der bisher erzeugten Bestellungen muss an einem gemeinsamen Ort liegen.

using System;

class Order
{
    private static int created;   // one copy for the whole program
    public int Id { get; }        // one copy per order
    public string Customer { get; }

    public Order(string customer)
    {
        created++;
        Id = created;
        Customer = customer;
    }

    public static int Created => created;
}

class Program
{
    static void Main()
    {
        var a = new Order("Ana");
        var b = new Order("Ben");
        var c = new Order("Chen");

        Console.WriteLine($"{a.Customer} #{a.Id}, {b.Customer} #{b.Id}, {c.Customer} #{c.Id}");
        Console.WriteLine($"Orders created: {Order.Created}");
    }
}

Ausgabe:

Ana #1, Ben #2, Chen #3
Orders created: 3

Auf statische Member wird über den Typnamen zugegriffen: Order.Created, nicht a.Created. C# erlaubt es nicht, einen statischen Member über eine Instanz zu erreichen (Fehler CS0176), was an der Aufrufstelle deutlich macht, dass der Wert geteilt ist.

Statische Methoden

Eine statische Methode hat kein this. Sie arbeitet nur mit ihren Parametern und anderen statischen Membern. Das macht sie zur natürlichen Form für Hilfsmethoden, die etwas aus ihren Eingaben berechnen:

using System;

class Pricing
{
    public static decimal WithVat(decimal net, decimal rate) => Math.Round(net * (1 + rate), 2);

    public static string Format(decimal amount) => amount.ToString("0.00") + " EUR";
}

class Program
{
    static void Main()
    {
        decimal gross = Pricing.WithVat(49.90m, 0.23m);
        Console.WriteLine(Pricing.Format(gross));
        Console.WriteLine(Math.Max(3, 7)); // Math is full of static methods
    }
}

Ausgabe:

61.38 EUR
7

Main selbst ist statisch: Die Runtime ruft es auf, bevor irgendein Objekt existiert.

Der Fehler CS0120: statischer Code verwendet Instanzmember

Weil Main statisch ist, stoßen Einsteiger auf diesen Fehler, sobald sie eine zweite Methode hinzufügen:

class Program
{
    int visits;
    void Greet() { Console.WriteLine("Hello"); }

    static void Main()
    {
        Greet();    // error CS0120: An object reference is required for the non-static field, method, or property 'Program.Greet()'
        visits++;   // error CS0120: An object reference is required for the non-static field, method, or property 'Program.visits'
    }
}

Eine statische Methode hat kein Objekt, es gibt also kein visits, das sie erhöhen könnte. Zwei Lösungen, und die richtige hängt davon ab, was der Member ist:

• Der Member sind wirklich Daten pro Objekt: Erzeuge ein Objekt und verwende es. var app = new Program(); app.Greet();
• Der Member braucht keinen Objektzustand: Markiere ihn als static. static void Greet() { ... }

Alles als static zu markieren, damit der Fehler verschwindet, funktioniert in einem winzigen Programm und wird in einem echten zu globalem Zustand. Entscheide anhand der Frage, ob die Daten zu einem Objekt oder zum ganzen Programm gehören.

Die umgekehrte Richtung ist immer erlaubt: Instanzmethoden können statische Member frei aufrufen.

Statische Klassen

Eine als static deklarierte Klasse darf nur statische Member enthalten und kann nie instanziiert werden. Sie ist eine benannte Gruppe von Funktionen und Konstanten.

using System;

static class Temperature
{
    public const decimal FreezingC = 0m;

    public static decimal ToFahrenheit(decimal c) => c * 9 / 5 + 32;
    public static decimal ToCelsius(decimal f) => (f - 32) * 5 / 9;
    public static bool IsFreezing(decimal c) => c <= FreezingC;
}

class Program
{
    static void Main()
    {
        Console.WriteLine(Temperature.ToFahrenheit(25m));
        Console.WriteLine(Temperature.ToCelsius(212m));
        Console.WriteLine(Temperature.IsFreezing(-3m));
        // var t = new Temperature(); // error CS0712: Cannot create an instance of the static class 'Temperature'
    }
}

Ausgabe:

77
100
True

Der Compiler setzt den Vertrag durch: Ein Instanzmember in einer statischen Klasse ist Fehler CS0708, und new darauf ist Fehler CS0712. Math, Console, File, Path und Enumerable sind alle statische Klassen. Auch Erweiterungsmethoden müssen in einer statischen Klasse stehen.

Statische Konstruktoren und static readonly

Ein statisches Feld, dessen Wert mehr als einen Ausdruck braucht, kann in einem statischen Konstruktor gesetzt werden, den die Runtime einmal ausführt, bevor der Typ zum ersten Mal verwendet wird:

using System;
using System.Collections.Generic;

class ShippingRates
{
    public static readonly IReadOnlyDictionary<string, decimal> ByCountry;
    public static readonly DateTime LoadedOn = new DateTime(2026, 1, 1);

    static ShippingRates()
    {
        Console.WriteLine("ShippingRates initialized");
        ByCountry = new Dictionary<string, decimal> { ["PT"] = 4.90m, ["ES"] = 5.50m, ["FR"] = 6.20m };
    }
}

class Program
{
    static void Main()
    {
        Console.WriteLine("Before first use");
        Console.WriteLine(ShippingRates.ByCountry["ES"]);
        Console.WriteLine(ShippingRates.ByCountry.Count);
        Console.WriteLine(ShippingRates.LoadedOn.ToString("yyyy-MM-dd"));
    }
}

Ausgabe:

Before first use
ShippingRates initialized
5.50
3
2026-01-01

readonly bedeutet, dass das Feld nur in seinem Initialisierer oder im statischen Konstruktor zugewiesen werden kann. Danach lässt es sich nicht neu zuweisen, auch wenn das Objekt, auf das es zeigt, noch veränderlich sein könnte, deshalb wird das Dictionary als IReadOnlyDictionary bereitgestellt.

const gegenüber static readonly

Beide geben dir einen benannten Wert, den das ganze Programm teilt, und sie unterscheiden sich darin, wann der Wert feststeht:

Die Zeile zum Kopieren zählt bei Bibliotheken: Deklariert Assembly A public const int MaxItems = 50; und verwendet Assembly B das, enthält B das Literal 50. A auf 100 zu ändern bewirkt für B nichts, bis B neu kompiliert wird. Für Werte, die sich zwischen Versionen ändern könnten, nimm lieber static readonly.

using static

Eine using static-Direktive (C# 6) importiert die statischen Member eines Typs, sodass du sie ohne den Typnamen aufrufen kannst:

using System;
using static System.Math;
using static System.Console;

class Program
{
    static void Main()
    {
        double radius = 3;
        double area = PI * Pow(radius, 2);
        WriteLine($"Area: {area:F2}");
        WriteLine(Max(12, 40));
    }
}

Ausgabe:

Area: 28.27
40

Bei mathelastigem Code liest sich das gut. Anderswo nimm es sparsam: Ein nacktes WriteLine oder Parse verbirgt, von welchem Typ die Methode kommt.

Statischer Zustand und Threads

Ein statisches Feld wird von jedem Thread im Prozess geteilt. Es aus mehreren Threads gleichzeitig zu erhöhen verliert Aktualisierungen, weil created++ ein Lesen, ein Addieren und ein Schreiben ist und zwei Threads diese verschränken können. Nimm Interlocked.Increment(ref created) für Zähler oder einen Lock für alles Größere. Webanwendungen sind der übliche Ort, an dem das zubeißt: Jede Anfrage läuft auf irgendeinem Thread, ein statisches Feld mit „dem aktuellen Benutzer“ wird also von allen Benutzern geteilt.

Noch eine Feinheit: In einer generischen Klasse bekommt jeder konstruierte Typ seine eigenen statischen Felder. Cache<int>.Count und Cache<string>.Count sind zwei verschiedene Felder.

Wann static passt

Gute Einsätze:

• Reine Hilfsmethoden, die ein Ergebnis aus ihren Argumenten berechnen: Formatierung, Umwandlungen, Validierung.
• Konstanten und schreibgeschützte Nachschlagedaten, die das Programm teilt.
• Fabrikmethoden wie TimeSpan.FromMinutes(5) oder dein eigenes Temperature.FromCelsius(21).
• Erweiterungsmethoden.

Schlechte Einsätze:

• Veränderlicher globaler Zustand (der aktuelle Benutzer, ein Warenkorb, Einstellungen, die sich ändern). Er koppelt jedes Codestück, das ihn berührt, und macht Tests von den Überbleibseln anderer Tests abhängig.
• Alles, was du in Tests austauschen willst, etwa eine Uhr, eine Datenbank oder einen E-Mail-Versender. Statische Aufrufe lassen sich nicht durch eine Attrappe ersetzen; eine an den Konstruktor übergebene Instanz schon.