Aller au menu - Aller au contenu

Icône Créer son premier objet

Par nico.pyright
Mise à jour : 02/02/2012
Difficulté : Intermédiaire Intermédiaire Creative Commons BY-NC-SA
22 955 visites depuis 7 jours, dont 648 sur ce chapitre classé 15/786
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#.
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

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 plus haut 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.
Retour en haut

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.

Une classe est une manière de représenter un objet. Le C# nous permet de créer des classes.


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 C# Express, la classe Program. Nous n’y avons pas fait trop attention, mais voilà à peu près à quoi elle ressemblait :

Code : C#
1
2
3
4
5
6
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 :

Image utilisateur


Visual C# 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.

Image utilisateur


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

Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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 C# 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 :

Code : C#
1
2
3
4
5
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 :

Code : C#
1
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.
Retour en haut

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 :

Code : C#
1
2
3
4
5
6
7
class Voiture
{
    void Klaxonner()
    {
        Console.WriteLine("Pouet !");
    }
}


Notez quand même l’absence du mot-clé static que nous étions obligés de mettre avant. 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 :

Code : C#
1
2
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 :

Code : C#
1
2
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 :

Code : C#
1
int valeurATrouver = new Random().Next(0, 100);


Ce qui peut en fait s’écrire :

Code : C#
1
2
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 :

Code : C#
1
2
Voiture voitureNicolas = new Voiture();
voitureNicolas.Klaxonner();


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


Code : Console
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 :



Code : C#
1
2
3
4
5
6
7
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 :



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
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 :



Code : C#
1
2
3
4
5
6
7
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 :



Code : C#
1
2
3
4
5
6
7
8
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 :



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
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 !

                

                
Retour en haut

            
                

                    

                        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 :



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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.




Notez d’ailleurs que la complétion automatique n’est pas proposée pour les méthodes inaccessibles.




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.

                

                
Retour en haut

            
                

                    

                        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, par exemple dans le code suivant :



Code : C#
1
2
3
4
5
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 :



Code : C#
1
2
3
4
5
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 :



Code : C#
1
2
3
4
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 :



Code : C#
1
2
3
4
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.




Notez ici qu’il s’agit bien de variables membres et non de vraies propriétés. En général, les variables d’une classe ne doivent jamais être publiques. Nous utiliserons rarement cette construction.





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 :



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
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 :



Code : C#
1
2
Voiture voitureNicolas = new Voiture();
voitureNicolas.vitessePrivee = 50;







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



Code : Console
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 :



Code : C#
1
2
3
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 :



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
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 :



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
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 :



Code : C#
1
2
Voiture voitureNicolas = new Voiture();
voitureNicolas.Vitesse = 50;







Nous aurons l’erreur de compilation suivante :

Code : Console
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 :



Code : C#
1
2
3
4
5
6
7
8
private double acceleration;
public double Acceleration
{
    set
    {
        acceleration = value;
    }
}







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



Code : C#
1
Console.WriteLine(voitureNicolas.Acceleration);







Nous aurons l’erreur de compilation attendue :

Code : Console
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 :



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
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 :



Code : C#
1
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 C# 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 C# nous propose plusieurs extraits de code :




Image utilisateur




Appuyez sur tab ou entrée pour sélectionner cet extrait de code et appuyez ensuite sur tab pour que Visual C# 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 C# 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 C# 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 C# express nous génère le bout de code suivant :



Code : C#
1
public int Vitesse { get; private set; }







En positionnant une propriété d’écriture en privée, Visual C# 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 :



Code : C#
1
2
3
4
5
Voiture voitureNicolas = new Voiture();

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







sont équivalentes à l’instruction :



Code : C#
1
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.




