C# Private Constructor usage

In C#, a private constructor is a constructor that is only accessible within the same class. It cannot be accessed from outside the class, even by derived classes or other classes in the same assembly. The primary purpose of a private constructor is to restrict the instantiation of the class to within the class itself.

Here are common use cases for a private constructor in C#:

1. Singleton Design Pattern:

One of the most common use cases for a private constructor is to implement the Singleton design pattern. The Singleton pattern ensures that a class has only one instance throughout the application and provides a global point of access to that instance.

    public class Singleton
    {
        private static Singleton instance;

        private Singleton() // Private constructor
        {
            // Initialization code
        }

        public static Singleton GetInstance()
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }

2. Utility Classes:

Classes that contain only static members and utility methods often have private constructors to prevent instances from being created. These classes typically provide helper functions and don't need to be instantiated.

    public static class MathUtils
    {
        private MathUtils() // Private constructor
        {
            // Prevent instantiation
        }

        public static int Add(int a, int b)
        {
            return a + b;
        }
    }
 

3. Factory Methods:

Private constructors are often used in conjunction with public static factory methods to control object creation. The factory method can control the creation logic based on certain conditions or requirements.

    public class Product
    {
        private Product()
        {
            // Private constructor
        }

        public static Product CreateProduct()
        {
            // Custom creation logic
            return new Product();
        }
    }
 

By making the constructor private, you ensure that instances of the class can only be created within the class itself or through designated factory methods, promoting better control over object creation and enforcing design patterns or usage patterns.