• 20 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Mis à jour le 10/03/2017

Créez votre premier objet

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Ah, enfin un peu de concret et surtout de code. Dans ce chapitre, nous allons appliquer les notions que nous avons vues sur la programmation orientée objet pour continuer notre apprentissage du C#.

Même si vous n'avez pas encore appréhendé exactement où la POO pouvait nous mener, ce n'est pas grave. Les notions s'affineront au fur et à mesure de la lecture du tutoriel. Il est temps pour nous de commencer à créer des objets, à les faire hériter entre eux, etc. Bref, à jouer, grâce à ces concepts, avec le C#.

Vous verrez qu'avec un peu de pratique tout s'éclaircira ; vous saisirez l'intérêt de la POO et comment être efficace avec le C#.

Tous les types C# sont des objets

Ça y est, il a fini avec son baratin qui donne mal à la tête ? Pourquoi tout ce blabla sur les objets ?

Parce que tout dans le C# est un objet. Comme déjà dit, une fenêtre Windows est un objet. Une chaîne de caractères est un objet. La liste que nous avons vue dans le cours précédent est un objet.
Nous avons vu que les objets possédaient des caractéristiques, il s’agit de propriétés. Un objet peut également faire des actions, ce sont des méthodes.

Suivant ce principe, une chaîne de caractères est un objet et possède des propriétés (par exemple sa longueur). De la même façon, il sera possible que les chaînes de caractères fassent des actions (par exemple se mettre en majuscules).
Nous allons voir plus bas qu’il est évidemment possible de créer nos propres objets (chat, chien, etc.) et que grâce à eux, nous allons enrichir les types qui sont à notre disposition. Un peu comme nous avons déjà fait avec les énumérations.

Voyons dès à présent comment faire, grâce aux classes.

Les classes

Dans le chapitre précédent, nous avons parlé des objets mais nous avons également parlé de la définition de l’objet, de sa structure. Eh bien, c’est exactement ça, une classe.

Nous avons déjà pu voir une classe dans le code que nous avons utilisé précédemment et qui a été généré par Visual Studio Express, la classe Program. Nous n’y avons pas fait trop attention, mais voilà à peu près à quoi elle ressemblait :

class Program
{
    static void Main(string[] args)
    {
    }
}

C’est elle qui contenait la méthode spéciale Main() qui sert de point d’entrée à l’application.
Nous pouvons découvrir avec des yeux neufs le mot clé class qui comme son nom le suggère permet de définir une classe, c'est-à-dire la structure d’un objet.

Rappelez-vous, les objets peuvent avoir des caractéristiques et faire des actions.

Ici, c’est exactement ce qu’il se passe. Nous avons défini la structure d’un objet Program qui contient une action : la méthode Main().
Vous aurez remarqué au passage que pour définir une classe, nous utilisons à nouveau les accolades permettant de créer un bloc de code qui délimite la classe.

Passons sur cette classe particulière et lançons-nous dans la création d’une classe qui nous servira à créer des objets. Par exemple, une classe Voiture.
À noter qu’il est possible de créer une classe à plusieurs endroits dans le code, mais en général, nous utiliserons un nouveau fichier, du même nom que la classe, qui lui sera entièrement dédié.
Une règle d’écriture commune à beaucoup de langage de programmation est que chaque fichier doit avoir une seule classe.

Faisons un clic droit sur notre projet pour ajouter une nouvelle classe :

Ajouter une nouvelle classe au projet
Ajouter une nouvelle classe au projet

Visual Studio Express nous ouvre sa fenêtre permettant de faire l’ajout d’un élément en se positionnant sur l’élément Classe. Nous pourrons donner un nom à cette classe : Voiture.

Création d'une classe Voiture
Création d'une classe Voiture

Vous remarquerez que les classes commencent en général par une majuscule.
Visual Studio Express nous génère le code suivant :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MaPremiereApplication
{
    class Voiture
    {
    }
}

