Inizializzazione delle proprietà automatiche C # [duplicato]

Question

    

Questa domanda ha già una risposta qui:

    

        
•              Come si dà a una proprietà automatica C # un valore predefinito ?                                      23 risposte                          
    

    

Sono abituato a scrivere lezioni come questa:

public class foo {
  private string mBar = "bar";
  public string Bar {
    get { return mBar; }
    set { mBar = value; }
  }
  //... other methods, no constructor ...
}

La conversione della barra in una proprietà automatica sembra conveniente e concisa, ma come posso mantenere l'inizializzazione senza aggiungere un costruttore e inserirla?

public class foo2theRevengeOfFoo {
  //private string mBar = "bar";
  public string Bar { get; set; }
  //... other methods, no constructor ...
  //behavior has changed.
}

Potresti vedere che l'aggiunta di un costruttore non è in linea con i risparmi di sforzo che dovrei ottenere dalle proprietà automatiche.

Qualcosa del genere avrebbe più senso per me:

public string Bar { get; set; } = "bar";

Answer 1

Aggiornamento: la risposta di seguito è stata scritta prima che arrivasse C # 6. In C # 6 puoi scrivere:

public class Foo
{
    public string Bar { get; set; } = "bar";
}

Puoi anche scrivere proprietà di sola lettura implementate automaticamente, che sono scrivibili solo nel costruttore (ma può anche essere assegnato un valore iniziale predefinito:

public class Foo
{
    public string Bar { get; }

    public Foo(string bar)
    {
        Bar = bar;
    }
}

---

È un peccato che non ci sia modo di farlo proprio ora. Devi impostare il valore nel costruttore. (L'uso del concatenamento del costruttore può aiutare a evitare la duplicazione.)

Le proprietà implementate automaticamente sono utili al momento, ma potrebbero sicuramente essere più belle. Non mi trovo a desiderare questo tipo di inizializzazione spesso come una proprietà implementata automaticamente di sola lettura che potrebbe essere impostata solo nel costruttore e sarebbe supportata da un campo di sola lettura.

Questo non è accaduto fino al C # 5 incluso, ma è in programma per C # 6 - entrambi in termini di consentire l'inizializzazione nel punto di dichiarazione, e che consentono l'implementazione automatica di sola lettura proprietà da inizializzare in un corpo del costruttore.

Answer 2

Puoi farlo tramite il costruttore della tua classe:

public class foo {
  public foo(){
    Bar = "bar";
  }
  public string Bar {get;set;}
}

Se hai un altro costruttore (cioè uno che prende i parametri) o un gruppo di costruttori puoi sempre avere questo (chiamato concatenamento del costruttore):

public class foo {
  private foo(){
    Bar = "bar";
    Baz = "baz";
  }
  public foo(int something) : this(){
    //do specialized initialization here
    Baz = string.Format("{0}Baz", something);
  }
  public string Bar {get; set;}
  public string Baz {get; set;}
}

Se si collega sempre una chiamata al costruttore predefinito, è possibile impostare lì tutte le inizializzazioni di proprietà predefinite. Durante il concatenamento, il costruttore incatenato verrà chiamato prima del costruttore chiamante in modo che i costruttori più specializzati saranno in grado di impostare impostazioni predefinite diverse, a seconda dei casi.

Answer 3

Sarà possibile in C # 6.0:

public int Y { get; } = 2;

Answer 4

Nel costruttore predefinito (e in quelli non predefiniti se ne hai ovviamente uno):

public foo() {
    Bar = "bar";
}

Credo che questo non sia meno performante del tuo codice originale, dato che è comunque ciò che accade dietro le quinte.