Programmation orientée objet avec .NET

Classes et objets du point de vue modélisation
     L'état d'un objet
     Le comportement d'un objet
     L'identité d'un objet
Classes et objets en C#
     Les classes
     Les membres d'une classe
          Les méthodes
          Les champs
          Les propriétés
     Les classes scellées
Les membres statiques et les membres d'instance
     Les champs statiques et d'instance
          Définitions
          Exemple
     Les méthodes statiques et d'instance
          Définitions
          Exemple
Le mot-clé this
     Définition
     Exemple

Cette partie traite de la programmation orientée objet avec la plate-forme .NET de Microsoft. Ici, nous ne développerons pas pas toutes les spécificités de la programmation orientée objet avec le langage C#. De nombreux liens vers les MSDN sont fournis à la fin de ce document. Nous allons utiliser le langage UML (Unified Modeling Language) pour illustrer les concepts de la programmation orientée objet. UML est un langage graphique de modélisation objet très utilisé pour modéliser des systèmes logiciels. Vous pouvez visiter le site de l'Object Management Group (OMG) (organisme qui s'occupe de la standardisation d'UML) si vous souhaitez en savoir plus sur UML. Commençons donc par donner une définition générale, qui est celle de la modélisation, des notions de classe et d'objet. Ensuite, nous appliquerons ces concepts en C#.

Classes et objets du point de vue modélisation

Définition générale d'une classe: une classe est la description abstraite d'un ensemble d'objets. Une classe est un type. Un entier est un type mais c'est un type simple. Une classe est un type complexe. Nous pouvons, par exemple, définir une classe Voiture. En comparaison avec un entier (type valeur), la notion de voiture est complexe puisqu'une voiture possède de nombreuses propriétés: couleur, quantité de carburant, puissance, etc.

Définition générale d'un objet: un objet est un représentant d'une classe. En programmation orientée objet, on parle d'instance au lieu d'utiliser le terme représentant. On dira donc qu'un objet est une instance d'une classe. Il s'agit d'une entité atomique. Un objet possède trois caractéristiques fondamentales: un état, un comportement et une identité.

L'état d'un objet

L'état d'un objet représente l'ensemble des valeurs des attributs de l'objet à un instant donné. L'état évolue au cours du temps. Par exemple, considérons une instance nommée maVoiture de la classe Voiture:

La couleur, la quantité de carburant et la puissance sont les attributs de l'objet maVoiture. Au cours de son déplacement, la valeur correspondant à la quantité de carburant diminue.

Le comportement d'un objet

Le comportement représente l'ensemble des compétences d'un objet. Un atome de comportement se nomme opération. Une opération se déclenche suite à une stimulation externe issue d'un autre objet. Concrètement, une opération est un message envoyé par un objet à un autre objet. Par exemple, une instance A d'une classe Ascenceur peut envoyer le message monter() à une instance C d'une classe Cabine. L'objet A demande donc à l'objet C de monter. Cela sous-entend que l'objet C est capable de monter.

L'identité d'un objet

Il n'y a pas grand chose à retenir sur l'idendité d'un objet. Il faut juste savoir que l'idendité d'un objet permet de distinguer cet objet sans ambiguïté. Chaque objet possède une identité attribuée de manière implicite à la création de l'objet.

Classes et objets en C#

