Les propriétés automatiques, les initialisateurs d'objets et de collections

Parmi les nouveautés de C#3.0, on trouve une nouvelle syntaxe qui permet de définir les propriétés de manière plus compacte : les propriétés automatiques.
Considérons la classe Personne suivante :

public class Personne

{       

    // Propriétés

    private int age;

    private string nom;

    private string prenom;           

    // Constructeurs

    public Personne() { }

    public Personne(int age, string nom, string prenom)

    {

        this.age    = age;

        this.nom    = nom;

        this.prenom = prenom;

    }

    // Accesseurs : getters & setters

    public int Age

    {

        get { return age; }

        set { age = value; }

    }

    public string Nom

    {

        get { return nom; }

        set { nom = value; }

    }

    public string Prenom

    {

        get { return prenom; }

        set { prenom = value; }

    }       

}

On pourra désormais écrire les accesseurs de la manière suivante :

// Accesseurs : getters & setters en C# 3.0

public int Age { get; set; }

public string Nom { get; set; }

public string Prenom { get; set; }

La syntaxe des propriétés automatiques est plus synthétique, le code est plus clair.
Il vaut mieux utiliser cette fonctionnalité pour les propriétés qui ne requiert pas de logique de validation.

Une autre fonctionnalité très utile est l'initialisateur d'objet.
Jusqu'ici, on pouvait instancier une classe de différentes manières, avec la classe Personne, on peut initialiser les propriétés une par une :

Personne p  = new Personne();

p.Age       = 10;

p.Nom       = "Dupond";

p.Prenom    = "François";

ou en utilisant le constructeur :

Personne p = new Personne(10, "Dupond", "François");

Avec C# 3.0, on pourra, à condition que les accesseurs get/set existent, instancier une classe comme cela :

Personne p = new Personne { Age = 10, Nom = "Dupond", Prenom = "François" };

Il n'est pas obligatoire lors de l'instanciation d'initialiser toutes les propriétés.
Les propriétés seront alors initialisées par les valeurs par défaut.
De plus, les propriétés peuvent être initialisées sans ordre précis.

Personne p1 = new Personne { Nom = "Dupond", Prenom = "François", Age = 10 };

// age sera initialisé à 0

Personne p2 = new Personne { Prenom = "François", Nom = "Dupond" };

// age sera initialisé à 0 et prenom à chaîne vide

Personne p3 = new Personne { Nom = "Dupond" }; 

Cette nouvelle fonctionnalité évite alors de créer une multitude de constructeurs de classe.
Au final, notre classe Personne devient alors beaucoup plus compact et plus lisible :

public class Personne

{

    // Accesseurs : getters & setters en C# 3.0

    public int      Age     { get; set; }

    public string   Nom     { get; set; }

    public string   Prenom  { get; set; }

}

Hormis les intitialisateurs d'objets, nous avons également les initialisateurs de collections.
En C# 2.0, pour déclarer et initialiser une collection d'objets, on devait, (et on pourrait toujours) faire :

List<Personne> personneList = new List<Personne>();

personneList.Add(new Personne { Age = 10, Nom = "Dupond", Prenom = "François" } );

personneList.Add(new Personne { Age = 72, Nom = "Pasteur", Prenom = "Louis" });

personneList.Add(new Personne { Age = 66, Nom = "Curie", Prenom = "Marie" });

Désormais, on pourra faire :

List<Personne> personneList = new List<Personne> {

    new Personne { Age = 10, Nom = "Dupond", Prenom = "François" },

    new Personne { Age = 21, Nom = "Pasteur", Prenom = "Louis" },

    new Personne { Age = 72, Nom = "Curie", Prenom = "Marie" }

};