4. Classes, méthodes et propriétés en C#

Le concept de classe est la base de tout langage de programmation orienté objet et a le pouvoir de définir les caractéristiques d’un ensemble d’objets qui ont des propriétés et effectuent les mêmes actions. En fait, elle représente tous les objets appartenant à une certaine classe.

Par exemple, pensez aux voitures : chaque voiture est différente d’une autre mais elles ont toutes quatre roues exécutent l’action de diriger ou freiner. Ces éléments communs en font un concept unique. Une classe.

Plus concrètement, on peut dire qu’une classe est une collection de variables, méthodes et propriétés. Aussi dans ce cas, C# reprend la syntaxe de Java pour construire une classe, dénommée class.

 public class Personne
{
    string mPrenom;
    string mNom;
    // Autres variables ...
 
    public Personne(string Prenom, string Nom)
    {
        // Définit les propriétés initiales de la classe.
        mPrenom = Prenom;
        mNom = Nom;
    }
 
    public void ImprimeMessage()
    { }
     
    private void Soutien()
    { }
}

Parfois, une classe est également identifiée comme un « type de données », en fait elle porte à la fois la représentation des données et les opérations de ces dernières, en fait le concept de classe est plus large.

Objets et Constructeurs

Nous pouvons considérer les instances d’une classe, c’est-à-dire les objets qui réalisent le concept de classe, comme des variables définies par un certain type de données.

 // Crée un objet p qui est une instance de la classe Personne
Personne p = new Personne("Luca", "Alice");

Pour chaque classe instanciée, un objet est créé et un constructeur de classe est appelé. Le constructeur, comme Java et C++, a le même nom de classe et ne renvoie aucune valeur (dans notre exemple, la méthode de public Personne). Dans VB .NET, cependant, le constructeur est défini dans une méthode déclarée comme Sub New.

Le constructeur est utilisé pour définir les propriétés que la classe doit avoir lors de sa création : dans notre exemple, lors de la création d’une instance de la classe Personne, ses variables mPrenom et mNom prennent les valeurs spécifiées dans l’argument du constructeur.

Les méthodes, ce sont quoi et comment les déclarer

Les méthodes permettent d’accéder aux objets pour les simuler, effectuer des actions ou de vérifier les comportements. Plus pragmatiquement ce sont des routines (fonctions ou procédures), voyons comment les déclarer.

Les méthodes d’une classe peuvent être définies comme public, private, protected ou internal (“Friend” dans Visual Basic .NET) : ces mots-clés sont généralement appelés modificateurs d’accès.

Avec le public, une routine devient accessible à toutes les instances de la classe. private, d’autre part, empêche que la routine soit visible en dehors de la classe dans laquelle elle est définie.

Si vous ne spécifiez pas le modificateur d’accès, private est la valeur par défaut. Par exemple, toujours en utilisant notre classe Personne :

 Personne p = new Personne("Luca", "Alice");
 
// Correct, ImprimeMessage est public
p.ImprimeMessage(); 
 
// Faux, Soutien est private, donc pas accessible
p.Soutien();

En déclarant une méthode de la classe Personne comme protected, elle ne sera visible que si nous définissons les classes héritées par Personne mais elle ne peut pas être utilisée dans le code où nous mettons des objets dans cette classe. L’hérédité sera traitée dans les prochaines leçons.

En pratique, protected ressemble à private, à la différence que la méthode est également visible pour les classes héritées du parent. Enfin, ce qui est déclaré comme internal n’est visible que dans l’ensemble de l’application. Pour le concept d’assembly, faites référence aux leçons dédiées à Visual Studio.

Après le modificateur d’accès de la méthode, vous devez spécifier le type de données renvoyé dans la déclaration.

Vous pouvez indiquer n’importe quel type de données: int, string, byte, etc. Vous pouvez également spécifier le nom d’une classe, car souvenez-vous qu’une classe est un type. Ce type de méthode correspond aux Function de VB.

