Private Constructor

A private constructor is a special instance constructor in C# restricted by the private access modifier. It explicitly prevents external classes from instantiating the type or deriving from it, restricting object creation and initialization exclusively to the members within the class itself.

public class ExampleClass
{
    // Private parameterless constructor
    private ExampleClass()
    {
        // Initialization logic
    }
}

Technical Characteristics

1. Suppression of the Default Constructor If a class declares no constructors, the C# compiler automatically generates a public parameterless default constructor. Explicitly declaring a private constructor suppresses this compiler generation, ensuring no public parameterless constructor exists.

2. Instantiation Restriction When a class contains only private constructors, any attempt by an external type to instantiate it using the new keyword results in compiler error CS0122 ('Type' is inaccessible due to its protection level).

3. Inheritance Blocking During inheritance, a derived class must invoke a constructor of its base class. If a base class has only private constructors, derived classes cannot access them. Consequently, the class cannot be inherited, effectively sealing it without using the sealed keyword (unless the derived class is nested within the base class).

4. Internal Access The private access modifier only restricts external access. Static methods, static properties, or other constructors within the same class definition retain full access to invoke the private constructor.

5. Overloading Like any other constructor, private constructors can be overloaded. A class can possess multiple private constructors with varying method signatures.

Mechanics Visualization

The following code demonstrates the compiler rules enforced by private constructors:

public class CoreComponent
{
    public int Id { get; private set; }

    // Private parameterless constructor
    private CoreComponent()
    {
        Id = 1;
    }

    // Private parameterized constructor
    private CoreComponent(int id)
    {
        Id = id;
    }

    // Static member within the class can invoke the private constructor
    public static CoreComponent Initialize()
    {
        return new CoreComponent(42); 
    }
}

public class ExternalClass
{
    public void Execute()
    {
        // ILLEGAL: Compiler Error CS0122
        // CoreComponent component = new CoreComponent();

        // ILLEGAL: Compiler Error CS0122
        // CoreComponent component = new CoreComponent(10);

        // LEGAL: Instantiation is handled internally by the class
        CoreComponent component = CoreComponent.Initialize();
    }
}

// ILLEGAL: Compiler Error CS0122 (Cannot access base constructor)
// public class DerivedComponent : CoreComponent 
// { 
// }

Master C# with Deep Grasping Methodology!

Learn More