[Référence sur le langage C#]
Pour faire fonctionner nos programmes C#, nous avons besoin du .NET Framework 1.1 qui est disponible sur la page de téléchargements. Pour écrire nos programmes, nous utiliserons un simple bloc-note.
N'hésitez pas à me contacter en cas de problèmes avec l'installation du .NET Framework.

Les classes

Du point de vue programmation, une classe représente l'implantation d'un type de données. Une classe C# se définit à l'aide du mot-clé class. L'exemple suivant représente la déclaration d'une classe nommée UneClasse.

using System;

class UneClasse
{
	// ici: déclaration des membres de la classe UneClasse.

	public static void Main()
	{
		// ici: déclaration des instructions du point d'entrée Main.
	}

	// ici: la délcaration des membres de UneClasse est également possible.
}						

Nous allons compiler ce programme élémentaire. Pour cela, il suffit d'ouvrir une nouvelle page du bloc-note, de copier le code ci-dessus et d'enregistrer le fichier avec l'extension .cs (uneclasse.cs, par exemple). Ouvrons ensuite une commande MS-DOS (dans le menu Démarrer, sélectionner Exécuter..., entrer le mot command). Attention, si vous suivez la procédure citée entre parenthèses, prenez soin de sélectionner d'abord la fenêtre qui contient le fichier à compiler. L'idéal est de faire une copie de la commande dans le répertoire qui contient les fichiers C# à compiler.
Entrons la ligne suivante dans la commande pour lancer la compilation: csc uneclasse.cs
Entrons ensuite le nom du fichier, sans l'extension .cs, pour exécuter le programme: uneclasse
Il ne se passe rien ?! C'est normal :-)

Les classes sur les MSDN

Les membres d'une classe

Une classe se construit à l'aide d'entités de différentes natures que l'on nomme membres de la classe.
Nous allons définir ces entités: les champs, les méthodes, les indexeurs, les événements, les propriétés et les types imbriqués.

Les membres d'une classe sur les MSDN

Les méthodes
La notion de méthode est assez proche de celle de fonction. La seule différence est qu'une méthode est appelée sur un objet d'une classe. Cela signifie donc qu'une méthode agit sur l'objet sur lequel elle est appelée.
Il existe deux méthodes particulières: le constructeur et le desctructeur.
Un constructeur (il peut en exister plusieurs) est automatiquement appelé lors de la construction d'un objet. Un constructeur permet, par exemple, d'initialiser un objet.
Le desctructeur est également appelé automatiquement pour la desctruction d'un objet.

Dans l'exemple suivant la méthode, FactureTotale() agit sur l'objet s1, instance de la classe Telephone

using System;

public class Telephone
{
	public decimal CoutForfait = 33.90M;		// Ils abusent !
	public decimal CoutCommunication = 7.20M;

	// Exemple de méthode de la classe Telephone
	public decimal FactureTotale()
	{
		return (CoutForfait + CoutCommunication);
	}

	public static void Main()
	{
		Telephone s1 = new Telephone(); 
		Console.Write("Cout total de la facture: ");
		Console.WriteLine(s1.FactureTotale());
	}
}						

Les les méthodes , les constructeurs et les destructeurs sur les MSDN.

Les champs
Un champ en C# est équivalent à un attribut du point de vue de la modélisation. Un champ peut être de n'importe quel type.
Un objet possède plusieurs champs valués. L'ensemble de ces valeurs représente l'état de l'objet.
Dans l'exemple de l'objet maVoiture de la classe Voiture, la quantité de carburant est representée par un champ de type entier et la couleur est representée par un champ de type Color.
Dans l'exemple suivant, nous déclarons une classe nommée Personne. Cette classe comporte deux champs nom et prenom de type chaîne de caractères et un champ naissance de type Date.

using System;

class Personne
{
	public static void Main()
	{
		string nom = "Dupond";
		string prenom = "Olivier";
		DateTime naissance = new DateTime(1967,06,20);
		string date = naissance.ToString("dd/MM/yyyy");

		Console.WriteLine("NOM\t\t\t" + nom);
		Console.WriteLine("PRENOM\t\t\t" + prenom);
		Console.WriteLine("DATE DE NAISSANCE\t" + date);
	}
}						

Résultat de l'exécution du programme:

Remarque: un champ de type valeur doit être initialisé avant l'utilisation de l'objet.

Un champ peut être initialisé, soit de manière déclarative (dans la classe), soit dans les constructeurs de la classe.
Dans l'exemple suivant, l'entier x est directement initialisé dans la classe UneClasse alors que l'entier y est initialisé dans l'unique constructeur de la classe.

using System;

class UneClasse
{
	short x = 12;
	int y;

	public UneClasse()	// Constructeur public de la classe UneClasse
	{
		y = 1;
	}

	public static void Main()
	{
		UneClasse obj = new UneClasse();
		Console.WriteLine("x.obj = " + obj.x);
		Console.WriteLine("y.obj = " + obj.y);
	}
}						

Résultat de l'exécution du programme:

Le mot-clé public devant le constructeur désigne le niveau de visibilité de celui-ci. La notion de niveaux de visibilité est définie dans la partie encapsulation.

Les champs sur les MSDN

Les propriétés
Une propriété est un membre qui permet d'accéder à l'état d'une instance, c'est-à-dire aux des champs de cette instance. L'accès se fait par des méthodes particulières que l'on nomme accesseurs. Une propriété peut contenir:

• soit un accesseur get qui permet un accès en lecture
• soit un accesseur set qui permet un accès en écriture
• soit les deux accesseurs get et set

Autrement dit, une propriété doit comporter au moins un accesseur.
Si la propriété ne définit qu'un accesseur get, on dit qu'elle est accessible en lecture seule.
De même, si la propriété ne définit qu'un accesseur set, on dit qu'elle est accessible en écriture seule.

L'accesseur get retourne un objet de même type que sa propriété.
Dans l'accesseur set, il est possible d'utiliser le mot-clé value. value représente le paramètre de l'accesseur set, utilisé pour l'assignation de la propriété.

Dans l'exemple suivant, nous définissons une propriété, de type entier, nommée xProp et munie des accesseurs get et set.
Comme la contrainte d'une propriété l'impose, la proprété xProp retourne un entier nommé x

using System;

class UneClasse
{
	private int x = 12;

	public int xProp
	{
		get
		{
			return x;
		}
		set
		{
			x = value;
		}
	}

	public static void Main()
	{
		UneClasse Cl = new UneClasse();
		Console.WriteLine("Cl.xProp = " + Cl.xProp);

		// modification de la valeur de x ==> appel de l'accesseur set
		Cl.xProp = 15;
		Console.WriteLine("Cl.xProp = " + Cl.xProp);

		// initialisation de y à x (i.e à 15) ==> appel de l'accesseur get
		int y = Cl.xProp;
		Console.WriteLine("y = " + y);
	}
}						

Résultat:

Les propriétés sur les MSDN

Nous reviendrons plus tard sur les indexeurs et sur les types imbriqués.

Les classes scellées

Une classe scellée est une classe dont on ne peut dériver. Une telle classe peut être une classe dérivée. Pour indiquer qu'une clase est scellée, on utilise le mot-clé sealed.

Les membres statiques et les membres d'instance

Dans une classe, on distingue deux catégories de membres:

• les membres statiques: ils appartiennent aux classes.
• les membres d'instance: ils appartiennent aux objets.

Le langage C# utilise le mot-clé static pour déclarer un membre statique.

Les champs statiques et d'instance

Définitions
Un champ statique:

• n'est pas associé à une instance particulière.
• est unique (une seule copie), quel que soit le nombre d'instances créées.

Un champ d'instance (non statique)

• appartient à une instance.
• est copié de telle sorte que chaque instance créée possède un champ d'instance distinct.

Exemple
Dans le programme suivant, nous déclarons un champ statique x de type entier et un champ y de type entier court. Nous tentons d'afficher la valeur des deux champs par l'intermédiaire d'un objet puis par l'intermédiaire de la classe UneClasse.

using System;

class UneClasse
{
	static int x = 4;
	short y = 12;

	static void Main()
	{
		UneClasse obj = new UneClasse();

		// OK: x statique ==> x appartient à la classe UneClasse
		Console.WriteLine("obj.x = " + UneClasse.x);

		// Erreur: x statique
		// ==> x n'est pas accessible par une instance de UneClasse (1)
		Console.WriteLine("obj.x = " + obj.x);

		// Erreur: y non statique
		// ==> y appartient à une instance de UneClasse  (2)
		Console.WriteLine("obj.y = " + UneClasse.y);

		// OK: obj est bien une instance de UneClasse
		Console.WriteLine("obj.y = " + obj.y);
	}
}						

Voici les erreurs que révèle la compilation:

(1) static.cs(16,34): error CS0176: Static member 'UneClasse.x' cannot be accessed with an instance reference; qualify it with a type name instead

(2) static.cs(19,34): error CS0120: An object reference is required for the nonstatic field, method, or property 'UneClasse.y'

Les champs statique et d'instance sur les MSDN

Les méthodes statiques et d'instance

Définitions
Une méthode statique:

• n'agit pas sur une instance particulière.
• ne peut pas contenir une référence this dans son corps.

Une méthode d'instance (non statique):

• agit sur une instance particulière.
• permet à cette instance d'être référencée par this.

Exemple
Dans le code suivant, nous déclarons une classe MaClasse qui définit une méthode statique Bonjour de type void et une méthode d'instance PrixTTC de type decimal. L'exemple montre qu'il n'est pas possible d'appliquer la méthode statique Bonjour à une instance de MaClasse.

using System;

class MaClasse
{
	private decimal PrixHT = 4;
	private decimal TVA = 19.6M;

	public static void Bonjour()
	{
		Console.WriteLine("Bonjour !");
	}

	public decimal PrixTTC()
	{
		return PrixHT * (1+TVA/100);
	}
}

class Principale
{
	public static void Main()
	{
		MaClasse mc = new MaClasse();

		// Erreur : Bonjour() est une méthode statique est non d'instance.
		mc.Bonjour();

		// OK
		MaClasse.Bonjour();

		// OK : PrixTTC est une méthode d'instance.
		decimal prixTTC = mc.PrixTTC();
		Console.WriteLine("Prix TTC : " + prixTTC);

	}
}						

Voici l'erreur tant attendue (nous avons également droit à une erreur de type CS0246):

staticmeth.cs(26,3): error CS0246: Le type ou le nom d'espace de noms 'mc' est introuvable (une directive using ou une référence d'assembly est-elle manquante ?)

