Types of Constructors in C#

Constructors in C# are special methods within a class that are responsible for initializing the object's state when an instance of the class is created. They have the same name as the class and can have various forms and access modifiers.

There are two types of constructors in C#: default constructors and parameterized constructors.

Default Constructor

A default constructor is automatically provided by the C# compiler if you don't define any constructors in your class. It initializes the object with default values (e.g., numeric types with 0, reference types with null).

class MyClass { // Default constructor provided by the compiler }

Parameterized Constructor

A parameterized constructor allows you to initialize an object with specific values provided as arguments when the object is created.

class Person { public string Name; public int Age; public Person(string name, int age) { Name = name; Age = age; } }

Example of creating an instance with a parameterized constructor:

Person person = new Person("Jenny", 35);

Constructor Overloading

You can define multiple constructors in a class with different parameter lists, a technique called constructor overloading.

class Calculator { public Calculator() { } // Default constructor public Calculator(int initialValue) { /* Initialize with initialValue */ } public Calculator(int initialValue, double discount) { /* Initialize with initialValue and discount */ } }

This allows you to create objects using different sets of parameters:

Calculator calc1 = new Calculator(); Calculator calc2 = new Calculator(100); Calculator calc3 = new Calculator(200, 0.1);

Static Constructor

A static constructor is used to initialize static members of a class. It's called automatically before any static members are accessed or any static methods are called, and it cannot have parameters.

class Logger { public static int LogCount; static Logger() { LogCount = 0; // Perform other static initialization } }

The static constructor runs once when the class is first used:

int count = Logger.LogCount; // Static constructor is called here

Private Constructor

A private constructor prevents the class from being instantiated directly from outside the class. It's often used in singleton patterns or to create utility classes with only static members.

class Singleton { private Singleton() { } public static Singleton Instance { get; } = new Singleton(); }

In this example, you can't create a Singleton object directly; you must use the Instance property.

Conclusion

Constructors in C# are special methods within classes used for initializing objects when they are created. They can be default constructors provided by the compiler, parameterized constructors that accept arguments for custom initialization, or static constructors for initializing static members. Constructor overloading allows multiple constructors with different parameter lists, and private constructors can restrict direct instantiation of a class, making them essential for managing object initialization and behavior in C# programs.






Related Topics
  1. Asynchronous programming in C#
  2. Singleton Class in C#
  3. Using The CQRS Pattern In C#
  4. 3-Tier Architecture in C#
  1. Regular Expression in C#
  2. Lambda Expressions in C#
  3. Binary Search using C#
  4. Abstract Class In C#
  5. How to serialize and deserialize JSON in C#
  6. Global using Directive in C# 10
  7. Recursion in C#
  8. C# String Concatenation
  9. DES encryption/decryption in C#
  10. Triple DES Encryption and Decryption in C#
  11. Encrypt and Decrypt data using RSA algorithm in C#