Difference Between Static Constructors And Non Static Constructors In C#

In C#, a constructor serves as a class method that is automatically invoked upon object creation. These specialized methods are essential for initializing objects with specific values. Constructors are named identically to their corresponding class and do not specify a return type.

There exist static constructors, non-static constructors, default constructors, and parameterized constructors. A constructor that accepts parameters is referred to as a parameterized constructor, while default constructors do not require any parameters.

If a static constructor initializes static members, it is referred to as a static constructor, while a non-static constructor will initialize the instance members.

Static Constructors:

Static Constructors are employed for initializing the static components of a class. They do not require any parameters, and their definition excludes an access modifier or the "static" keyword. The execution of a static constructor happens just once, usually before any static members are utilized or static methods are invoked within the class. It is not permissible to assign an access modifier such as public or private to a static constructor as it is automatically invoked by the runtime.

Syntax:

It has the following syntax:

class MyClass
{
 static MyClass() // Static constructor
 {
 // Initialization code for static members
 }
}

Example:

Let's consider a C# program to demonstrate the usage of static constructors.

using System;
class MyClass
{
 // Static variable to be initialized in the static constructor
 private static int staticVariable;
 static MyClass()
 {
 Console.WriteLine("Static constructor is called.");
 staticVariable = 100;
 }
 public static void PrintStaticVariable()
 {
 Console.WriteLine($"Static variable value: {staticVariable}");
 }
}
class Program
{
 static void Main()
 {
 MyClass.PrintStaticVariable();
 MyClass.PrintStaticVariable();
 }
}

Output:

The given code snippet defines a placeholder diagram with a background gradient, border radius, padding, margin, and text alignment for styling purposes. It includes a placeholder icon with a specific font size and margin, as well as placeholder text with a defined color and font size.

Explanation:

The C# program defines a class named MyClass with a static variable staticVariable and a static constructor (static MyClass) that initializes this variable to 100. The program includes a static method PrintStaticVariable in MyClass that prints the value of the static variable. In the Main method of the Program class, the static method PrintStaticVariable is called twice on the MyClass type, resulting in the execution of the static constructor only once. The program output displays the message "Static constructor is called" once, confirming the static constructor's single execution, and then prints the static variable value twice, indicating that the static variable retains its value across multiple calls to the static method.

Non-static constructors:

Non-static constructors, also known as instance constructors, are essential for initializing instance members within a class. These constructors bear the same name as the class and have the flexibility to accept parameters. Upon the creation of a class instance with the "new" keyword, a non-static constructor is automatically triggered. Furthermore, non-static constructors can be assigned access modifiers such as public or private to manage the constructor's visibility as needed.

Syntax:

It has the following syntax:

class MyClass
{
 public MyClass() // Non-static constructor
 {
 // Initialization code for instance members
 }
}

Example:

Let's consider a C# code example to demonstrate non-static constructors.

using System;
class MyClass
{
 // Instance variable to be initialized in the non-static constructor
 private int instanceVariable;
 public MyClass(int value)
 {
 Console.WriteLine("Non-static constructor is called.");
 instanceVariable = value;
 }
 public void PrintInstanceVariable()
 {
 Console.WriteLine($"Instance variable value: {instanceVariable}");
 }
}
class Program
{
 static void Main()
 {
 MyClass myObject = new MyClass(10);
 myObject.PrintInstanceVariable();
 MyClass anotherObject = new MyClass(20);
 anotherObject.PrintInstanceVariable();
 }
}

Output:

The code snippet below demonstrates the styling for a placeholder element with a diagram:

.placeholder-diagram { background: linear-gradient(135deg, #374151 0%, #1f2937 100%); border-radius: 12px; padding: 40px; margin: 20px 0; text-align: center; }
.placeholder-diagram .placeholder-icon { font-size: 3rem; margin-bottom: 10px; }
.placeholder-diagram .placeholder-text { color: #9ca3af; font-size: 1rem; }

Explanation:

The C# application introduces a class named MyClass, containing an instance variable named instanceVariable and a non-static constructor (public MyClass(int value)) responsible for initializing this variable with a specific value. Within the Main method of the Program class, the new keyword is utilized to instantiate two objects of MyClass, each with distinct values. Consequently, the non-static constructor is invoked for each object, confirming the message "Non-static constructor is called." Following this, the PrintInstanceVariable method is called for each object to display the individual values of their instance variables. This program effectively showcases the creation of unique object states through the non-static constructor, emphasizing the encapsulation of object-specific behavior within the class.

Differences between the static and non-static constructors:

The <style> code snippet defines the styling for a placeholder diagram. This includes a background with a linear gradient, border radius, padding, margin, and text alignment properties. Inside the diagram, there is an icon with a specific font size and margin, as well as text with a defined color and font size. This styling is crucial for creating visually appealing and structured placeholder elements on a webpage.

There exist various distinctions between static and non-constructors in C#. A few key variances include:

Conclusion:

Static constructors are linked to the class directly and are utilized for initializing static members once. On the other hand, non-static constructors are connected to class instances and serve the purpose of initializing instance members upon object creation.