staticmeth.cs(26,3): error CS0176: Le membre static 'MaClasse.Bonjour()' est inaccessible avec une référence d'instance ; qualifiez-le avec un nom de type

Les méthodes statique et d'instance sur les MSDN

Nous nous limitons pour l'instant aux champs et aux méthodes statiques. Vous pouvez consulter les MSDN pour obtenir des informations sur les autres membres statiques.

Le mot-clé this

Définition

Le mot-clé this (ou accès this) permet de faire référence à l'instance courante d'une classe. D'après le paragraphe précédent, une méthode statique ne peut pas faire référence à this.

Exemple

Une tâche très courante consiste à utiliser le mot-clé this dans le constructeur d'une classe afin d'accéder aux membres de celle-ci. C'est ce que nous illustrons dans le code suivant.
Nous déclarons une classe Personne qui contient deux champs privés nom et prenom de type chaîne de caractères, un constructeur public et une méthode publique Identite de type void.
Lorsqu'une instance p de Personne est créée, ses champs nom et prenom sont initialisés dans le constructeur de la classe. Dans ce cas particulier, this fait référence à l'objet p de telle sorte que nous pourrions remplacer this par p:

p.nom = n;
p.prenom = p;					

Notons que nous aurions pu donner le même nom aux champs et aux paramètres du constructeur. Par exemple, remplacer n par nom et p par prenom dans les paramètres du constructeur.
La méthode Identite se contente d'afficher le nom et le prénom associés à une instance de Personne.

using System;

class Personne
{
	private string nom;
	private string prenom;

	public Personne(string n, string p)
	{
		this.nom = n;
		this.prenom = p;
	}

	public void Identite()
	{
		Console.WriteLine("Nom: " + nom);
		Console.WriteLine("Prenom: " + prenom);
	}
}

class Principale
{
	public static void Main()
	{
		Personne p = new Personne("Paul", "Jean");
		p.Identite();
	}
}						

Le mot-clé this sur les MSDN

Dimanche 12 Juin 2005