Make the class builder private?

Question

When placing a constructor of a class in C# as private, get the following error:

I would like to know the technical explanation for the reason of this error and whether there is any case of use of a builder (or one of the builders) of a class as private.

Answer 1

A private constructor is useful in cases where you want to prevent the class from being instantiated or want to allow it to be instantiated only within itself. This is useful for static classes or to implement design standards Singleton and Factory.

An example can be found in that reply. Other examples are obviously in the other answers here.

Singleton (taken from Wikipedia):

public class Program {
    public static void Main() {
        var singleton = MyClass.Instance;
    }
}

public class MyClass {
   private static MyClass instance;
   private MyClass() {}
   public static MyClass Instance {
      get {
         if (instance == null) instance = new MyClass();
         return instance;
      }
   }
}

Behold working in the ideone. And in the .NET Fiddle. Also put on the Github for future reference.

Answer 2

The technical explanation is simple: the constructor cannot be accessed from outside the class. Hence the error.

Private constructors are important when you want to force parameters for the exposed constructors (public). For example, constructors without parameters could be declared private so that their use is avoided. There is a caveat here: the builder without parameters needs to do something, otherwise his statement makes no sense.

For example:

public class MinhaClasse 
{
    protected int MeuInteiroQuePrecisaSerPreenchido { get; set; }
    protected int OutraProperty { get; set; }

    // inacessível, portanto não pode ser usado fora da classe.
    private MinhaClasse() 
    { 
        OutraProperty = 5;
    } 

    // Aqui eu chamo o construtor sem parâmetros. 
    public MinhaClasse(int _meuInteiro) : this()
    {
        MeuInteiroQuePrecisaSerPreenchido = _meuInteiro;
    }
}

By default, the constructor without class parameters is public.

Still, suppose you want to define several constructs (for checking data of arguments, for example). You can make builders with varying levels of protection:

public class MinhaClasse2
{
    protected int MeuInteiro { get; set; }
    protected int OutraProperty { get; set; }
    protected String MinhaStringComValidacao { get; set; }

    // inacessível, portanto não pode ser usado fora da classe.
    private MinhaClasse() 
    { 
        OutraProperty = 5;
    } 

    private MinhaClasse(String _minhaString) : this()
    {
        if (_minhaString != "Valor que não pode") 
        {
            MinhaStringComValidacao = _minhaString;
        }
    }

    public MinhaClasse(int _meuInteiro, String _minhaString) : this(_minhaString)
    {
        MeuInteiro = _meuInteiro;
    }
}

Silly example, but only to demonstrate how it can be done.

Answer 3

We have a lot of good answers here but since I grumbled at something in each of them, I think it’s only fair that I expose my own.

As already said, the reason for the error is that you are trying to use a class member (the constructor) that is not accessible outside of it due to the fact that it is private.

And yes, there are cases of use or utility in declaring a constructor as private:

Declare a private constructor when you want this constructor to be accessible only to the class itself and its nested classes.

Sometimes only the class itself knows its constraints to be instantiated, so it is at these times that you declare the constructor as private. These restrictions may be:

• The class wants to restrict only a single instance of itself throughout the application lifecycle (design Pattern Singleton).

• The class wants to control its instances - for example by pooling instances of itself, so it itself creates its instances (design Pattern Factory) and decides when to deliver a new instance or when to deliver an existing instance.

• The class requires external consumers to pass certain parameters to the constructor but wants to be able to create instances of itself without passing any parameters or passing parameters that are not of public interest. In this case it would have public parameterized constructors and a private constructor not parameterized or that accepts specific parameters that only need to be known internally.

These are the uses that occur to me at the moment but there may be more.

Besides public and private, a builder can also be protected, which makes it possible for it to be used exclusively by the Child Class Controller, and ternal, which makes it accessible only to classes of the same Assembly.

Internal is useful for example to use the design Pattern Factory or pool of instances causing another class of the same context to be responsible for these restrictions instead of placing all this knowledge within the very class whose instantiation one wants to control.

As for creating a private constructor for static classes, it is not very useful because in this case it is enough to declare the class itself as static (Static class).

Answer 4

According to MSDN documentation:

A private constructor is a special instance constructor. It is generally used in classes that contain only static members. If a class has one or more private builders and no public constructor, other classes (except nested classes) may not create instances of that class.

For example:

class NLog
{
    // Construtor privado:
    private NLog() { }

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

Empty constructor declaration prevents automatic generation of a default constructor. Note that if you do not specify a modifier of access the constructor will still be private by default. However, the modifier private is usually used explicitly to make clear that the class cannot be instantiated.

Builders are used to avoid creating instances of a class when there are no instance fields or methods, as in the Math class, or when a method is called to obtain an instance of a class. If all class methods are static, consider making the entire class static.

Example:

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

class TestCounter
{
    static void Main()
    {
        // A instrução abaixo irá gerar um erro porque o construtor é inacessível
        // Counter aCounter = new Counter();   // Erro

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

        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
// Output: New count: 101

Answer 5

This is a concrete case, implemented by the ASP.NET Web Api team on Github: https://github.com/ASP-NET-MVC/aspnetwebstack/blob/master/src/System.Web.Http/Results/OkResult.cs

I myself have applied the same pattern here.

Briefly, the above two links show a pattern variation "Parameter Object". Public constructors of the class receive either their dependencies directly, or another object containing their dependencies.

Both public constructors involve the arguments in an instance of IDependencyProvider, which is passed to a private constructor who extracts dependencies and treats them evenly. This constructor is considered a detail of implementation, customers do not need to know about it, and therefore it is 'private.

public class MyClass
{
    private readonly string _dependency1;
    private readonly string _dependency2;

    public MyClass(string dependency1, int dependency2)
        : this(new DirectDependencyProvider(dependency1, dependency2))
    {
    }

    public MyClass(Container container)
        : this(new ContainerDependencyProvider(container))
    {
    }

    //constructor privado
    private MyClass(IDependencyProvider provider)
    {
        _dependency1 = provider.Dependency1;
        _dependency2 = provider.Dependency2;

        //etc, fazer alguma coisa com as duas dependencias
    }

    private interface IDependencyProvider
    {
        string Dependency1 { get; }
        int Dependency2 { get; }
    }

    private class DirectDependencyProvider : IDependencyProvider
    {
        private readonly string _dependency1;
        private readonly int _dependency2;

        public DirectDependencyProvider(string dependency1, int dependency2)
        {
            _dependency1 = dependency1;
            _dependency2 = dependency2;
        }

        public string Dependency1
        {
            get { return _dependency1; }
        }

        public int Dependency2
        {
            get { return _dependency2; }
        }
    }

    private class ContainerDependencyProvider : IDependencyProvider
    {
        private readonly Container _container;

        public ContainerDependencyProvider(Container container)
        {
            if(container == null)
                throw new ArgumentNullException("container");
            _container = container;
        }

        public string Dependency1
        {
            get { return _container.StringStuff; }
        }

        public int Dependency2
        {
            get { return _container.IntStuff; }
        }
    }
}

Note that the interface IDependencyProvider and its implementations are private types.

The alternative would be to use a private boot method, but we would have to sacrifice Fields readonly and the guarantee of its immutability. This is a sacrifice that can and must be avoided.

public class MyClass
{
    private string _dependency1;
    private string _dependency2;

    public MyClass(string dependency1, int dependency2)
    {
        Initialize(dependency1, dependency2);
    }

    public MyClass(Container container)
    {
        if(container == null)
            throw new ArgumentNullException("container");

        Initialize(container.StringStuff, container.IntStuff);
    }

    private void Initialize(string dependency1, int dependency2)
    {
        _dependency1 = dependency1;
        _dependency2 = dependency2;
    }
}

Answer 6

Another use case for a private constructor would be to implement the Singleton Pattern design. By this standard, a class must have only one instance. To ensure this, the Singleton constructor is private. More information: http://en.wikipedia.org/wiki/Singleton_pattern. Just a reminder that Singleton is useful in just a few situations. It has a number of disadvantages( for example, it makes testing difficult ), so it should be used carefully.

Answer 7

I believe that most uses are when we want to maintain a DDD and the framework forces us to have default constructor, for example it is the Entity Framework that forces all persisting entities to have constructs without parameter, but does not care about visibility. As you follow the DDD and do not want "anemic" templates do not want class users to be able to use these constructs and use this feature to hide them.

I agree that they also serve to protect classes with purely static methods, but there has the feature of declaring static class, design issue.

@Caffé: All classes have constructors, including static ones. Of course, these constructors have greater restrictions.

Note (linqpad):

void Main()
{
    Console.WriteLine(Xpto.msg);
}

static class Xpto
{
    public static string msg;

    static Xpto()
    {
        msg = "Blau";
    }
}