Note : cela parait évident, mais il est bien sûr possible d’accéder aux propriétés d’une classe depuis une méthode de la même classe.



                

                
Retour en haut

            
    

        

            
Q.C.M.

            
                

                    

                    Désignez le type qui n’est pas un objet :
                    
    
                        
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                    

                

            
                

                    

                    Combien puis-je créer de méthodes dans un objet ?
                    
    
                        
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                    

                

            
                

                    

                    Puis-je faire ceci ?



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
public class Program
{
    static void Main(string[] args)
    {
        Voiture voiture = new Voiture();
        voiture.vitesse = 5;
    }
}

public class Voiture
{
    int vitesse; 
}




                    
    
                        
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                    

                

            
                

                    

                    Puis-je faire ceci ?



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
public class Program
{
    static void Main(string[] args)
    {
        Voiture voiture = new Voiture();
        voiture.Rouler();
    }
}

public class Voiture
{
    public void Rouler()
    {
        Console.WriteLine(AfficherVitesse() + " km/h");
    }

    private string AfficherVitesse()
    {
        return "10";
    }
}




                    
    
                        
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                    

                

            
                

                    

                    Quel est l’extrait de code permettant de créer une propriété automatique ?
                    
    
                        
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                    

                

            
                

                    

                    Est-il possible de définir une propriété en lecture seule ?
                    
    
                        
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                                
  •  
    • 
                            
                    

                

            

            

            
Statistiques de réponses au QCM

        

    

    
Retour en haut




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).
    • 




    

        
            
            
        
    


    

        
            

                

                    
                    
                    
                

            

        
            Chapitre précédent
        
            Sommaire
        
            Chapitre suivant
        
    







    
Retour en haut



    
Partager

    


    


    

    
Retour en haut

    
            

                5 commentaires pour "Créer son premier objet"
                

                    Note moyenne :
                        3.05
                    / 4
                    (230 votes)
                    
                

            

        
        

            
              

                Pseudo
                Commentaire
              

            
            
              
                

                  
                    
                      Hors ligne 
                    
                      dadouvicc
                    
                  
                  
                    #
                    
                         Posté le 13/01/2012 à 23:31:20
                    
                    
                


                
                    

                
                
                    


    

    Avis : Décevant
        
    



    





                		
                
                    
                    Très bon tuto :) mais la, on entre dans le difficile, j'ai peur de ne plus comprendre, d'ailleurs, je ne comprend plus XD
                    
                
                

              
                

                  
                    
                      Hors ligne 
                    
                      Mandi
                    
                  
                  
                    #
                    
                         Posté le 09/03/2012 à 15:04:20
                    
                    
                


                
                    

                
                
                    

C'est en forgeant...
Avatar

    

    Avis : Bon
        
    



    





                		
                
                    
                    Bonjour et félicitations pour ce tuto!



Difficile exercice que d'expliquer la POO "simplement"  :p



Je viens du monde Java et je découvre les subtilités de base du C# avec ravissement. J'ai cependant un peu de mal à comprendre le fonctionnement des accesseurs et le concept des variables membres et des propriétés est un peu déroutant :euh:



Pouvez-vous m'apporter quelques éclaircissements sur la dernière partie concernant les propriétés auto-implémentées ?



Citation : nico.pyright


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







Cela signifie-t-il qu'au sein de la classe Voiture, n'importe quelle méthode (ou bloc de code) à la possibilité de "setter" la variable privée en passant par la propriété publique en lecture seule ?

Cela correspondrait alors à un setter privé en Java ?

L'utilisation d'une variable membre privée dans une classe interdit complètement l'accès à celle-ci même depuis la classe porteuse ?




Citation : nico.pyright


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é.







Quelle est cette (très  :D ) subtile subtilité ?

Est-ce le fait que le setter doive toujours apparaître, mais avec une visibilité privée ?




Citation : nico.pyright



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é.







Parlez-vous de la variable membre ou de la propriété ?

Est-il possible d'avoir des propriétés privées, ce que je traduirais en Java comme un attribut de classe ayant des getters et setters privés ?