Pour renvoyer la valeur, vous devez utiliser le mot-clé return, suivi de toute expression de même type que la valeur de retour de la méthode. Cette instruction provoque également la sortie de la méthode. Par exemple :

 public int Carre(int N)
{
  return N * N;
  // Tout code écrit ici ne fonctionnera pas.
}

En C#, une méthode qui renvoie une valeur doit nécessairement contenir le mot-clé return, sinon, lors de la compilation, vous obtiendrez une erreur.

Par contre, les fonctionnalités Visual Basic peuvent ne pas avoir le return : dans ce cas, la valeur de return est la valeur par défaut pour le type de données particulier.

Les méthodes qui ne renvoient pas de valeur, telles que ImprimeMessage() et Support() de l’exemple, ont un type void ; ils correspondent à Sub de Visual Basic. Vous pouvez toujours utiliser le mot de return dans une méthode void, ce qui dans ce cas a pour seul objectif de quitter la procédure : dans ce cas, return ne doit pas être suivi d’une expression.

Les propriétés

Une classe peut également contenir d’autres types de méthodes, appelées propriétés. Ce sont des routines particulières qui vous permettent de lire et / ou de définir les valeurs de certaines propriétés d’une classe. Ajoutez, par exemple, la propriété suivante à la classe Personne :

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

Cela permet de lire ou (ré) écrire variable mPrenom, sinon ce ne serait pas visible en dehors de la classe. Le get doit renvoyer la variable associée à la propriété. Ainsi, comme indiqué précédemment, il faut prévoir l’instruction return.

Le set est cependant exécuté lorsque vous changez la valeur de la propriété ; le mot clé value contient la nouvelle valeur à affecter. L’utilisation des propriétés est intuitive :

 Personne p = new Personne("Luca", "Alice");
 
// Affiche "Luca" (get)
Console.WriteLine(p.Prenom); 
 
// Définit le prénom "Pippo" (set)
p.Prenom = "Pippo";

De même, vous pouvez ajouter une propriété Nom.

Surement vous êtes en train de vous demander pourquoi vous devriez utiliser les propriétés quand vous pourriez simplement rendre public les variables mPrenom et mNom. Il est préférable d’avoir un membre de classe privé uniquement accessible via les propriétés lorsque vous devez contrôler les valeurs attribuées aux membres eux-mêmes.

Par exemple, supposons que nous voulions éviter d’entrer un nom ou un nom d’utilisateur vide : si nous définissons les variables mPrenom et mNom comme publiques, ce ne sera pas possible.

En fait, vous avez libre accès aux variables qui peuvent être définies sur n’importe quelle chaîne valide (y compris, par conséquent, la chaîne vide). Pour résoudre ce problème, définissez simplement les membres comme privés et modifiez la propriété Prenom comme suit :

 public string Prenom
{
  get { return mPrenom; }
  set
  {
    if (value == string.Empty)
      mPrenom = "(Aucun prénom)";
    else
      mPrenom = value;
  }
}

De même, la propriété Nom doit également être redéfinie.

string.Empty est un champ en lecture seule qui représente la chaîne vide. Si Prenom ou Nom est défini sur la chaîne vide, ce code les définit respectivement comme Aucun prénom et Aucun nom.

Nous notons que, pour obtenir un comportement cohérent de toute la classe, le constructeur doit également être modifié afin de vérifier les arguments.

Il est bon de définir des propriétés qui vous permettent de modifier les valeurs des variables utilisées par une classe, afin d’avoir plus de contrôle sur les données spécifiées plutôt que de vous donner un accès libre aux variables elles-mêmes.

Les propriétés peuvent également être en lecture seule si elles n’ont que le get, ou en écriture seule, si elles n’ont que le set.

Pour obtenir un comportement similaire en Java ou en C++, vous devez définir deux méthodes distinctes, appelées méthodes getter (pour récupérer la valeur) et setter (pour la définir).

Précédent : 3. Notre premier programme#                                                                 Suivant :  5. Méthodes statiques et namespaces