Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt

Use this file to discover all available pages before exploring further.

A static constructor is a special, parameterless method used to initialize static data within a class or struct. The Common Language Runtime (CLR) invokes it automatically exactly once per application domain, strictly prior to the instantiation of the first object of the type or the first reference to any static member of the type. 
public class ConfigurationManager
{
    public static readonly int MaxConnections;

    // Static constructor
    static ConfigurationManager()
    {
        MaxConnections = 100;
    }
}

​
Technical Rules and Constraints

  • No Access Modifiers: Static constructors cannot have access modifiers (e.g., public, private). They are implicitly private and accessible only to the CLR.
  • No Parameters: They cannot accept parameters. Consequently, a type can have only one static constructor, and overloading is impossible.
  • Implicit Invocation: Developer code cannot call a static constructor explicitly. The CLR dictates the exact moment of execution.
  • No Instance Context: Static constructors cannot access instance members. The this and base keywords are invalid within their scope.
  • Generic Types: For generic types, the static constructor is invoked exactly once per closed constructed type. For example, MyClass<int> and MyClass<string> are distinct types at runtime, and each will trigger its own independent static constructor execution.
  • Value Types: Structs can define static constructors. The CLR guarantees execution when accessing any static member (including static fields, properties, and methods) or when calling an explicitly declared instance constructor. However, execution is not triggered by merely allocating an array of the struct or when the struct is initialized via its implicit default parameterless constructor (which simply zeroes the memory).

​
Initialization Semantics and the beforefieldinit Flag

Defining an explicit static constructor fundamentally alters a type’s initialization semantics by omitting the beforefieldinit flag in the emitted Intermediate Language (IL).
  • Without an explicit static constructor: The compiler emits the beforefieldinit flag. This grants the CLR the flexibility to initialize static fields at any time prior to their first access, enabling runtime performance optimizations.
  • With an explicit static constructor: The beforefieldinit flag is removed. This forces the CLR to execute the static constructor strictly and deterministically immediately before the first access to any static member or the first instantiation of the type.

​
Execution Flow and Thread Safety

The CLR guarantees thread-safe execution of static constructors. To achieve this without causing deadlocks with user code that might lock on typeof(T), the CLR utilizes a dedicated internal synchronization mechanism (an internal lock) for type initialization, rather than locking the publicly accessible Type object. If multiple threads attempt to access the type simultaneously, the CLR blocks all but one thread until the static constructor completes execution.

​
Exception Handling

Exceptions within a static constructor have severe consequences. If a static constructor throws an unhandled exception, the CLR catches it and wraps it in a TypeInitializationException. Once this occurs, the type is marked as in an error state and becomes permanently unusable for the lifetime of the application domain. Any subsequent attempts to instantiate the type or access its static members will immediately re-throw the TypeInitializationException without re-executing the static constructor.
Master C# with Deep Grasping Methodology!Learn More