Je suis plus d’un an en retard, mais j’ai découvert aujourd’hui quelques nouveautés dans le langage C# version 3.0 que j’ai envie de partager avec vous.

Je ne nommerai pas toutes les fonctionnalités ici, mais simplement celles qui m’ont le plus intéressé.

Variables typées implicitement

Tout programmeur étant habitué avec les langages de script tel que PHP et JavaScript connait les variables typées implicitement. Il sont déclarées sans que leur type ne soit défini. C# 3.0 introduit cette façon de faire. À partir de maintenant, il ne suffit que de préfixer toute déclaration de variable par le type var, et le tour est joué. À la première initialisation, la variable sera typée.

Par exemple:

var age = 29; // Variable typée implicitement en int
var nom = "Sébastien"; // Variable typée implicitement en string

Initialisateurs d’objets

Une autre grosse nouveauté, c’est la possibilité de pouvoir initialiser un objet directement, sans devoir passer par un constructeur avec paramètres. Il ne suffit que d’assigner des valeurs aux propriétés de l’objet entres accolades, immédiatement après son instantiation:

Personne moi = new Personne() { Nom = "Sébastien", Age = 29 };

Propriétés auto implémentées

Qui n’a jamais eu à écrire une longue classe, avec plusieurs propriétés pour exposer des membres, sans pour autant écrire de code spécifique à chacune. Le fait d’exposer directement les membres de la classe devenait tentant, malgré le fait que la pratique n’était pas recommandée.

Qu’à cela ne tienne, maintenant c’est possible de le faire de façon plus élégante. Ce qui autrefois donnait ceci:

class Personne {
    private int m_Age;
    private string m_Prenom;
    private string m_Nom;

    public int Age {
        get { return m_Age; }
        set { m_Age = value; }
    }

    public string Prenom{
        get { return m_Prenom; }
        set { m_Prenom= value; }
    }

    public string Nom{
        get { return m_Nom; }
        set { m_Nom= value; }
    }
}

Devient aujourd’hui:

class Personne {
    public int Age { get; set; }
    public string Prenom { get; set; }
    public string Nom { get; set; }
}

Le comportement final sera le même, puisque le compilateur se chargera de générer les membres de la classe “sous le capot”.

Voilà, en espérant que ces quelques exemples pourront en aider quelques-uns. Je n’ai pas nommé toutes les nouveautés du langage, parce qu’il y en a encore plusieurs, mais plutôt celles que j’avais trouvées les plus intéressantes.

Si vous avez des commentaires ou suggestions, n’hésitez pas à m’en faire part. Je vais essayer dans le futur d’écrire des articles de ce type un peu plus souvent.