Constructor in C#

Constructor Parameters

Constructor parameters in C# are the input variables defined within a constructor's signature. They allow developers to pass data and information to the constructor when creating an object of the corresponding class. By including parameters in a constructor, the class can be instantiated with specific initial values, making it more flexible and adaptable to different scenarios. When defining a constructor, you can specify its parameters within parentheses after the constructor's name.

Example

Output:

In the above example, the MyClass constructor takes two parameters: a string called name and an int called age. When an object of MyClass is created, these parameters must be provided to the constructor. This allows us to set the Name and Age properties of the object to specific values right at the moment of its instantiation.

Important points to Remember About Constructors

Let us now look at the important aspects of constructor in C#.

• Automatic Invocation: Constructors are automatically called when an object of the class is created using the new keyword. They are responsible for initializing the object's state before it can be used.
• Name and No Return Type: Constructors have the same name as the class they belong to and do not have an explicit return type, not even void.
• Default Constructor: If you don't define any constructors in a class, C# automatically provides a default parameterless constructor. However, if you define any constructor (parameterless or not), the default constructor is not automatically created.
• Initialization Logic: Constructors are used to set up initial values for the object's properties or fields. This helps ensure the object is in a valid state when created.
• Chaining Constructors: Constructors can be chained together using the this keyword to reuse initialization logic and reduce redundancy.
• Inheritance and Constructors: In derived classes, constructors can implicitly or explicitly call base class constructors using the base keyword to ensure proper initialization of the inherited members.

In the above section you learned some important points of constructors in C#.

Types of Constructors

In this section, you shall learned about the different types of constructor in C#.

Default Constructor

A default constructor in C# is a constructor that is automatically provided by the compiler when a class does not have any explicit constructors defined. It is also known as a parameterless constructor because it does not accept any parameters. The default constructor has an empty body, meaning it does not contain any initialization logic.

If a class does not have any constructors defined, the compiler automatically generates a default constructor for the class. However, if the class contains at least one constructor, the default constructor is not automatically provided.

Here's an example of a class with a default constructor in C#:

Example:

Output:

In the above example, the MyClass class has a default constructor in C# defined explicitly.

Parameterized Constructor

A parameterized constructor in C# is a constructor that accepts one or more parameters, allowing developers to pass data and information to the constructor during object creation. Unlike the default constructor, which has no parameters, the parameterized constructor provides a way to initialize the object's properties with specific values at the time of instantiation.

Here's an example of a class with a parameterized constructor in C#:

Example:

Output:

In the above example, the MyClass class has a parameterized constructor that takes two parameters: a string called name and an int called age. When an object of MyClass is created using this constructor, the provided name and age values are used to initialize the Name and Age properties of the object.

Note: Parameterized constructors are useful when you want to ensure that certain properties of an object are initialized with specific values at the time of creation.

Copy Constructor

A copy constructor is a special type of constructor that creates a new object by copying the values from another object of the same type. Its purpose is to provide a mechanism to create a duplicate, or deep copy, of an existing object. By doing so, the copy constructor ensures that the new object is entirely independent and has its own separate memory space, rather than just referencing the same memory locations as the original object.

Here's an example of a copy constructor in C#:

Example:

In the above example, the MyClass class has a copy constructor that takes an object of the same class, MyClass, as its parameter. The constructor then initializes the new object's properties (Name and Age) by copying the corresponding values from the other object.

Output:

Private Constructor

A private constructor in C# is a constructor with a private access modifier, meaning it can only be accessed from within the same class. It cannot be called directly from outside the class or from other classes. Private constructors are used to restrict the instantiation of a class to within the class itself, preventing external code from creating objects of that class.

Here's an example of a class with a private constructor:

Example:

In the above example, the SingletonClass has a private constructor, making it impossible for code outside of the class to create instances directly. Instead, the public static method GetInstance() is used to control the creation of the single instance, ensuring that there is only one instance of SingletonClass throughout the application.

Output:

Note: Using private constructors allows developers to enforce design patterns, control object creation, and restrict instantiation based on specific requirements, contributing to the overall robustness and integrity of the codebase.

Static Constructor

A static constructor in C# is a special constructor used to initialize static members of a class. Unlike regular instance constructors, static constructors are automatically called only once, before any static members are accessed or any static methods are called within the class.

Here's an example of a class with a static constructor:

Example:

In the above example, the MyStaticClass contains a static constructor that initializes the static field Counter to 0. The static constructor is automatically called the first time any member of the class is accessed.

Output:

Hence, till now you have learned about the different types of constructor in C#.