Nous retrouvons le mot-clé class suivi du nom de notre classe Voiture et les accolades ouvrantes et fermantes permettant de délimiter notre classe. Notons également que cette classe fait partie de l’espace de nom MaPremièreApplication qui est l’espace de nom par défaut de notre projet. Pour nous simplifier le travail, Visual Studio Express nous a également inclus quelques espaces de noms souvent utilisés.

Mais pour l’instant cette classe ne fait pas grand-chose.

Comme cette classe est vide, elle ne possède ni propriétés, ni actions. Nous ne pouvons absolument rien faire avec à part en créer une instance, c'est-à-dire un objet. Cela se fait grâce à l’utilisation du mot-clé new. Nous y reviendrons plus en détail plus tard, mais cela donne :

static void Main(string[] args)
{
    Voiture voitureNicolas = new Voiture();
    Voiture voitureJeremie = new Voiture();
}

Nous avons créé deux instances de l’objet Voiture et nous les stockons dans les variable voitureNicolas et voitureJeremie.

Si vous vous rappelez bien, nous aurions logiquement dû écrire :

MaPremiereApplication.Voiture voitureNicolas = new MaPremiereApplication.Voiture();

Ou alors positionner le using qui allait bien, permettant d’inclure l’espace de nom MaPremiereApplication.

En fait, ici c’est superflu vu que nous créons les objets depuis la méthode Main() qui fait partie de la classe Program faisant partie du même espace de nom que notre classe.

Les méthodes

Nous venons de créer notre objet Voiture mais nous ne pouvons pas en faire grand-chose. Ce qui est bien dommage. Ça serait bien que notre voiture puisse klaxonner par exemple si nous sommes bloqués dans des embouteillages. Bref, que notre voiture soit capable de faire des actions. Qui dit « action » dit « méthode ».

Nous allons pouvoir définir des méthodes faisant partie de notre objet Voiture. Pour ce faire, il suffit de créer une méthode, comme nous l’avons déjà vu, directement dans le corps de la classe :

class Voiture
{
    void Klaxonner()
    {
        Console.WriteLine("Pouet !");
    }
}

Notez quand même l’absence du mot-clé static que nous étions obligés de mettre dans le cours précédent. Je vous expliquerai un peu plus loin pourquoi.

Ce qui fait que si nous voulons faire klaxonner notre voiture, nous aurons juste besoin d’invoquer la méthode Klaxonner() depuis l’objet Voiture, ce qui s’écrit :

Voiture voitureNicolas = new Voiture();
voitureNicolas.Klaxonner();

Cela ressemble beaucoup à ce que nous avons déjà fait. En fait, nous avons déjà utilisé des méthodes sur des objets. Rappelez-vous, nous avons utilisé la méthode Add() permettant d’ajouter une valeur à une liste :

List<int> maListe = new List<int>();
maListe.Add(1);

Comme nous avons un peu plus de notions désormais, nous pouvons remarquer que nous instancions un objet List (plus précisément, une liste d’entier) grâce au mot clé new et que nous invoquons la méthode Add de notre liste pour lui ajouter l’entier 1.

Nous avons fait pareil pour obtenir un nombre aléatoire, dans une écriture un peu plus concise. Nous avions écrit :

int valeurATrouver = new Random().Next(0, 100);

Ce qui peut en fait s’écrire :

Random random = new Random();
int valeurATrouver = random.Next(0, 100);

Nous créons un objet du type Random grâce à new puis nous appelons la méthode Next() qui prend en paramètres les bornes du nombre aléatoire que nous souhaitons obtenir (0 étant inclus et 100 exclu). Puis nous stockons le résultat dans un entier.

Et oui, nous avons manipulé quelques objets sans le savoir …

Revenons à notre embouteillage et compilons le code nous permettant de faire klaxonner notre voiture :

Voiture voitureNicolas = new Voiture();
voitureNicolas.Klaxonner();

