An Overview of C# Static Constructors

Static Constructor in C#

In C#, a static constructor is a special type of constructor that is used to initialize any static data or to perform a particular action that needs to be executed once when the class is loaded into memory, typically before any instance of the class is created, or any static members are accessed

• Before the first instance of the class is created: This ensures that any static members (fields, methods) are initialized or prepared before they're used by an object of that class.
• Before any static member of the class is referenced: This guarantees that the static initialization code runs before any static elements are accessed.

About Static constructors

• It doesn't have access modifiers (like public, private, or protected) and can't have parameters.
• It is implicitly private and can't be called directly by code.
• A static constructor is called automatically before the first instance of the class is created or any static members are accessed.
• Static constructors are called once per application domain, and they execute before any instance-level constructors. If a class is never used or referenced in the program, its static constructor will not execute

In a Simple way of understanding

• Declared with the static keyword: This distinguishes them from regular instance constructors (which don't have the static keyword).
• No access modifiers or parameters: Static constructors cannot have access modifiers (like public or private) or take parameters.
• Implicit invocation: They are called automatically by the CLR (Common Language Runtime) at the appropriate time, and you cannot call them directly.

Usages of Static constructors

• Initializing static fields: This is the primary purpose of static constructors. You can assign values to static fields within the constructor's body.
• Performing one-time actions: If you have code that needs to be executed only once during the program's lifetime, a static constructor is a suitable place.
  • Loading configuration data from a file
  • Registering event handlers
  • Performing validation checks on type parameters (with some limitations)
• One-time Setup: Perform one-time setup tasks such as setting up static resources or initializing static caches.
• Singleton Pattern: In some cases, static constructors are used in conjunction with the singleton pattern to ensure that a class has only one instance.
• Logging or Tracing Setup: Set up logging or tracing infrastructure for a class.

Sample Program

class MyStaticClass
{
    private static readonly int _age;

    public static int MemberAge
    {
        get
        {
            Console.WriteLine("i am refered MemberAge");
            return _age;
        }
    }

    private static readonly string _name;

    public static string MemberName
    {
        get
        {
            Console.WriteLine("i am refered MemberName");
            return _name;
        }
    }

    static MyStaticClass()
    {
        Console.WriteLine("i am called - Initialization of static data");
        _age = 42;
        _name = "Demo";
    }
}

 Console.WriteLine(" Main Started");
 Console.WriteLine(" Main Access MemberName Start");
 Console.WriteLine(MyStaticClass.MemberName);
 Console.WriteLine(" Main Access MemberName End");

 Console.WriteLine(" Main Access MemberAge Start");
 Console.WriteLine(MyStaticClass.MemberAge);
 Console.WriteLine(" Main Access MemberAge End");
 Console.WriteLine(" Main Ended");

 Console.ReadLine();

Result

 Main Started
 Main Access MemberName Start
i am called - Initialization of static data
i am refered MemberName
Demo
 Main Access MemberName End
 Main Access MemberAge Start
i am refered MemberAge
42
 Main Access MemberAge End
 Main Ended

Thanks