Waarom hebben we een privéconstructeur nodig?

Als een klasse een privéconstructor heeft, kan deze niet worden geïnstantieerd.
Dus als ik niet wil dat mijn klas wordt geïnstantieerd en deze nog steeds gebruikt, kan ik deze statisch maken.

Wat is het nut van een privéconstructor?

Het wordt ook gebruikt in de singleton-klasse, maar behalve dat, is er een ander gebruik?

(Opmerking: de reden dat ik het bovenstaande singleton-geval uitsluit, is dat ik niet begrijp waarom we een singleton nodig hebben als er een statische klasse beschikbaar is. U mag dit niet beantwoorden vanwege mijn verwarring in de vraag.)

Antwoord 1, autoriteit 100%

Fabriek

Privéconstructors kunnen handig zijn bij het gebruik van een fabriekspatroon (met andere woorden, een statische functie die wordt gebruikt om een ​​instantie van de klasse te verkrijgen in plaats van expliciete instantiatie).

public class MyClass
{ 
    private static Dictionary<object, MyClass> cache = 
        new Dictionary<object, MyClass>();
    private MyClass() { }
    public static MyClass GetInstance(object data)
    {
        MyClass output;
        if(!cache.TryGetValue(data, out output)) 
            cache.Add(data, output = new MyClass());
        return output;           
    }
}

Pseudo-verzegeld met geneste kinderen

Alle geneste klassen die van de buitenste klasse erven, hebben toegang tot de privéconstructor.

U kunt dit bijvoorbeeld gebruiken om een ​​abstracte klasse te maken waarvan ukan erven, maar niemand anders (een internal-constructor zou hier ook werken om overerving te beperken naar een enkele assembly, maar de private-constructor dwingt alle implementaties om geneste klassen te zijn.)

public abstract class BaseClass
{
    private BaseClass() { }
    public class SubClass1 : BaseClass
    {
        public SubClass1() : base() { }
    }
    public class SubClass2 : BaseClass
    {
        public SubClass2() : base() { }
    }
}

Basisconstructie

Ze kunnen ook worden gebruikt om “basis”-constructors te maken die worden aangeroepen door verschillende, meer toegankelijke constructors.

public class MyClass
{
    private MyClass(object data1, string data2) { }
    public MyClass(object data1) : this(data1, null) { }
    public MyClass(string data2) : this(null, data2) { }
    public MyClass() : this(null, null) { }
}

Antwoord 2, autoriteit 49%

Zoals Stefan, Adam en anderen hebben opgemerkt, zijn private constructors nuttig in gevallen waarin het ongewenst is dat een klasse door code buiten de klasse wordt gemaakt. Singletons, fabrieken, statische methode-objecten zijn voorbeelden van waar het nuttig is om de constructie van een type te beperken om een ​​bepaald patroon af te dwingen.

Om te reageren op het tweede deel van uw vraag over waarom singletons nodig zijn als statische klassen bestaan:singletons en statische klassen zijn nietequivalent.

Een singleton-klasse kan bijvoorbeeld een interface implementeren, een statische klasse niet. Een singleton-object kan als parameter aan methoden worden doorgegeven – dit is niet zo eenvoudig te doen met statische klassen zonder toevlucht te nemen tot wrapper-objecten of reflectie. Er zijn ook gevallen waarin u een overervingshiërarchie wilt maken waarin een (of meer) van de bladklassen singleton zijn – dit is ook niet mogelijk met statische klassen. Een ander voorbeeld: je hebt mogelijk verschillende singletons en je wilt er misschien een tijdens runtime instantiëren op basis van omgevings- of configuratieparameters – dit is ook niet mogelijk met statische klassen.

Het is belangrijk om de taalfuncties te begrijpen en de juiste te kiezen voor de taak – ze zijn er met een reden.

Antwoord 3, autoriteit 19%

Soms zou je een klas niet moeten kunnen instantiëren. Dit maakt dit expliciet en dwingt dit af op compilerniveau.

Singletons zijn slechts één gebruiksvoorbeeld. Constantenklassen, statische methodeklassen en andere soorten patronen schrijven voor dat een klasse niet instantieerbaar moet zijn.