Impossible de compiler, le compilateur nous indique l’erreur suivante :

MaPremiereApplication.Voiture.Klaxonner()' est inaccessible en raison de son niveau de protection

Diantre ! Déjà un premier échec dans notre apprentissage de l’objet !

Vous aurez deviné grâce au message d’erreur que la méthode Klaxonner() semble inaccessible. Nous expliquerons un peu plus bas de quoi il s’agit. Pour l’instant, nous allons juste préfixer notre méthode du mot-clé public, comme ceci :

class Voiture
{
    public void Klaxonner()
    {
        Console.WriteLine("Pouet !");
    }
}

Nous allons y revenir juste en-dessous, mais le mot-clé public permet d’indiquer que la méthode est accessible depuis n’importe où.

Exécutons notre application et nous obtenons :

Image utilisateur

Wahou, notre première action d’un objet. :)

Bien sûr, ces méthodes peuvent également avoir des paramètres et renvoyer un résultat. Par exemple :

class Voiture
{
    public bool VitesseAutorisee(int vitesse)
    {
        if (vitesse > 90)
            return false;
        else
            return true;
    }
}

Cette méthode accepte une vitesse en paramètre et si elle est supérieure à 90, alors la vitesse n’est pas autorisée. Cette méthode pourrait également s’écrire :

class Voiture
{
    public bool VitesseAutorisee(int vitesse)
    {
        return vitesse <= 90;
    }
}

En effet, nous souhaitons renvoyer faux si la vitesse est supérieure à 90 et vrai si la vitesse est inférieure ou égale.

Donc en fait, nous souhaitons renvoyer la valeur du résultat de la comparaison d’infériorité ou d’égalité de la vitesse à 90, c'est-à-dire :

class Voiture
{
    public bool VitesseAutorisee(int vitesse)
    {
        bool estVitesseAutorisee = vitesse <= 90;
        return estVitesseAutorisee;
    }
}

Ce que nous pouvons écrire finalement en une seule ligne comme précédemment.

Il est bien sûr possible d’avoir plusieurs méthodes dans une même classe et elles peuvent s’appeler entre elles, par exemple :

class Voiture
{
    public bool VitesseAutorisee(int vitesse)
    {
        return vitesse <= 90;
    }

    public void Klaxonner()
    {
        if (!VitesseAutorisee(180))
            Console.WriteLine("Pouet !");
    }
}

Quitte à rouler à une vitesse non autorisée, autant faire du bruit !

Notion de visibilité

Ok, le mot-clé public nous a bien sauvé la vie, mais… qu’est-ce donc ?

En fait, je l’ai rapidement évoqué et nous nous sommes bien rendu compte que sans ce mot-clé, c'est impossible de compiler car la méthode n’est pas accessible.

Le mot-clé public sert à indiquer que notre méthode peut être accessible depuis d’autres classes ; en l’occurrence dans notre exemple depuis la classe Program. C’est-à-dire que sans ce mot-clé, il est impossible à d’autres objets d’utiliser cette méthode.

Pour faire en sorte qu’une méthode soit inaccessible, nous pouvons utiliser le mot-clé private. Ce mot-clé permet d’avoir une méthode qui n’est accessible que depuis la classe dans laquelle elle est définie.
Prenons l’exemple suivant :

class Voiture
{
    public bool Demarrer()
    {
        if (ClesSurLeContact())
        {
            DemarrerLeMoteur();
            return true;
        }
        return false;
    }

    public void SortirDeLaVoiture()
    {
        if (ClesSurLeContact())
            PrevenirLUtilisateur();
    }

    private bool ClesSurLeContact()
    {
        // faire quelque chose pour vérifier
        return true;
    }

    private void DemarrerLeMoteur()
    {
        // faire quelque chose pour démarrer le moteur
    }

    private void PrevenirLUtilisateur()
    {
        Console.WriteLine("Bip bip bip");
    }
}

