`this` e un costruttore di classe

Question

Attualmente ho una classe e sono un po 'confuso con il suo costruttore.

public class BarListTracker : GotTickIndicator 
{ 
    public BarListTracker(BarInterval interval) : this(new BarInterval[] { interval }) { } 
} 

che cosa fa la dichiarazione this(new BarInterval[] { interval }) implica?

Answer 1

Ciò indica che essi stanno basando, o chiamando , un altro costruttore della classe quando questo viene chiamato e passa il valore come una matrice di BarInterval. In questo caso è non una classe base perché altrimenti si direbbe : base(...), è un altro costruttore definito in questa stessa classe.

Questo è molto comune perché si desidera accedere a una classe in diversi modi e, in questo caso, sembra che siano in grado di inviare solo un singolo oggetto a volte senza impostare un array nel codice.

Tuttavia, una cosa che avrebbero potuto fare è appena cambiato l'altro costruttore, quello di essere chiamato con : this essere questo:

public BarListTracker(params BarInterval[] interval) 

e non sarebbe nemmeno necessario il secondo costruttore. È una soluzione più pulita e produce gli stessi risultati ovunque.L'altro costruttore ottiene ancora un array, si può anche passare un array ad esso se si voleva:

var arrOfBarInterval = new BarInterval[] { val1, val2 }; 
var tracker = new BarListTracker(arrOfBarInterval); 

Ma, si può anche solo trascorrere una:

var tracker = new BarListTracker(barInterval); 

Se avete la possibilità di fare che lo raccomanderei.

Un avvertimento da notare, il costruttore : this(...) viene chiamato ed eseguito prima il costruttore si è in. Tenere a mente quando si costruisce la logica.

Answer 2

Questo è constructor chaining. In sostanza, si sta chiamando un costruttore diverso prima di eseguire il contenuto di tale costruttore.

public class Foo 
{ 
    public Foo() 
     : this("Hello") 
    { 
     Console.Write(" World!"); 
    } 

    public Foo(string text) 
    { 
     Console.Write(text); 
    } 
} 

new Foo(); //outputs "Hello World!" 

Quindi, da qualche parte nel vostro BarListTracker ci dovrebbe essere un altro costruttore che richiede sia una matrice BarInterval[] o un IEnumerable<BarInterval> come questo:

public class BarListTracker : GotTickIndicator 
{ 
    public BarListTracker(BarInterval interval) 
     : this(new BarInterval[] { interval }) 
    { 
     //specific initialization for this constructor 
    } 

    public BarListTracker(BarInterval[] intervals) 
    { 
     //shared initialization logic for both constructors 
    } 
} 

eseguirà il corpo BarListTracker(BarInterval[]), quindi eseguire il corpo di BarListTracker(BarInterval)

Questo è generalmente utilizzato per ridurre la duplicazione del codice. Se disponi di un codice di inizializzazione per il tuo-, ha più senso scriverlo in un posto e condividere quella logica con i tuoi costruttori piuttosto che riscriverlo per ognuno.

Inoltre, consente di passare o modificare i parametri di input con espressioni di base. Quindi, in questo caso, in linea con la chiamata al costruttore BarListTracker(BarInterval[]), è il wrapping del singolo oggetto BarInterval interval come una matrice per abbinare la firma. Probabilmente questo è solo un sovraccarico di convenienza per fornire un'API più semplice per i programmatori che spesso possono avere solo un singolo BarInterval con cui costruire il tracker.

Answer 3

Ciò significa una chiamata di un altro costruttore dello che accetta un array di oggetti BarInterval, passando una matrice contenente l'oggetto passato in questo costruttore. Si effettua la chiamata

var tracker = new BarListTracker(interval); 

equivalente a questo:

var tracker = new BarListTracker(new BarInterval[] { interval }); 

Answer 4

chiamate un altro costruttore in questa classe, qualcosa di simile:

public BarListTracker(BarInterval[] intervals) 

Answer 5

Si chiama un altro costruttore della stessa classe, ad esempio

public class Point{ 
    public Point(int x, int y){ 
     this.x=x; 
     this.y=y; 
    } 

    public Point():this(0,0){} 
} 

se nel codice si chiamano

var p= new Point(); 

utilizzerà il costruttore senza parametri definiti che chiamerà il costruttore con il parametro di passaggio a è 0,0

questo è piuttosto utile se si dispone di più di un costruttore che accetta molti parametri e desidera fornire cons tructor con il parametro predefinito

Answer 6

si avrà un altro costruttore che accetta come parametro un array di BarInterval. Questo in pratica non è altro che chiamare un costruttore da un altro costruttore. Un altro collegamento che potrebbe essere utile è Call one constructor from another