Voilà, je sais que ça fait beaucoup de questions, mais faire les analogies avec le Java me permet de comprendre plus vite le fonctionnement du monde C# qui, avouons-le, a ses particularités  ^^ 



Merci pour ce tuto qui me permet de me mettre rapidement le pied à l'étrier dans mon nouveau travail !




                    
                        
SdZ Addict!

Non au langage SMS!!

                        
 

                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      nico.pyright
                    
                  
                  
                    #
                    
                         Posté le 09/03/2012 à 15:50:08
                    
                    
                


                
                    

                
                
                    


            Groupe : Auteurs
        


    





                		
                
                    
                    Bonjour et merci de votre lecture.

Je vais essayer de répondre à vos questions :)







Citation : Mandi
Bonjour et félicitations pour ce tuto!



Difficile exercice que d'expliquer la POO "simplement"  :p



Je viens du monde Java et je découvre les subtilités de base du C# avec ravissement. J'ai cependant un peu de mal à comprendre le fonctionnement des accesseurs et le concept des variables membres et des propriétés est un peu déroutant :euh:



Pouvez-vous m'apporter quelques éclaircissements sur la dernière partie concernant les propriétés auto-implémentées ?



Citation : nico.pyright


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







Cela signifie-t-il qu'au sein de la classe Voiture, n'importe quelle méthode (ou bloc de code) à la possibilité de "setter" la variable privée en passant par la propriété publique en lecture seule ?

Cela correspondrait alors à un setter privé en Java ?

L'utilisation d'une variable membre privée dans une classe interdit complètement l'accès à celle-ci même depuis la classe porteuse ?







Si vous définissez une variable ou propriété en privée sur une classe, alors n'importe quel autre membre de la classe (méthode, variable, constructeur, ...) aura accès à cette variable/propriété. Ce sont uniquement les autres classes qui ne pourront pas y accéder.

Citation : Mandi


Citation : nico.pyright


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é.







Quelle est cette (très  :D ) subtile subtilité ?

Est-ce le fait que le setter doive toujours apparaître, mais avec une visibilité privée ?







Exactement.

Citation : Mandi




Citation : nico.pyright



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é.







Parlez-vous de la variable membre ou de la propriété ?

Est-il possible d'avoir des propriétés privées, ce que je traduirais en Java comme un attribut de classe ayant des getters et setters privés ?









Je parle dans ce cas de la variable. Il est possible d'avoir des propriétés privées, oui tout à fait. Cela permet d'encapsuler des traitements internes, sans les exposer aux autres classes.

Citation : Mandi


Voilà, je sais que ça fait beaucoup de questions, mais faire les analogies avec le Java me permet de comprendre plus vite le fonctionnement du monde C# qui, avouons-le, a ses particularités  ^^ 



Merci pour ce tuto qui me permet de me mettre rapidement le pied à l'étrier dans mon nouveau travail !








J'espère avoir répondu à vos questions  :D 

Bon courage
                    
                        
Mon livre pour apprendre le C#

                        
 

                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      Nihak Ben
                    
                  
                  
                    #
                    
                         Posté le 13/04/2012 à 11:45:06
                    
                    
                


                
                    

                
                
                    

Avatar

    

    Avis : Très bon
        
    



    





                		
                
                    
                    Hep,



Quand j’exécute ce code :



Code : C#
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

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

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







Il ne se passe rien.  o_O 

Je n'arrive à afficher aucun Console.WriteLine :/
                    
                		
                

              
                

                  
                    
                      Hors ligne 
                    
                      nico.pyright
                    
                  
                  
                    #
                    
                         Posté le 13/04/2012 à 13:33:30
                    
                    
                


                
                    

                
                
                    


            Groupe : Auteurs
        


    





                		
                
                    
                    Il faut que tu instancies ton objet Voiture et que tu appelles la méthode Klaxonner()
                    
                        
Mon livre pour apprendre le C#

                        
 

                    
                		
                

              
            
        

        
            
Voir tous les commentaires