Ici seules les méthodes Demarrer() et SortirDeLaVoiture() sont utilisables depuis une autre classe, c'est-à-dire que ce sont les seules méthodes que nous pourrons invoquer, car elles sont publiques. Les autres méthodes sont privées à la classe et ne pourront être utilisées qu’à l’intérieur de la classe elle-même. Les autres classes n’ont pas besoin de savoir comment démarrer le moteur ou comment vérifier que les clés sont sur le contact, elles n’ont besoin que de pouvoir démarrer ou sortir de la voiture. Les méthodes privées sont exclusivement réservées à l’usage interne de la classe.

Il existe d’autres indicateurs de visibilité que nous allons rapidement décrire :

Visibilité

Description

public

Accès non restreint

protected

Accès depuis la même classe ou depuis une classe dérivée

private

Accès uniquement depuis la même classe

internal

Accès restreint à la même assembly

protected internal

Accès restreint à la même assembly ou depuis une classe dérivée

Les visibilités qui vont le plus vous servir sont représentées par les mots-clés public et private. Nous verrons que le mot-clé protected va servir un peu plus tard quand nous parlerons d’héritage. Notez qu’internal pourra être utilisé une fois que nous aurons bien maitrisé toutes les notions.

Ces mots-clés sont utilisables avec beaucoup d’autres concepts. Nous avons utilisé les méthodes pour les illustrer mais ceci est également valable pour les classes ou les propriétés que nous allons découvrir juste après.

Oui mais, au début, nous avons pu déclarer une classe sans préciser de visibilité… et pareil pour la première méthode qui ne compilait pas… c’est normal ?

Oui, il existe des visibilités par défaut suivant les types déclarés. Vous aurez compris par exemple que la visibilité par défaut d’une méthode est privée si l’on ne spécifie pas le mot clé.

Pour éviter tout risque et toute ambigüité, il est recommandé de toujours indiquer la visibilité. Ce que nous ferons désormais dans ce tutoriel, maintenant que nous savons de quoi il s’agit.

Les propriétés

Des objets c’est bien. Des actions sur ces objets, c’est encore mieux. Il nous manque encore les caractéristiques des objets. C’est là qu’interviennent les propriétés.

Sans le savoir, vous avez déjà utilisé des propriétés dans le cours précédent, par exemple dans le code suivant :

string[] jours = new string[] { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };
for (int i = 0; i < jours.Length; i++)
{
    Console.WriteLine(jours[i]);
}

Dans la boucle, nous utilisons jours.Length. Nous utilisons en fait la propriété Length du tableau « jours », un tableau étant bien sûr un objet.

Nous avons pu utiliser d’autres propriétés, par exemple dans l’instruction suivante :

List<string> jours = new List<string> { "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche" };
for (int i = 0; i < jours.Count; i++)
{
    Console.WriteLine(jours[i]);
}

Ici, Count est la propriété de la liste « jours ».

De la même façon, nous avons la possibilité de créer des propriétés sur nos classes pour permettre d’ajouter des caractéristiques à nos objets.

Par exemple, nous pouvons rajouter les propriétés suivantes à notre voiture : une couleur, une marque, une vitesse.
Il y a plusieurs façons de rajouter des caractéristiques à un objet. La première est d’utiliser des variables membres.

Les variables membres :

Ici en fait, un objet peut avoir une caractéristique sous la forme d’une variable publique qui fait partie de la classe. Pour ce faire, il suffit de définir simplement la variable à l’intérieur des blocs de code délimitant la classe et de lui donner la visibilité public.

Rajoutons par exemple une chaine de caractères permettant de stocker la couleur de la voiture :

public class Voiture
{
    public string Couleur;
}

Notez que j’ai rajouté les visibilités pour la classe et pour la variable.

Grâce à ce code, la chaine de caractères Couleur est désormais une caractéristique de la classe Voiture. Nous pourrons l’utiliser en faisant suivre notre objet de l’opérateur « . » suivi du nom de la variable. Ce qui donne :

