Constructors and Its Types in C#

using System;  
namespace copyConstractor  
{  
    class employee  
    {  
        private string name;  
        private int age;  
        public employee(employee emp)   // declaring Copy constructor.  
        {  
            name = emp.name;  
            age = emp.age;  
        }  
        public employee(string name, int age)  // Instance constructor.  
        {  
            this.name = name;  
            this.age = age;  
        }  
        public string Details     // Get deatils of employee  
        {  
            get  
            {  
                return  " The age of " + name +" is "+ age.ToString();  
            }  
        }  
    }  
    class empdetail  
    {  
        static void Main()  
        {  
            employee emp1 = new employee("Vithal", 23);  // Create a new employee object.  
            employee emp2 = new employee(emp1);          // here is emp1 details is copied to emp2.  
            Console.WriteLine(emp2.Details);  
            Console.ReadLine();  
        }  
    }  
}

Now run the program, the output will be as follows:

Static Constructor in C#

When a constructor is created using a static keyword, it will be invoked only once for all of the instances of the class and it is invoked during the creation of the first instance of the class or the first reference to a static member in the class. A static constructor is used to initialize static fields of the class and to write the code that needs to be executed only once.

Some key points of a static constructor are:

1. A static constructor does not take access modifiers or have parameters.
2. A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.
3. A static constructor cannot be called directly.
4. The user has no control over when the static constructor is executed in the program.
5. A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.

Syntax

class employee  
{
    // Static constructor  
    static employee(){}  
}

Now let's see it practically.

using System;  
namespace staticConstractor  
{  
    public class employee  
    {  
        static employee() // Static constructor   
        declaration{Console.WriteLine("The static constructor ");  
    }  
    public static void Salary()  
    {  
        Console.WriteLine();  
        Console.WriteLine("The Salary method");  
    }  
}  
class details  
{  
    static void Main()  
    {  
        Console.WriteLine("----------Static constrctor example by vithal wadje------------------");  
        Console.WriteLine();  
        employee.Salary();  
        Console.ReadLine();  
    }  
  }  
}

Now run the program the output will look as in the following:

Private Constructor in C#

When a constructor is created with a private specifier, it is not possible for other classes to derive from this class, neither is it possible to create an instance of this class. They are usually used in classes that contain static members only. Some key points of a private constructor are:

1. One use of a private constructor is when we have only static members.
2. It provides an implementation of a singleton class pattern
3. Once we provide a constructor that is either private or public or any, the compiler will not add the parameter-less public constructor to the class.

Now let's see it practically.

using System;  
namespace defaultConstractor  
{  
    public class Counter  
    {  
        private Counter()   //private constrctor declaration  
        {  
        }  
        public static int currentview;  
        public static int visitedCount()  
        {  
            return ++ currentview;  
        }  
    }  
    class viewCountedetails  
    {  
        static void Main()  
        {  
            // Counter aCounter = new Counter();   // Error  
            Console.WriteLine("-------Private constructor example by vithal wadje----------");  
            Console.WriteLine();  
            Counter.currentview = 500;  
            Counter.visitedCount();  
            Console.WriteLine("Now the view count is: {0}", Counter.currentview);  
            Console.ReadLine();  
        }  
    }  
}

Now run the application. The output is as follows.

If you uncomment the preceding statement that is commented in the above program then it will generate an error because the constructor is inaccessible (private).

Summary

In this article, I discussed various types of constructors in C# language, I hope you found this article useful