C# Static Constructor vs Instance Constructor

1. What is a Static Constructor?

A static constructor is used to initialize static members of a class. It executes automatically only once per type initialization, regardless of how many objects are created.

Key Points

• Uses the static keyword.

• Executes automatically, at most once per type initialization.

• Cannot accept parameters or access modifiers.

• Cannot be called explicitly.

• Mainly used for one-time initialization of static data.

2. What is an Instance Constructor?

An instance constructor is used to initialize instance fields and properties. It executes whenever a new object is created.

Key Points

• Does not use the static keyword.

• Executes whenever an object is created.

• Can accept parameters.

• Supports constructor overloading.

• Used to initialize object-specific data.

3. Simple Example

public class Employee
{
    public static string CompanyName;
    public string Name;

    // Static Constructor
    static Employee()
    {
        CompanyName = "ABC Technologies";
        Console.WriteLine("Static Constructor Called");
    }

    // Instance Constructor
    public Employee(string name)
    {
        Name = name;
        Console.WriteLine("Instance Constructor Called");
    }
}

// Creating Objects
Employee emp1 = new Employee("John");
Employee emp2 = new Employee("David");

Console.WriteLine(emp1.Name);
Console.WriteLine(emp2.Name);
Console.WriteLine(Employee.CompanyName);

Output

Static Constructor Called
Instance Constructor Called
Instance Constructor Called
John
David
ABC Technologies

Explanation

1. When emp1 is created, the static constructor executes first.

2. The instance constructor executes and initializes Name = "John".

3. When emp2 is created, the static constructor does not execute again.

4. The instance constructor executes again and initializes Name = "David".

5. Both objects share the static CompanyName field.

4. Execution Flow

Employee emp1 = new Employee("John");
                  |
                  v
          Static Constructor
             (Runs Once)
                  |
                  v
          Instance Constructor
             Name = John
                  |
                  v
            emp1 Created


Employee emp2 = new Employee("David");
                  |
                  v
          Static Constructor
             (Skipped)
                  |
                  v
          Instance Constructor
             Name = David
                  |
                  v
            emp2 Created

5. Static Constructor vs Instance Constructor – Differences

6. Important Interview Questions

Q1. Which constructor executes first?

When creating the first object of a class that has a static constructor, the static constructor executes before the instance constructor.

Q2. Can a static constructor execute without creating an object?

Yes. Accessing a static member can trigger static constructor execution.

Q3. Can we have both static and instance constructors in the same class?

Yes. A class can contain one static constructor and multiple overloaded instance constructors.

Q4. Can a static constructor access instance variables?

No, not directly. A static constructor can directly access only static members. Accessing instance members requires an object reference.

Q5. Can a static constructor be overloaded?

No. A class can have only one static constructor, and it cannot accept parameters.

Final Key Points

• Static Constructor = One-time initialization for the class.

• Instance Constructor = Initialization for each object.

• Static constructors initialize shared static data.

• Instance constructors initialize individual object data.

• Static constructors execute automatically before the type's first use that requires initialization.

Interview Answer: A static constructor initializes class-level static members and executes only once per type initialization. An instance constructor initializes object-level members and executes whenever a new object is created.