Voiture voitureNicolas = new Voiture();
voitureNicolas.Couleur = "rouge";
Voiture voitureJeremie = new Voiture();
voitureJeremie.Couleur = "verte";

Cela ressemble beaucoup à ce que nous avons déjà fait. Nous utilisons le « . » pour accéder aux propriétés d’un objet.
Comme d’habitude, les variables vont pouvoir stocker des valeurs. Ainsi, nous pourrons avoir une voiture rouge pour Nicolas et une voiture verte pour Jérémie.

Les propriétés :

Les propriétés sont en fait des variables évoluées. Elles sont à mi-chemin entre une variable et une méthode.

Prenons cet exemple :

public class Voiture
{
    private int vitessePrivee;
    public int Vitesse
    {
        get
        {
            return vitessePrivee;
        }
        set
        {
            vitessePrivee = value;
        }
    }
}

Nous pouvons voir que nous définissons dans un premier temps une variable privée, « vitessePrivee » de type entier. Comme prévu, cette variable est masquée pour les utilisateurs d’objets Voiture. Ainsi, le code suivant :

Voiture voitureNicolas = new Voiture();
voitureNicolas.vitessePrivee = 50;

provoquera l’erreur de compilation désormais bien connue :

MaPremiereApplication.Voiture.vitessePrivee' est inaccessible en raison de son niveau de protection

Par contre, nous en avons profité pour définir la propriété Vitesse, de type int. Pour ceci, nous avons défini une partie de la propriété avec le mot clé get suivi d’un return vitessePrivee. Et juste en dessous, nous avons utilisé le mot clé set, suivi de vitessePrivee = value.

Ce que nous avons fait, c’est définir la possibilité de lire la propriété grâce au mot clé get. Ici, la lecture de la propriété nous renvoie la valeur de la variable privée. De la même façon, nous avons défini la possibilité d’affecter une valeur à la propriété en utilisant le mot clé set et en affectant la valeur à la variable privée.

Les blocs de code délimités par get et set se comportent un peu comme des méthodes, elles ont un corps qui est délimité par des accolades et dans le cas du get, elle doit renvoyer une valeur du même type que la propriété.

À noter que dans le cas du set, « value » est un mot clé qui permet de dire : « la valeur que nous avons affectée à la propriété ».

Prenons l’exemple suivant :

Voiture voitureNicolas = new Voiture();
voitureNicolas.Vitesse = 50;
Console.WriteLine(voitureNicolas.Vitesse);

La première instruction instancie bien sûr une voiture.

La deuxième instruction consiste à appeler le bloc de code set de Vitesse qui met la valeur 50 dans la pseudo-variable value qui est stockée ensuite dans la variable privée.

Lorsque nous appelons la troisième instruction, nous lisons la valeur de la propriété et pour ce faire, nous passons par le get qui nous renvoie la valeur de la variable privée.

Ok, c’est super, mais dans ce cas, pourquoi passer par une propriété et pas par une variable ? Même s'il parait que les variables ne doivent jamais être publiques …

Eh bien parce que dans ce cas-là, la propriété peut faire un peu plus que simplement renvoyer une valeur. Et aussi parce que nous masquons la structure interne de notre classe à ceux qui veulent l’utiliser.
Nous pourrions très bien envisager d’aller lire la vitesse dans les structures internes du moteur, ou en faisant un calcul poussé par rapport au coefficient du vent et de l’âge du capitaine (ou plus vraisemblablement en allant lire la valeur en base de données). Et ici, nous pouvons tirer parti de la puissance des propriétés pour masquer tout ça à l’appelant qui lui n’a besoin que d’une vitesse.

Par exemple :