Antwoord 4, autoriteit 6%

Doel om de privéconstructor binnen een klasse te maken

1. Om een ​​klasse te beperken die wordt overgenomen.

2. Beperk een klasse die wordt geïnstantieerd of meerdere instanties/objecten maakt.

3. Om het singleton-ontwerppatroon te bereiken.

   public class TestPrivateConstructor
   {
       private TestPrivateConstructor()
       {  }
       public static int sum(int a , int b)
       {
           return a + b;
       }
   }
   class Program
   {
       static void Main(string[] args)
       {
           // calling the private constructor using class name directly 
           int result = TestPrivateConstructor.sum(10, 15);
           // TestPrivateConstructor objClass = new TestPrivateConstructor(); // Will throw the error. We cann't create object of this class
       }
   }
   

Antwoord 5, autoriteit 4%

Je kunt het gebruiken om een ​​singletoninstantie te forceren of een fabrieksklasse.

Een statische methode kan de private constructor aanroepen om een ​​nieuwe instantie van die klasse te maken.

Bijvoorbeeld een singleton-instantie:

public class Foo
{
  private Foo (){}
  private Foo FooInstance {get;set;}
  public static Foo GetFooInstance ()
  {
    if(FooInstance == null){
      FooInstance = new Foo();
    }
    return FooInstance;
  }
}

Hierdoor kan slechts één instantie van de klasse worden gemaakt.

Antwoord 6, autoriteit 3%

Als je enige doel is dat je niet wilt dat het wordt geïnstantieerd, dan is het voldoende om het statisch te maken.

Als, otoh, je gewoon niet wilt dat het van buiten de klas wordt gemaakt (misschien wil je alleen dat gebruikers er een krijgen door een statische fabriek in de klas te gebruiken) – dan heb je een privé-ctor nodig om die toe te staan publiek toegankelijke statische fabrieken om het te instantiëren.

Onthoud dat het historisch gezien niet altijd mogelijk was om een ​​klasse statisch te maken… Het privé maken van de ctor was een manier om het niet-instantieerbaar te maken (is dit een woord?) voordat het statische sleutelwoord op een klasse kon worden toegepast. ..

Antwoord 7

Met betrekking tot singletons – singleton is een ontwerppatroon dat wordt gebruikt wanneer de omgeving en vereisten voldoen aan vergelijkbare motivaties voor het gebruik van het patroon; statische klassen zijn een taalfunctie.

Zoals LBushkin’s antwoord, terwijl sommige van de doelen van het gebruik van singleton kan worden bereikt met behulp van statische klassen, een bepaalde implementatie van singleton kan alleen de functieset van statische klassen overschrijden.

Antwoord 8

Als de klasse ALLEEN privé-constructors heeft, kan deze niet van buitenaf worden geïnstantieerd.

U kunt ook privé-constructeurs en openbare constructeurs hebben met verschillende handtekeningen.

Antwoord 9

Als je een fabriek voor een klasse wilt maken, kun je een privéconstructur gebruiken en enkele statische “fabrieks”-methoden aan de klasse zelf toevoegen om de klasse te maken.

Een voorbeeld hiervan is de Graphicsklasse, met de From* methodes.

Antwoord 10

Privé-constructors is een speciale instantie-constructor. en worden gebruikt in sommige gevallen waarin we een klasse maken die alleen statische leden heeft, dus het maken van een instantie van deze klasse is nutteloos, en dat is waar de private constructor in het spel komt.

Als een klasse een of meer privéconstructors heeft en geen openbare constructors, kunnen andere klassen (behalve geneste klassen) geen instanties van deze klasse maken.

voorbeeld:

class LogClass {
  public static double e = Math.E;  //2.71828
  // Private Constructor:
  private LogClass() { 
 }  
}

De verklaring van de lege constructor voorkomt de automatische generatie van een parameter minder constructeur.

Als u geen toegangsmodificator met de constructor gebruikt, is het nog steeds standaard privé.
Lees meer: https://qawithexperts.com/tutorial / C-Sharp / 32 / Private-constructor-in-C-Sharp