> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C# 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.
```csharp theme={"dark"}
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:
```csharp theme={"dark"}
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
// {
// }
```
Tired of Poor C# Skills? Fix That With Deep Grasping!
Learn More