private int vitessePrivee;
public int Vitesse
{
    get
    {
        int v = vitesseDesRoues * rayon * coefficient; // ce calcul est complètement farfelu !
        MettreAJourLeCompteur();
        AdapterLaVitesseDesEssuieGlaces();
        return v;
    }
    set
    {
        // faire la mise à jour des variables internes
        MettreAJourLeCompteur();
        AdapterLaVitesseDesEssuieGlaces();
    }
}

En faisant tout ça dans le bloc de code get, nous masquons les rouages de notre classe à l’utilisateur. Lui, il n’a besoin que d’obtenir la vitesse, sans s’encombrer du compteur ou des essuie-glaces.

Bien sûr, la même logique peut s’adapter au bloc de code qui permet d’affecter une valeur à la propriété, set.

Il est également possible de rendre une propriété en lecture seule, c’est-à-dire non modifiable par les autres objets. Il pourra par exemple sembler bizarre de positionner une valeur à la vitesse alors qu’en fait, pour mettre à jour la vitesse, il faut appeler la méthode AppuyerPedale(double forceAppui).

Pour empêcher les autres objets de pouvoir directement mettre à jour la propriété Vitesse, il suffit de ne pas déclarer le bloc de code set et de ne garder qu’un get. Par exemple :

public class Voiture
{
    private int vitessePrivee;
    public int Vitesse
    {
        get
        {
            // faire des calculs ...
            return vitessePrivee;
        }
    }
}

Ce qui fait que si nous tentons d’affecter une valeur à la propriété Vitesse depuis une autre classe, par exemple :

Voiture voitureNicolas = new Voiture();
voitureNicolas.Vitesse = 50;

Nous aurons l’erreur de compilation suivante :

La propriété ou l'indexeur 'MaPremiereApplication.Voiture.Vitesse' ne peut pas être assigné -- il est en lecture seule

Le compilateur nous indique donc très justement qu’il est impossible de faire cette affectation car la propriété est en lecture seule.
Il devient donc impossible pour un utilisateur de cette classe de modifier la vitesse de cette façon.

De même, il est possible de définir une propriété pour qu’elle soit accessible en écriture seule. Il suffit de définir uniquement le bloc de code set :

private double acceleration;
public double Acceleration
{
    set
    {
        acceleration = value;
    }
}

Ainsi, si nous tentons d’utiliser la propriété en lecture, avec par exemple :

Console.WriteLine(voitureNicolas.Acceleration);

Nous aurons l’erreur de compilation attendue :

La propriété ou l'indexeur 'MaPremiereApplication.Voiture.Acceleration' ne peut pas être utilisé dans ce contexte, car il lui manque l'accesseur get

Ce bridage d’accès à des propriétés prend tout son sens quand nous souhaitons exposer nos objets à d’autres consommateurs qui n’ont aucun intérêt à connaitre la structure interne de notre classe. C’est un des principes de l’encapsulation.

Les propriétés auto-implémentées :

Les propriétés auto-implémentées sont une fonctionnalité que nous allons beaucoup utiliser. Il s’agit de la définition d’une propriété de manière très simplifiée qui va nous servir dans la grande majorité des cas où nous aurons besoin d’écrire des propriétés. Dans ce tutoriel, nous l’utiliserons très souvent.

Ainsi, le code suivant que nous avons déjà vu :

private int vitesse;
public int Vitesse
{
    get
    {
        return vitesse;
    }
    set
    {
        vitesse = value;
    }
}

est un cas très fréquent d’utilisation de propriétés. Nous exposons ici une variable privée à travers les propriétés get et set. L’écriture du dessus est équivalente à la suivante :

public int Vitesse { get; set; }

Dans ce cas, le compilateur fait le boulot lui-même, il génère (dans le code compilé) une variable membre qui va servir à stocker la valeur de la propriété.

C’est exactement pareil, sauf que cela nous simplifie grandement l’écriture.

