Scopo del concatenamento del costruttore?

Question

Dopo aver letto questo Constructor chaining question sono solo curioso di sapere perché qualcuno dovrebbe fare concatenamento costruttore?

Qualcuno potrebbe fare luce sul tipo di scenari in cui ciò potrebbe essere utile.

È una buona pratica di programmazione?

Answer 1

E 'assolutamente una buona pratica per due motivi principali:

Per evitare la duplicazione del codice

class Foo 
{ 
    public Foo(String myString, Int32 myInt){ 
     //Some Initialization stuff here 
    } 

    //Default value for myInt 
    public Foo(String myString) : this(myString, 42){} 

    //Default value for both 
    public Foo() : this("The Answer", 42){} 
} 

Per far rispettare buon incapsulamento

public abstract class Foo 
{ 
    protected Foo(String someString) 
    { 
     //Important Stuff Here 
    } 
} 

public class Bar : Foo 
{ 
    public Bar(String someString, Int32 myInt): base(someString) 
    { 
     //Let's the base class do it's thing 
     // while extending behavior 
    } 
} 

Answer 2

Il motivo principale è riuscire a riutilizzare il codice tra costruttori. Invece di duplicare l'inizializzazione, è possibile inserire tutto il codice di inizializzazione in un singolo costruttore e chiamarlo da altri costruttori.

Answer 3

L'ho visto quando hai fatto un po 'di lavoro pesante in fase di costruzione, e hai molti modi diversi di creare l'oggetto. (Così una manciata di medici con diverse definizioni di parametri).

Si può semplicemente avere una funzione membro privata che fa il lavoro comune tra i medici. Non è davvero necessario che un ctor chiami un altro nella stessa classe. (Che non è nemmeno permesso nella maggior parte delle lingue).

Answer 4

'Constructor concatenamento' è un approccio in cui un costruttore chiama un altro costruttore nella stessa cla ss. Ciò è particolarmente utile quando abbiamo una classe che definisce più costruttori. Ad esempio, stiamo creando una classe chiamata Persona nell'esempio seguente. Abbiamo anche tre campi che possiamo usare; Età, nome e colore dei capelli. Questa classe ha tre costruttori. Se non abbiamo usato l'approccio della 'Constructor concatenamento', il codice sarebbe qualcosa di simile di seguito:

Non utilizzando il costruttore concatenamento:

public class Person 
    { 
     private int Age; 
     private string Name; 
     private string HairColour; 


     public Person(int theAge) 
     { 
      Age = theAge; 
     } 

     public Person(int theAge, string theName) 
     { 
      Age = theAge; 
      Name = theName; 
     } 

     public Person(int theAge, string theName, string theHairColour) 
     { 
      Age = theAge; 
      Name = theName; 
      HairColour = theHairColour; 
     } 

    } 

Come si può vedere, in ogni costruttore stiamo assegnando un valore su Age, che duplica il codice. Abbiamo anche assegnato un valore a Name in due dei costruttori, quindi ancora più duplicazioni. Per eliminare questo problema, possiamo assegnare tutti i valori a Age, Name e HairColour nel costruttore con il maggior numero di parametri. Possiamo quindi chiamare quel costruttore quando vengono chiamati gli altri due costruttori. Vedere il codice qui sotto per vedere questo approccio "Chaining".

utilizzando il costruttore concatenamento:

public class Person 
    { 
     private int Age; 
     private string Name; 
     private string HairColour; 


     public Person(int theAge):this(theAge, "", "") 
     { 
      //One parameter 
     } 

     public Person(int theAge, string theName):this(theAge, theName, "") 
     { 
      //Two Parameters 
     } 

     public Person(int theAge, string theName, string theHairColour) 
     { 
      //Three parameters 
      Age = theAge; 
      Name = theName; 
      HairColour = theHairColour; 
     } 

    } 

Speranza che aiuta - consente di risparmiare sulla duplicazione.

Un esempio più 'estremo' con un sacco di campi (e quindi un sacco di potenziali duplicazioni) è mostrata qui:

An example where it will definitely save on duplication