What is the need of private constructor in C#?

Question

What is the need of private constructor in C#? I got it as a question for a C# test.

Answer 1

You can use it with inheritance in a case where the arguments to the constructor for the base class are of different types to those of the child classes constructor but you still need the functionality of the base class in the child class eg. protected methods.

Generally though this should be avoided wherever possible as this is a bad form of inheritance to be using.

Answer 2

Whenever you want to prevent direct instantiation of a class from outside of it, you'll use a private constructor. For example, prior to C# 2.0 which introduced static classes, you used a private constructor to accomplish roughly the same thing:

sealed class StaticClass {
     private StaticClass() {
     }
     public static void DoSomething() {
     }
}

Answer 3

Private constructors are used to prevent the creation of instances of a class when there are no instance fields or methods, such as the Math class, or when a method is called to obtain an instance of a class. If all the methods in the class are static, consider making the entire class static. For more information see Static Classes and Static Class Members.

class NLog
{
    // Private Constructor:
    private NLog() { }

    public static double e = System.Math.E;  //2.71828...
}

The following is an example of a class using a private constructor.

public class Counter
{
    private Counter() { }
    public static int currentCount;
    public static int IncrementCount()
    {
        return ++currentCount;
    }
}

class TestCounter
{
    static void Main()
    {
        // If you uncomment the following statement, it will generate
        // an error because the constructor is inaccessible:
        // Counter aCounter = new Counter();   // Error

        Counter.currentCount = 100;
        Counter.IncrementCount();
        System.Console.WriteLine("New count: {0}", Counter.currentCount);
    }
}

Answer 4

For example if you have a class that should only be created through factory methods. Or if you have overloads of the constructor, and some of them should only be used by the other constructors. Probably other reasons as well =)

Answer 5

I'm late to the game, but reading through all the other answers, I don't see this usage mentioned:

I use private constructors in scenarios where I have multiple (public) constructors, and they all have some code in common. With constructor chaining, the code becomes really neat and DRY.

Remember, the private readonly variables can only be set in constructors, so I can't use a regular method.

Example:

public class MyClass
{
    private readonly int _a;
    private readonly int _b;
    private readonly string _x;

    public MyClass(int a, int b, string x)
        : this(x)
    {
        _a = a;
        _b = b;
    }

    public MyClass()
        : this("(not set)")
    {
        // Nothing set here...
    }

    private MyClass(string x)
    {
        _x = x;
    }
}

Answer 6

While this link is related to java, I think it should help you understand the reason why as the idea is pretty much the same.

Private constructors prevent a class from being explicitly instantiated by callers. There are some common cases where a private constructor can be useful:

• classes containing only static utility methods
• classes containing only constants
• type safe enumerations
• singletons