En plus, nous pouvons encore accélérer son écriture en utilisant ce qu’on appelle des « snippets » qui sont des extraits de code. Pour les utiliser, il suffit de commencer à écrire un mot et Visual Studio nous complète le reste. Un peu comme la complétion automatique sauf que cela fonctionne pour des bouts de code très répétitifs et très classiques à écrire.

Commencez par exemple à taper « prop », Visual Studio nous propose plusieurs extraits de code :

L'extrait de code pour créer une propriété auto-implémentée
L'extrait de code pour créer une propriété auto-implémentée

Appuyez sur tab ou entrée pour sélectionner cet extrait de code et appuyez ensuite sur tab pour que Visual Studio génère l’extrait de code correspondant à la propriété auto-implémentée. Vous aurez :

Image utilisateur

Ici, int est surligné et vous pouvez, si vous le souhaitez, changer le type de la propriété, par exemple string. Appuyez à nouveau sur tab et Visual Studio surligne le nom de la propriété, que vous pouvez à nouveau changer. Appuyez enfin sur entrée pour terminer la saisie et vous aurez une belle propriété auto-implémentée :

Image utilisateur

Vous avez pu remarquer qu’en commençant à taper « prop », Visual Studio Express vous a proposé d’autres extraits de code, par exemple « propfull » qui va générer la propriété complète telle qu’on l’a vue un peu plus haut.

D’autres extraits de code existent, comme « propg » qui permet de définir une propriété en lecture seule.

En effet, comme au chapitre précédent, il est possible de définir des propriétés auto-implémentées en lecture seule ou en écriture seule avec une écriture simplifiée. Dans le cas des propriétés auto-implémentées, il y a cependant une subtilité.

Pour avoir de la lecture seule, nous devons indiquer que l'affectation est privée, comme on peut le voir en utilisant l’extrait de code « propg ». Visual Studio Express nous génère le bout de code suivant :

public int Vitesse { get; private set; }

En positionnant une propriété d’écriture en privée, Visual Studio Express autorise la classe Voiture à modifier la valeur de Vitesse, que ce soit par une méthode ou par une propriété.

A noter que si nous n'avions pas mis private set et que nous avions simplement supprimé le set, alors la compilation aurait été impossible. En effet, il s’avère difficile d’exploiter une propriété auto-implémentée en lecture alors que nous n’avons pas la possibilité de lui donner une valeur. Ou inversement.

Alors, pourquoi nous avoir parlé de la possibilité de complètement supprimer la lecture ou l’écriture ? Ce n’est pas plus intéressant de toujours mettre la propriété en private ?

Si c’est une propriété auto-implémentée, évidemment que si. Par contre, si nous n’utilisons pas une propriété auto-implémentée et que nous utilisons une variable membre pour sauvegarder la valeur de la propriété, nous pourrons éventuellement modifier ou lire la valeur de la variable à partir d’une méthode ou d’une autre propriété.

Bref, maintenant que vous connaissez les deux syntaxes, vous pourrez utiliser la plus adaptée à votre besoin.

Voilà pour les propriétés.

À noter que quand nous avons beaucoup de propriétés à initialiser sur un objet, nous pouvons utiliser une syntaxe plus concise. Par exemple, les instructions suivantes :

Voiture voitureNicolas = new Voiture();

voitureNicolas.Couleur = "Bleue";
voitureNicolas.Marque = "Peugeot";
voitureNicolas.Vitesse = 50;

sont équivalentes à l’instruction :

Voiture voitureNicolas = new Voiture { Couleur = "Bleue", Marque = "Peugeot", Vitesse = 50 };

Les accolades servent ici à initialiser les propriétés au même moment que l’instanciation de l’objet.

En résumé
  • On utilise des classes pour représenter quasiment la plupart des objets.

  • On utilise le mot-clé class pour définir une classe et le mot-clé new pour l'instancier.

  • Une classe peut posséder des caractéristiques (les propriétés) et peut faire des actions (les méthodes).

Exemple de certificat de réussite
Exemple de certificat de réussite