Freigeben über

Statische Konstruktoren (C#-Programmierhandbuch)

  • Artikel

Ein statischer Konstruktor wird verwendet, um static-Daten zu initialisieren oder um eine bestimmte Aktion auszuführen, die nur einmal ausgeführt werden muss. Er wird automatisch aufgerufen, bevor die erste Instanz erstellt oder auf irgendwelche statischen Member verwiesen wird. Ein statischer Konstruktor wird höchstens einmal aufgerufen.

class SimpleClass
{
    // Static variable that must be initialized at run time.
    static readonly long baseline;

    // Static constructor is called at most one time, before any
    // instance constructor is invoked or member is accessed.
    static SimpleClass()
    {
        baseline = DateTime.Now.Ticks;
    }
}

Es gibt mehrere Aktionen, die Teil der statischen Initialisierung sind. Diese Aktionen werden in der folgenden Reihenfolge ausgeführt:

  1. Statische Felder sind auf 0 (null) festgelegt. Die Laufzeit führt diese Initialisierung in der Regel aus.
  2. Initialisierer für statische Felder werden ausgeführt. Die Initialisierer für statische Felder im am stärksten abgeleiteten Typ werden ausgeführt.
  3. Statische Felder mit Basistypen werden ausgeführt. Initialisierer für statische Felder, beginnend mit dem direkten Basistyp über sämtliche Basistypen bis System.Object.
  4. Ein statischer Konstruktor wird ausgeführt. Alle statischen Konstruktoren, von der ultimativen Basisklasse von Object.Object über jede Basisklasse über den Typlauf. Die Reihenfolge der Ausführung statischer Konstruktoren wird nicht angegeben. Alle statischen Konstruktoren in der Hierarchie werden jedoch ausgeführt, bevor Instanzen erstellt werden.

Wichtig

Es gibt eine wichtige Ausnahme für die Regel, die ein statischer Konstruktor ausgeführt wird, bevor eine Instanz erstellt wird. Wenn ein statischer Feldinitialisierer eine Instanz des Typs erstellt, wird dieser Initialisierer (einschließlich eines Aufrufs eines Instanzkonstruktors) ausgeführt, bevor der statische Konstruktor ausgeführt wird. Dies ist am häufigsten im Singleton-Muster, wie im folgenden Beispiel gezeigt:

public class Singleton
{
    // Static field initializer calls instance constructor.
    private static Singleton instance = new Singleton();

    private Singleton()
    { 
        Console.WriteLine("Executes before static constructor.");
    }

    static Singleton()
    { 
        Console.WriteLine("Executes after instance constructor.");
    }

    public static Singleton Instance => instance;
}

Ein Modulinitialisierer kann eine Alternative zu einem statischen Konstruktor sein. Weitere Informationen finden Sie in der Spezifikation für Modulinitialisierer.

Hinweise

Statische Konstruktoren verfügen über folgende Eigenschaften:

  • Ein statischer Konstruktor akzeptiert keine Zugriffsmodifizierer oder Parameter.
  • Eine Klasse oder Struktur kann nur einen statischen Konstruktor besitzen.
  • Statische Konstruktoren können nicht vererbt oder überladen werden.
  • Ein statischer Konstruktor kann nicht direkt aufgerufen werden und ist nur für den Aufruf durch die Common Language Runtime (CLR) gedacht. Er wird automatisch aufgerufen.
  • Der Benutzer hat keine Kontrolle, wenn der statische Konstruktor im Programm ausgeführt wird.
  • Ein statischer Konstruktor wird automatisch aufgerufen. Er initialisiert die Klasse, bevor die erste Instanz erstellt oder auf statischen Member in dieser Klasse (nicht den zugehörigen Basisklassen) verwiesen wird. Ein statischer Konstruktor wird vor einem Instanzkonstruktor ausgeführt. Wenn Variableninitialisierer für statische Felder in der Klasse des statischen Konstruktors vorhanden sind, werden sie in der Textreihenfolge ausgeführt, in der sie in der Klassendeklaration vorhanden sind. Die Initialisierer werden unmittelbar vor dem statischen Konstruktor ausgeführt.
  • Wenn Sie keinen statischen Konstruktor zum Initialisieren von statischen Feldern angeben, werden alle statischen Felder mit ihrem Standardwert initialisiert, wie unter Standardwerte für C#-Typen aufgeführt.
  • Wenn ein statischer Konstruktor eine Ausnahme auslöst, ruft ihn die Laufzeit kein zweites Mal auf, und der Typ bleibt für die Lebensdauer der Anwendungsdomäne nicht initialisiert. Eine TypeInitializationException-Ausnahme wird in aller Regel ausgelöst, wenn ein statischer Konstruktor keinen Typ instanziieren kann oder wenn in einem statischen Konstruktor ein Ausnahmefehler auftritt. Bei statischen Konstruktoren, die im Quellcode nicht explizit definiert sind, ist zur Problembehandlung möglicherweise eine Prüfung des IL-Codes (Intermediate Language, Zwischensprache) erforderlich.
  • Die Existenz eines statischen Konstruktors verhindert die Hinzufügung des BeforeFieldInit-Typattributs. Dadurch wird die Laufzeitoptimierung eingeschränkt.
  • Ein als static readonly deklariertes Feld kann nur als Teil der Deklaration oder in einem statischen Konstruktor zugewiesen werden. Wenn ein expliziter statischer Konstruktor nicht erforderlich ist, initialisieren Sie statische Felder in der Deklaration anstatt über einen statischen Konstruktor, um die Laufzeitoptimierung zu verbessern.
  • Die Runtime ruft einen statischen Konstruktor höchstens einmal in einer einzelnen Anwendungsdomäne auf. Dieser Aufruf erfolgt in einem gesperrten Bereich, der auf dem spezifischen Typ der Klasse basiert. Im Text eines statischen Konstruktors sind keine zusätzlichen Sperrmechanismen erforderlich. Um das Risiko von Deadlocks zu vermeiden, blockieren Sie den aktuellen Thread in statischen Konstruktoren und Initialisierern nicht. Warten Sie z. B. nicht auf Aufgaben, Threads, Wait-Handles oder Ereignisse, richten Sie keine Sperren ein, und führen Sie keine blockierenden parallelen Vorgänge wie parallele Schleifen, Parallel.Invoke und parallele LINQ-Abfragen aus.

Hinweis

Auch wenn auf einen expliziten statischen Konstruktor nicht direkt zugegriffen werden kann, sollte seine Existenz dennoch dokumentiert werden, um bei der Fehlerbehebung von Initialisierungsausnahmen zu helfen.

Verwendung

  • Eine typische Verwendung statischer Konstruktoren besteht darin, wenn die Klasse eine Protokolldatei verwendet und der Konstruktor verwendet wird, um Einträge in dieser Datei zu schreiben.
  • Statische Konstruktoren sind auch beim Erstellen von Wrapperklassen für nicht verwalteten Code nützlich, wenn der Konstruktor die LoadLibrary-Methode aufrufen kann.
  • Statische Konstruktoren sind auch eine praktische Möglichkeit, um Laufzeitüberprüfungen des Typparameters über Typparametereinschränkungen zu erzwingen, die zur Kompilierzeit nicht überprüft werden können.

Beispiel

In diesem Beispiel verfügt die Klasse Bus über einen statischen Konstruktor. Wenn die erste Instanz von Bus erstellt wird (bus1), wird der statische Konstruktor zur Initialisierung der Klasse aufgerufen. Die Beispielausgabe überprüft, ob der statische Konstruktor nur einmal ausgeführt wird, obwohl zwei Instanzen von Bus erstellt werden, und dass er vor dem Ausführen des Instanzkonstruktors ausgeführt wird.

public class Bus
{
    // Static variable used by all Bus instances.
    // Represents the time the first bus of the day starts its route.
    protected static readonly DateTime globalStartTime;

    // Property for the number of each bus.
    protected int RouteNumber { get; set; }

    // Static constructor to initialize the static variable.
    // It is invoked before the first instance constructor is run.
    static Bus()
    {
        globalStartTime = DateTime.Now;

        // The following statement produces the first line of output,
        // and the line occurs only once.
        Console.WriteLine("Static constructor sets global start time to {0}",
            globalStartTime.ToLongTimeString());
    }

    // Instance constructor.
    public Bus(int routeNum)
    {
        RouteNumber = routeNum;
        Console.WriteLine("Bus #{0} is created.", RouteNumber);
    }

    // Instance method.
    public void Drive()
    {
        TimeSpan elapsedTime = DateTime.Now - globalStartTime;

        // For demonstration purposes we treat milliseconds as minutes to simulate
        // actual bus times. Do not do this in your actual bus schedule program!
        Console.WriteLine("{0} is starting its route {1:N2} minutes after global start time {2}.",
                                this.RouteNumber,
                                elapsedTime.Milliseconds,
                                globalStartTime.ToShortTimeString());
    }
}

class TestBus
{
    static void Main()
    {
        // The creation of this instance activates the static constructor.
        Bus bus1 = new Bus(71);

        // Create a second bus.
        Bus bus2 = new Bus(72);

        // Send bus1 on its way.
        bus1.Drive();

        // Wait for bus2 to warm up.
        System.Threading.Thread.Sleep(25);

        // Send bus2 on its way.
        bus2.Drive();

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Sample output:
    Static constructor sets global start time to 3:57:08 PM.
    Bus #71 is created.
    Bus #72 is created.
    71 is starting its route 6.00 minutes after global start time 3:57 PM.
    72 is starting its route 31.00 minutes after global start time 3:57 PM.
*/

C#-Sprachspezifikation

Weitere Informationen finden Sie im Abschnitt Statische Konstruktoren der C#-Sprachspezifikation.

Weitere Informationen