Programmation Orientée Objet

Introduction
La programmation orientée objet (POO), est un
paradigme de programmation
informatique élaboré par les Norvégiens Ole-
Johan Dahl et Kristen Nygaard au début des
années 1960 et poursuivi par les travaux de
l'Américain Alan Kay dans les années 1970.
• La POO utilise une approche différente de celle des
langages procéduraux.
• Comment certaines sociétés de l’industrie informatique
sont elles devenues si importantes et aussi vite ?
• Elles fabriquent en général de bonnes machines, vendues à
prix bas, dans une période où il existe une demande.
• Comment ont-elles pu construire tant de modèles aussi
rapidement, et comment ont-elles répondu aussi vite aux
changements que subit le marché de la micro-informatique ?
• Essentiellement, parce qu’elles ont sous-traité une
bonne partie de leurs travaux. Elles ont acheté des
éléments à des vendeurs réputés et se sont chargées
de l’assemblage des machines.(alimentations, disques
durs, cartes mères, etc.)
• Production rapide et réduction des coûts. Ces
constructeurs achetaient des «fonctionnalités
préconditionnées». (elles acquéraient quelque chose
qui possédait certaines propriétés (taille, poids, etc.) et
une certaine fonctionnalité (une sortie stabilisée, une
puissance électrique, etc.)
 Programmation orientée objet

La POO s’appuie sur la même idée.

• Un programme est constitué d’objets qui
interagissent (communiquent) afin de réaliser
une ou plusieurs tâches.
• Chaque objet possède certaines propriétés et
peut accomplir certaines opérations.
• C’est le temps et les fonctionnalités disponibles
qui décideront du fait que vous construisez un
objet ou que vous utilisez un autre disponible.
 Programmation orientée objet

• La POO propose une méthodologie de

programmation centrée sur les objets. Où un
objet peut être vu comme une entité regroupant
un ensemble de données et de méthodes de
traitement.
• Le programmeur Doit d’abord identifier les objets
qui doivent être utilisés (ou manipulés) par le
programme: on commence par décider quels
objets doivent être inclus dans le programme.
Va ensuite, écrire les traitements, en associant
chaque traitement à un objet donné.
 Définition
La Programmation Orientée Objet (POO) consiste à chercher
quels sont les objets en jeu dans l’application.
Un objet représente un concept, une idée ou toute entité du
monde physique, comme une voiture, une personne…
Pour chaque objet, le programmeur doit chercher à mettre
dans une même et unique structure les données et les
opérations qui lui sont associées.
Objet = Données + Traitements
Le concept Objet introduit plusieurs nouvelles notions : Les
classes, l’encapsulation, l’héritage, le polymorphisme…
 Les classes

C’est une notion fondamentale et totalement indispensable à la POO.

Une classe correspond à la définition d'un ensemble d'entités
partageant les mêmes attributs et les mêmes opérations.
Une classe contient des données membres (attributs) et des fonctions
membres (opérations sur données).
Déclaration
Pour créer une classe en c#, on utilise :
class Nom_Classe
{
Déclaration des données membres
Déclaration des fonctions membres…
}
 Données membres

Les données membres sont des variables déclarées à l’intérieur de la classe mais à l'extérieur des
méthodes et sont en relation avec la nature de l’objet représenté par la classe.
class Nom_Classe
{
Type_Donnée1 Nom_Donnée1 ;
Type_Donnée2 Nom_Donnée2 ;
…
}
Exemple :
Un rectangle est défini par une largeur et une longueur. Ces informations doivent être représentées à
l’intérieur de la classe et sont dites données membre de la classe Rectangle
class Rectangle
{
double largeur ;
double longueur ;
}
 Fonctions membres (méthodes) :

A l’intérieur d’une classe, le programmeur doit prévoir toutes les opérations

possibles sur un objet. Chaque opération sera représentée par une méthode.
Exemple :
Pour un rectangle, l’utilisateur pourra avoir besoin de :
- Calculer la surface
- Calculer le périmètre
-Afficher la longueur
- Afficher la largeur…
NB :
- Il n’est pas nécessaire de passer en argument des données membres d’une
classe à des fonctions membres de la même classe. Ces variables sont
automatiquement reconnues.
- Lorsque le nom d’un argument est identique à celui d’une donnée membre
de la classe, on utilise le mot clé this pour désigner la donnée membre :
this.Nom_Donnée_Membre ;
 Exemple :

class Rectangle
{
double largeur ;
double longueur ;
double périmètre ()
{
double p ;
p=(largeur+longueur)*2 ;
return p ;
}
}
 Accessibilité

L’accessibilité définit la visibilité des informations d’une classe

ou d’un membre par rapport aux autres membres et aux
autres classes
Les identificateurs d’accès sont :
public : Un attribut définit comme public sera accessible
depuis n'importe quel endroit.
private : Un attribut définit en tant que private ne sera
accessible qu'au sein de la classe dans laquelle il est définit. Il
s'agit du plus haut niveau de protection.
protected : Les attributs définis en tant que protected seront
accessibles au sein de la classe dans laquelle ils sont définis,
mais également au sein de toutes les classes dérivées.
. Pour gérer l’accessibilité, on associe à la déclaration d’un membre un identificateur d’accès :
A une classe
Identificateur_Accès class Nom_Classe
{…}
A une donnée membre
Identificateur_Accès Type_Donnée1 Nom_Donnée1
A une fonction membre void
Identificateur_Accès void Nom_Méthode (Type_Argument1 Arg1, Type_Argument2 Arg2…)
{...}
A une fonction membre avec valeur de retour
Identificateur_Accès Type_Retour Nom_Méthode (Type_Argument1 Arg1, Type_Argument2 Arg2…)
{...
return valeur ;
}
Remarques :
Par défaut, en C#, les attributs et méthodes possède le niveau de protection private, donc accessible
uniquement au sein de la classe dans laquelle ils sont définis.
 L’encapsulation
Les données sont déclarées privées et on ne
peux y accéder que via des méthodes
( Getters et Setters)
 Méthodes d’accès Getter

Ces méthodes permettent à l’utilisateur d’accéder, de l’extérieur, à des

données déclarées privées à l'intérieur d'une classe. Par convention les noms
de ces méthodes commencent par Get.
Les méthodes Getter seront du type de la donnée à retourner :
Identificateur_Accès Type_donnée_privée Nom_Getter()
{
return Donnée_privée ;
}
 Exemple
class Rectangle
{
private double largeur ;
private double longueur ;
double getLargeur()
{
return largeur ;
}
double getLongueur()
{
return longueur ;
}
}
NB:
Les Getters sont également appelés accesseurs
 Méthodes d’accès Setter

Ces méthodes permettent à l’utilisateur de définir, de

l’extérieur, des données déclarées privées à l'intérieur d'une
classe. Par convention les noms de ces méthodes
commencent par set.
Les méthodes set seront de type void :
Identificateur_Accès Void Nom_Setter (type_argument
argument)
{
Donnée_privée =argument ;
}
Rq : Le type de l'argument doit correspondre au type de la
données privée à définir.
 Exemple

class Rectangle
{
private double largeur ;
private double longueur ;
void setLargeur(double lar)
{
largeur =lar ;
}
void setLongueur(double lon)
{
longueur =lon ;
}
}
NB:
Les setters sont également appelés modificateurs
Remarque:
Une propriété en lecture seule doit disposer uniquement de getter
 Les propriétés

Les propriétés sont utilisées pour rendre accessible les getters et setters via un nom commun.
Le principe est très simple. Au lieu de posséder deux méthodes (getter et setter) séparées, les deux sont
regroupées dans notre propriété au sein de deux blocs get et set. Cette dernière peut être appelée
comme une simple méthode et Visual Studio décidera automatiquement s’il doit appeler le getter ou le
setter.
Prenons directement un exemple :
public int Age
{
get
{
return _age;
}
set
{
_age = value;
}
}
 Exercice
• Ecrire une classe Personne sachant que chaque
personne est identifiée par son nom, son
prénom, son sexe et son âge. Toutes ces données
doivent être déclarées privées.
• Ecrire les méthodes d ’accès à ces données
• Ecrire une méthode affiche() qui affiche ces
informations sous la forme suivante:
je suis……
J’ai……..
Je suis de sexe……
 Instantiation d'une classe

Une fois une classe créée, il n'est pas possible de l’utiliser directement. Il faut créer des objets se basant
sur cette classe. Le processus de création d’un objet à partir d’une classe est appelé instantiation d’un
objet ou création d’une instance d’une classe. Un objet est donc l'instance d'une classe et il est possible
de créer autant d’objets souhaités basés sur une classe
Pour créer une instance d'une classe :
Nom_Classe Référence_Objet ;
Référence_Objet=new Nom_Classe () ;
Ou
Nom_Classe Référence_Objet =new Nom_Classe ();
Exemple :
Pour créer deux rectangle R1 et R2 à partir de la classe Rectangle :
Rectangle R1 ;
R1=new Rectangle () ;
Rectangle R2 ;
R2=new Rectangle () ;
Ou
Rectangle R1 =new Rectangle () ;
Rectangle R2 =new Rectangle () ;
 Constructeur
C’est une méthode qui permet la création des
objets.
Il ya deux types de constructeur: par défaut et
par initialisation
 Constructeur par défaut
Toute classe dispose d’une méthode spéciale appelée constructeur par défaut. Cette
méthode est appelée automatiquement chaque fois qu’on souhaite utiliser la classe
correspondante. Le constructeur par défaut porte le même nom que la classe, ne peut
spécifier de valeur de retour et ne doit pas être private.
Le constructeur par défaut sert à inclure certaines valeurs d'initialisation (valeurs par
défaut). A l'appel de la classe, ces valeurs sont automatiquement chargées.
S'il n'existe pas de valeurs à décrire ou de paramètres d'initialisation, la définition du
constructeur par défaut n’est pas nécessaire. La création des objets se fait
implicitement par le compilateur mais il est conseillé d'expliciter le constructeur par
défaut dans chaque classe.
Identificateur_Accès class Nom_Classe
{
Public nom_classe () //Constructeur par défaut
{
...
}
}
 Constructeur par initialisation (par
assignation
Cette méthode spéciale permet d'appeler la classe et d'initialiser certaines ou toutes ses données membres. Comme le
constructeur par défaut, le constructeur par initialisation porte le même nom que la classe et ne doit être ni private, ni
void mais il reçoit en entrée des paramètres qui vont être affectés aux données membres et donc les différentes autres
méthodes vont utiliser ces valeurs pour effectuer les traitements.
Identificateur_Accès class Nom_Classe
{
Public nom_classe (type_Argument1 Arg1, Type_Argument2 Arg2,…)
{
Donnée_Membre1=Arg1 ;
Donnée_Membre2=Arg2 ;
…
}
…
}
Pour instancier une classe en utilisant le constructeur par initialisation :
Nom_Classe Référence_Objet =new Nom_Classe (param1,param2,…);
Remarque
Il est possible d’avoir plusieurs constructeurs d’initialisation dans la même classe. Le nom est le même mais le nombre
d’arguments à assigner sera différent.
 Exemple :

class Rectangle
{
private double largeur ;
private double longueur ;
Public Rctangle()
{}
public Rectangle (double lar, double lon)
{
largeur=lar ;
longueur=lon ;
}
}
 Remarque
• Si la classe ne contient pas de constructeurs,
un constructeur par défaut est créé
automatiquement; Mais dès que vous ajoutez
un constructeur par initialisation à votre
classe, si vous voulez utiliser le constructeur
par défaut, vous devez le créer même s’il est
vide
 Constructeur par copie
Un constructeur qui crée un objet à partir d’un autre.
Exemple :
public Article(Article a)
{
this.refe = a.refe;
this.des = a.des;
this.pu = a.pu;
this.qte = a.qte;
Console.WriteLine("test de constructeur par
copie");
 Destructeur

Il existe en C# un processus automatique qui s’occupe de la libération de la

mémoire alloué lors de l’utilisation d’une classe (Garbage Collector) mais si le
programme souhaite effectuer des opérations spécifiques en fin d’utilisation
d’une classe, elles sont insérées dans une méthode spécifique nommée
finalize.
Identificateur_Accès class Nom_Classe
{
public void finalize ()
{
…
}
…
}
Pour appeler le destructeur :
Référence_Objet.finalize();
 Exploitation des méthodes d'une
classe
Tout projet c# dispose d'une méthode main
dans sa classe principale qui est le point
d'entrée du programme où seront appelées
toutes les autres classes.
 Exemple :
class Rectangle
{
private double largeur ;
private double longueur ;
Rectangle() // Constructeur par défaut action vide
{}
Rectangle(double lar;double lon) // constructeur par initialisation
{
largeur=lar ;
longueur=lon ;
}
public void setLargeur(double largeur) // Méthode pour saisir
{
this.largeur=largeur ;
}
public void setLongueur(double longueur) // Méthode pour saisir
{
this.longueur=longueur ;
}
public double getLargeur()
{
return largeur ;
}
public getLongueur()
{
return longueur ;
}
public double surface ()
{
return (largeur*longueur) ;
}
public double périmètre ()
{
return ((largeur+longueur)*2) ;
}
public double diagonale ()
{
return ((largeur+longueur)/2) ;
}
}
 Programme Principal

class MenuPrincipal
{
static void Main (string []args)
{
Rectangle R1=new Rectangle(20,30); // Construction rectangle par initialisation
Rectangle R2=new rectangle ();
Console.writeLine("Introduire la largeur du rectangle :");
double Lar=double.parse(console.readLine()) ;
console.writeLine("Introduire la longueur du rectangle :");
double Lon= double.parse(console.readLine()) ;
R2.setLargeur(Lar) ; //Appel du setter. La valeur saisie Lar sera affectée à largeur;
R2.setLongueur(Lon) ; //Appel du setter. La valeur saisie Lon sera affectée à longueur;
Console.writeLine("Informations sur le premier Rectangle :");
Console.writeLine ("Largeur="+R1.getLargeur());
Console.writeLine ("Longueur="+R1.getLongueur());
Console.writeLine ("Surface="+R1.surface());
Console.writeLine ("Périmètre="+R1.périmètre());
Console.writeLine ("Diagonale="+R1.diagonale());
Console.writeLine ("Informations sur le deuxième Rectangle :");
Console.writeLine ("Largeur="+R2.getLargeur());
Console.writeLine ("Longueur="+R2.getLongueur());
Console.writeLine ("Surface="+R2.surface());
Console.writeLine ("Périmètre="+R2.périmètre());
Console.writeLine ("Diagonale="+R2.diagonale());
}
}
 Regroupement en paquets
(namespace) :
Il est possible de regrouper plusieurs définitions de classes
dans un groupe logique appelé namespace. Pour créer un
namespace, il suffit de commencer le fichier par l’instruction :
namespace Nom_namespace ;
Pour importer toutes les classes d’un namespace à l’intérieur
d’une classe :
using nom_ namespace ;

Remarque :
Toute classe sans indication de namespace appartient au
namespace par défaut.
 L'héritage

Super-Classes et Classes dérivées :

L'héritage est un concept important de la POO qui fait qu'une classe hérite des caractéristiques
(attributs) et du comportement (méthodes) d'une autre classe à laquelle elle rajoute d'autres éléments
ou même redéfinit certains de ses éléments (elle l'étend).
La classe qui hérite est dite classe dérivée, classe fille, sous-classe ou classe spécialisée. La classe de
laquelle dérive la classe fille est dite classe de base, classe mère ou super - classe.
Pour indiquer qu’une classe hérite d’une autre :
Public class Nom_Classe : Nom_classe_mère
{
…
}

Remarque :
C# n'accepte pas l'héritage multiple et donc les classes ne peuvent hériter que d’une seule classe à la
fois.
Pour appeler un constructeur de la classe mère on utilise le mot-clé base.
:base(); //Appel du constructeur par défaut
Ou
:base(argument1, argument2,…); // Appel d'un constructeur par initialisation
 Redéfinition d'une méthode ou d’une propriété

Pour redéfinir une méthode ou une propriété, on utilise le mot clé

new(ou override).
Supposons que l’âge d’un enseignant doit être supérieur à 23. Dans ce
cas il faut redéfinir la propriété Age comme suit :
public new int Age
{
get { return base.Age; }
set
{
if (value > 23) base.Age = value;
else Console.WriteLine("erreur");
}
}
Pour appeler une méthode de la classe mère on utilise la syntaxe suivante :
Base.nom_méthode() ;
Exemple :
public new void presente_Toi()
{
base.presente_Toi();
Console.WriteLine("sa note est: " + note);
}
Remarque:
Les attributs déclarés à l'aide de private dans la classe mère sont hérités par la classe
fille. Chaque instance de la classe fille en possède une copie qui ne peut être ni lue, ni
modifiée directement. Pour cela, il faut faire appel à un setter de la classe parent
sinon la variable doit être déclarée comme protected (visible à l'intérieur de la classe
et des classes dérivées et invisible aux autres classes).
 Exercice

On se propose de gérer les moyennes des étudiants d’une école dont

la formation est étalée sur deux ans.
En première année la moyenne générale (MG) est calculée sur la base des
moyennes du semestre1 (MS1) et semestre2 (MS2) soit :
MG = (MS1 + MS2)/2
En deuxième année l’étudiant achève sa formation par un projet de fin
d’étude qui sera noté (note_projet), ce qui change la règle de calcul de la
moyenne générale soit :
MG = (MS1 + MS2 + note_projet)/3
Le but de cette activité consiste à développer principalement la notion
d’héritage ; on va pas alourdir le programme par la saisie des notes
pour le calcul de la moyenne ( à chaque instance de la classe Etudiant
ou EtudiantSecondeAnnée on saisit directement la moyenne du
semestre1 (MS1) et la moyenne du semestre2 (MS2) respectivement
dans note_s1, note_s2.
Créez la classe Etudiant.
Cette classe possédera 5 propriétés :
int numéro;
char nom;
String niveau;
double note_s1;
double note_s2;

Créer la classe EtudiantSecondeAnnée qui hérite de la classe Etudiant et qui possède la propriété suivante :

double noteProjet;
- La classe Etudiant
Implémenter les getters et les setters
Implémentez la méthode affichage qui permet d’afficher les informations de l’étudiant
Implémentez la méthode calculer la moyenne de 1ere année.
Implémentez deux constructeurs d’initialisation
La classe EtudiantSecondeAnnée
Implémenter les getters et les setters
Implémentez la méthode affichage qui permet d’afficher les informations de l’étudiant
Implémentez la méthode calculer la moyenne générale.
Implémentez deux constructeurs d’initialisation.
 Les classes scellées

Le principe des classes scellées en C# est très

simple, il s'agit simplement de réduire les
fonctionnalités d'héritage. Une classe scellé, définie
avec le mot clé sealed est une classe que vous ne
pouvez pas dériver.
Syntaxe :
Sealed class nom_classe
{…}
 Polymorphisme
Un des concepts fondamentaux de la programmation Orientée objet. C'est la capacité
d'une entité à posséder plusieurs formes (mot grec signifiant plusieurs formes), la
possibilité de recevoir le même message mais d’agir de différentes façons. On
distingue généralement deux types de polymorphisme : Statique et dynamique.
Le polymorphisme statique :
C'est la possibilité d'avoir plusieurs méthodes portant le même nom. En c# les
méthodes ne sont pas identifiées par leurs noms uniquement mais plutôt par leurs
signatures (nom, type de retour, liste d'arguments, nombre d'arguments…).
Le polymorphisme dynamique
Il s'agit de la redéfinition de méthodes dans des classes héritant d'une classe de base.
Une méthode dans la classe fille a le même nom qu'une autre méthode dans la super
classe mais son implantation est différente.
A l'appel d'une méthode par un objet, c# cherche s'il existe une méthode qui a une
signature qui correspond à celle de la méthode appelée. Si c'est le cas la méthode est
appelée sinon le compilateur recherche dans la classe mère et ensuite dans la classe
mère de la classe mère et ainsi de suite jusqu'à atteindre la classe Object. Si aucune
méthode ayant cette signature n'est trouvée, il signale une erreur.
 Méthodes et classes abstraites

Méthodes abstraites
Une méthode abstraite n'est qu'une signature de
méthode sans corps de méthode. Elle n'est pas
directement exécutable et doit obligatoirement être
implantée dans une classe fille. Il s'agit de créer des
modèles génériques permettant de définir
ultérieurement des actions spécifiques.
Pour déclarer une méthode abstraite :
abstract Identificateur_Accès void|Type_retour
nom_méthode (argument1,argument2,…)
 Classes abstraites

Une classe abstraite est une classe qui ne peut pas être instanciée et
seule une classe dérivée qui redéfinit obligatoirement toutes les
méthodes abstraites de cette classe mère peut être instanciée.
Remarques :
Si une classe contient au moins une méthode abstraite, elle doit être
déclarée comme classe abstraite.
Une classe abstraite peut contenir des méthodes non abstraites.
Une classe abstraite peut ne contenir aucune méthode abstraite
Pour déclarer une classe abstraite :
abstract public nom_classe
{…}
 Exercice classe et méthode abstraite

Le directeur d'une entreprise de produits chimiques souhaite

gérer les salaires et primes de ses employés au moyen d'un
programme C#.
Un employé est caractérisé par son nom, son prénom, son âge
et sa date d'entrée en service dans l'entreprise.
Codez une classe abstraite Employe dotée des attributs
nécessaires, d'une méthode abstraite calculerSalaire (ce calcul
dépendra en effet du type de l'employé) et d'une méthode
getNom retournant une chaine de caractère obtenue en
concaténant la chaine de caractères "L'employé " avec le
prénom et le nom.
Dotez également votre classe d'un constructeur prenant en
paramètre l'ensemble des attributs nécessaires.
 Exercice classe et méthode abstraite
Calcul du salaire
Le calcul du salaire mensuel dépend du type de l'employé. On
distingue les types d'employés suivants :
Ceux affectés à la Vente. Leur salaire mensuel est le 20 % du
chiffre d'affaire qu'ils réalisent mensuellement, plus 400 DH
Ceux affectés à la Représentation. Leur salaire mensuel est
également le 20 % du chiffre d'affaire qu'ils réalisent
mensuellement, plus 800 DH.
Ceux affectés à la Production. Leur salaire vaut le nombre
d'unités produites mensuellement multipliées par 5.
Ceux affectés à la Manutention. Leur salaire vaut leur nombre
d'heures de travail mensuel multipliées par 65 dh.
Exercice classe et méthode abstraite(suite)
Codez une hiérarchie de classes pour les employés en
respectant les conditions suivantes :
La super-classe de la hiérarchie doit être la classe Employe.
Les nouvelles classes doivent contenir les attributs qui leur
sont spécifiques ainsi que le codage approprié des méthodes
calculerSalaire et getNom, en changeant le mot "employé"
par la catégorie correspondante.
Chaque sous classe est dotée de constructeur prenant en
argument l'ensemble des attributs nécessaires.
N'hésitez pas à introduire des classes intermédiaires pour
éviter au maximum les redondances d'attributs et de
méthodes dans les sous-classes
 Interface

Les interfaces sont très proches des classes abstraites.

Une interface définit un contrat que la classe qui
l'implémente doit respecter. Les interfaces ne peuvent
pas être instanciées.
Au lieu de parler de dérivation, on parle
d'implémentation.
Une interface ne possède que des méthodes.
Lorsqu'une classe implémente une interface, cette classe
doit obligatoirement implémenter toutes ses méthodes.
Les méthodes déclarées dans les interfaces ne possèdent
pas de définition.
La déclaration d'une interface se fait grâce au mot-
clé interface.
Contrairement à l'héritage, une classe peut
implémenter plusieurs interfaces. De même, une
classe peut hériter d'une autre classe tout en
implémentant une ou plusieurs interfaces. Pour
cela, il suffit de séparer les classes génériques et
interfaces par des virgules.
Exemple :
classStagiaire:Personne,IComparable,ICloneable
{…}
 Classification des données membres
et des méthodes

Données et Méthodes d'instance :

Dans une classe, il existe des attributs et des méthodes
spécifiques à chaque objet et donc qui changent de
valeur d'instance en instance. Une nouvelle copie est
créée de chacun de ces éléments à chaque nouvelle
instanciation de l'objet. Ces éléments sont dits d'instance.
Exemple :
La largeur et la longueur du rectangle varient de rectangle
en rectangle. Ce sont des variables d'instance.
 Données et Méthodes de classe

Variables de classe
Il existe des situations où une variable déclarée dans une
classe doit garder la même valeur pour toutes les instances de
cette classe. Dans ce cas toute modification de l'attribut sera
reconnue par toutes les instances de la classe. Ces variables
sont dites variables de classe ou statiques.
Pour indiquer qu'un attribut est de classe :
Modificateur_accès static Type_Données nom_Variable ;
Les variables de classes ne dépendent pas des instances de
classes et donc elles sont accessibles sans avoir besoin
d'instancier la classe :
Nom_Classe.Nom_Variable_de_Classe
 Méthode de classe

Une méthode de classe est une méthode dont les résultats et les
actions ne varient pas d'instance en instance.
Pour indiquer qu'une méthode est de classe :
Modificateur_accès static void|Type_Données
nom_Méthode(Argument1, Argument2,…)
Comme pour les variables de classe, pour utiliser une méthode de
classe :
Nom_Classe.Nom_Méthode_de_Classe(Argument1, Argument2,…)
Exemple
Pour utiliser la méthode sqrt qui appartient à la classe Math, on a pas
besoin d'instantier la classe Math parce qu'il s'agit d'une méthode
static et ainsi on écrit directement console.writeLine(Math.sqrt(9)).
 Exercice

Ecrivez une classe Livre avec les attributs suivants: titre, auteur, prix,
annee.
La classe Livre doit disposer des constructeurs suivants :
Livre(), Livre(titre), Livre(titre, auteur), Livre(titre, auteur, prix),
Livre(titre, auteur, prix, annee), Livre(Livre).
La classe Livre doit contenir des accesseurs et mutateurs pour les
différents attributs.
La classe livre doit aussi contenir une méthode afficher() pour afficher
les attributs des livres. Une méthode compter() pour avoir le nombre
des instances créées et une méthode type() qui va prendre 1 si le
prix de livre <100 et la valeur 2 si le 100<=prix< =500 et 3 si
500<prix.
Ecrivez aussi une classe de testLivre afin de tester la classe Livre
 Gestion des exceptions
Introduction
De nombreuses fonctions C# sont susceptibles
de générer des exceptions, c'est à dire des
erreurs. Lorsqu'une fonction est susceptible de
générer une exception, le programmeur devrait
la gérer dans le but d'obtenir des programmes
plus résistants aux erreurs : il faut toujours
éviter le "plantage" sauvage d'une application.
L’instruction Try Catch permet de traiter les erreurs qui
peuvent se produire dans un bloc d’instruction
try
{….//Bloc d’instruction. En cas d’erreur le bloc catch le plus
adapté traitera l’erreur
}
catch (….)
{….}
catch(….)
{… }
finaly
{Code à exécuter dans tous les cas }
• Chaque bloc Catch permet de traiter une
catégorie d’exception.
• Les blocs Catch ne seront exécutés que s’il y a
une erreur dans le bloc d’instructions.
• Le bloc finaly est toujours exécuté qu’il y ait
ou qu’il n’y ait pas d’erreur. (Bloc facultatif)
 Les exceptions personnalisées
On reprend l’exemple de la classe Personne

class Personne
{
private string nom;
private string prenom;
private int age;

private static int nbPersonnes;

public Personne()
{
nbPersonnes++;
}
public Personne(string nom,string prenom, int age)
{
this.nom = nom;
this.prenom = prenom;
this.Age = age;
nbPersonnes++;
}
}
public Personne(Personne p)
{
nom = p.Nom;
prenom = p.Prenom;
Age = p.Age;
nbPersonnes++;
}

public int Age

{
get { return this.age; }
set {age = value; }
}
public string Nom
{
get { return this.nom; }
set { this.nom=value; }

}
public string Prenom
{
get { return this.prenom; }
set { this.prenom = value; }
}
public static int NbPersonnes
{
get { return nbPersonnes; }
}

public void afficher()

{
Console.WriteLine("nom: " + nom + "\tprenom: " + prenom + "\tage: " + Age);
}
}
}
L’âge d’une personne doit être positif. Pourtant si vous attribuez une valeur négative à l’âge d’une
personne, cette valeur sera acceptée.
Si vous souhaitez générer une exception lors de la saisie d’un âge négatif,
vous devez créer vos propres classes d'exceptions par une dérivation à partir
de la classe Exception. Par exemple, le code suivant crée une classe
ErreurAgeException que vous pouvez lever si, par exemple, l’âge donné pour
une nouvelle personne n'est pas valide. Le constructeur de classe pour votre
exception affiche un message d’erreur indiquant le type d’erreur.

class ErreurAgeException:Exception
{
public ErreurAgeException()
{
Console.WriteLine("Erreur: Age négatif");
}
}
Il faut par la suite indiquer là où l’exception doit être levée en utilisant le mot clé throw. Dans notre cas,
une exception de type ErreurAgeException doit être levée au niveau du constructeur de la classe
personne (si l’utilisateur essaye de créer une personne avec un âge négatif) ou au niveau du setter de
l’attribut âge (si l’utilisateur essaye d’attribuer un âge négatif à une personne)

Il faut donc modifier le constructeur comme suit :

public Personne(string nom,string prenom, int age)
{
// si l’age est négatif on declenche une exception
if (age < 0) throw new ErreurAgeException();
else
{
this.nom = nom;
this.prenom = prenom;
this.Age = age;
nbPersonnes++;
}
}
De même, il faut modifier la propriété Age comme suit :
public int Age
{
get { return this.age; }
set
{
if (value < 0) throw new ErreurAgeException();
else age = value;
}
}
Testons maintenant la classe ErreurAgeException
static void Main(string[] args)
{
Personne p = new Personne("asri", "yassine",23);
p.afficher();

Console.WriteLine("donner l'age");
p.Age = int.Parse(Console.ReadLine());

p.afficher();
Console.Read();
}

On remarque que si l’utilisateur saisit un âge négatif l’exception suivante se produit

Pour gérer cette exception, il faut utiliser la clause try/catch, et donc le code devient :

static void Main(string[] args)

{
Personne p = new Personne("asri", "yassine",23);
p.afficher();

Console.WriteLine("donner l'age");
try
{
p.Age = int.Parse(Console.ReadLine());
}
catch (ErreurAgeException e)
{
Console.WriteLine(e.Message);
}
p.afficher();
Console.Read();
}
 Exercices
Exercice 1 :
Ecrire un programme C# qui permet de contrôler la saisie d’une note entre 0
et 20.
Exercice 2 :
Ecrire la méthode int moyenne(string[] listeDeNombres) dans la classe
Traitement qui prend en argument un tableau de chaînes de caractères. On
veut que toutes les chaînes qui ne comprennent pas des nombres entiers
soient éliminées du calcul et ne soient pas prises en compte pour calculer la
moyenne (on ne divise donc pas par listeDeNombres.length, mais par le
nombre de nombres entiers contenus dans ce tableau).
Exercice 3:
On veut maintenant que la méthode moyenne vue à l'exercice précédent lève
une exception de type TableauIncorrect si le tableau listeDeNombres passé en
argument de la méthode comprend des valeurs 'null'.
Ecrire la classe d'exception TableauIncorrect et modifier la méthode moyenne
pour qu'elle lève cette exception si nécessaire.
 Les tableaux
Tableaux unidimentionnels :
on déclare un tableau à une seule dimension:
type[] nom = new type[capacité];
un tableau ne peut contenir que des éléments de même type.
Exemple1 : si vous voulez que votre tableau puisse stocker 20 valeurs :
int[] tableau = new int[20];
Déclaration et initialisation d’un tableau:
Exemple2: int[] tableau = new int[5] { 1, 5, 2, 1, 3 };
Pour accéder à un élément d'un tableau, la syntaxe est la suivante :
tableau[index] = valeur;
 Exemple de tableau unidimentionnel

string[] tableau = new string[5];

for (int x = 0; x < tableau.Length; ++x)

{
Console.Write("Veuillez entrer le mot " + (x + 1) + " : ");
tableau[x] = Console.ReadLine();
}

for (int x = 0; x < tableau.Length; ++x)

Console.Write(tableau[x] + " ");

Console.Read();
 Les tableaux multi-dimensionnels

• Il est également possible de travailler avec des

tableaux à plusieurs dimensions. Voici la
déclaration d'un tableau à deux dimensions :
type[,] nom = new type[capacité1, capacité2];
 Exemple
string[,] tableau = new string[2, 5];

for (int y = 0; y < 2; ++y)

{
for (int x = 0; x < 5; ++x)
{
Console.Write("Veuillez entrer le mot [" + y + ", " + x + "] : ");
tableau[y, x] = Console.ReadLine();
}
}

for (int y = 0; y < 2; ++y)

for (int x = 0; x < 5; ++x)
Console.Write(tableau[y, x] + " ");

Console.Read();
 Tableaux d'objets

• Créer un tableau d'objets, plutôt qu'un

tableau de types de données simples tel que
des entiers, est un processus bipartite. En
premier lieu, vous déclarez le tableau, puis,
vous devez créer les objets qui sont stockés
dans le tableau. Cet exemple crée une classe
qui définit un CD audio. Il crée ensuite un
tableau qui stocke 20 CD audio.
class CD
{
private string album;
private string artist;

public string Album

{
get {return album;}
set {album = value;}
}
public string Artist
{
get {return artist;}
set {artist = value;}
}
}
class Program
{
static void Main(string[] args)
{
CD[] cdLibrary = new CD[20];
for (int i=0; i<20; i++)
{
cdLibrary[i] = new CD();
}

cdLibrary[0].Album = "See";
cdLibrary[0].Artist = "The Sharp Band";
}
}
 La classe Array
Cette classe fournit plusieurs méthodes utiles permettant la manipulation d’un tableau, telles que Sort
et Reverse
Exemple:
public static void Main(string []args)
{
// Créer un tableau de string de taille 5
string[] Noms = new string[5];
// Lire les noms de 5 employés
System.Console.WriteLine("Entrer les noms de 5 emplyés:");
for (int i = 0; i < Noms.Length; i++)
{
Noms[i] = Console.ReadLine();
}
// Afficher les éléments du tableau saisi
Console.WriteLine("\nle tableau siasi:");
foreach (string nom in Noms)
{
Console.Write("{0} ", nom);
}
// Inverser le tableau
Array.Reverse(Noms);
// Afficher le tableau inversé
Console.WriteLine("\n\nLe tableau dans l’ordre inverse:");
foreach (string nom in Noms)
{
Console.Write("{0} ", nom);
}
// Trier le tableau
Array.Sort(Noms);
// Afficher le tableau trié
Console.WriteLine("\n\nLe tableau trié:");
foreach (string nom in Noms)
{
Console.Write("{0} ", nom);
}
}
}
Il existe d’autres méthodes dont les plus utilisées sont dans cet exemple:
class Program
{
static void Main(string[] args)
{
Client[] t = new Client[3];
t[0] = new Client("Alami", "ali", 2, 16);
t[1] = new Client("Alami", "fati", 2, 16);
t[2] = new Client("salmi", "ahmed", 4, 17);

// afficher tous les éléments du tableau t

foreach (Client a in t)
Console.WriteLine(a.ToString());
Client c = new Client("Alami", "fati", 2, 16);
// chercher la position de la première occurrence de c dans le tableau t
int i = Array.IndexOf(t, c);
Console.WriteLine("la position de c est: " + i);
// chercher la position de la dernière occurrence de c dans le tableau t
i = Array.LastIndexOf(t, c);
Console.WriteLine("la position de c est: " + i);
Client[] T = new Client[3];
// copier 3 éléments du tableau t dans T
Array.Copy(t, T, 3);
//copier t dans T à partir de la position 0
t.CopyTo(T, 0);
// redimensioner le tableau T
Array.Resize(ref T, 2);
foreach (Client a in T)
Console.WriteLine(a.ToString());
Console.Read();
}
}
Les tableaux présentent des limites:
La longueur du tableau est fixe.
La manipulation est difficile (une seule
méthode)
Si je décide d’enlever un objet, sa case reste
vide(T[0]=null)
Pas de possibilité d’insertion à une position p…
 Les collections

Une collection est une suite finie d’éléments S1,

S2,… , Sn. Il existe différents types de collections.
La différence entre ces collections réside dans la
nature des éléments à stocker et dans les
moyens d’accès et de manipulation de ces
structures.
 La collection ArrayList

Un Arraylist est une collection d’éléments non

triée. Sa taille est dynamique elle change
automatiquement en fonction du nombre
d’éléments stockés. La suppression, l’ajout et la
modification sont assez simple.
Déclaration
Using System.Collections;
…
ArrayList AL = new ArrayList();
Pour ajouter un élément à la fin
ArrayList AL = new ArrayList();
..
AL.add(Objet);
Pour ajouter un élément à une certaine position
ArrayList AL = new ArrayList();
..
AL.insert(position,Objet);
Pour supprimer un élément :
ArrayList AL = new ArrayList();
..
AL.remove(Objet);

Pour supprimer un élément à une position :

ArrayList AL = new ArrayList();
..
AL.removeAt(position);
Pour parcourir un Arraylist
Méthode1 :
ArrayList AL = new ArrayList();
..
for (i=0;i<=AL.count-1;i++)
{
//l'élément à la position I est AL[i]. Un cast est nécessaire pour récupérer l'objet
}
Méthode2 :
ArrayList AL = new ArrayList();
..
foreach (Object x in AL)
{//Traitement de Objet
}
Pour vider un Arraylist
ArrayList AL = new ArrayList();
..
AL.clear();
 Trier une collection ArrayList
ArrayList AL = new ArrayList();
..
AL.sort();
Si la collection Arraylist contient des données de type primitif
(int, string,…), les données sont triées automatiquement par
l'instruction sort si par contre elle contient des données
complexes, une erreur est déclenchée.
En fait la collection ArrayList fait le tri en faisant appel à la
méthode compareTo() pour comparer les éléments. Cette
méthode vient de l'interface système IComparable. Elle est
implémentée d'office pour les types primitifs. Pour exécuter
une opération de tri sur les types complexes, il faut
l'implémenter pour l'objet complexe concerné.
 Exemple
class Personne :IComparable
{
public int CompareTo(object obj)
{
Personne Compare = (Personne)obj;
int result = this.age.CompareTo(Compare.age);
if (result == 0)
result = this.age.CompareTo(Compare.age);
return result;
}
private string nom;

public string Nom

{
get { return nom; }
set { nom = value; }
}
private int age;
public int Age
{
get { return age; }
set { age = value; }
}
public Personne(string nom, int age)
{
this.nom = nom;
this.age = age;
}
public override string ToString()
{
return "nom:" + nom + "\tage:" + age;
}
static void Main(string[] args)
{
Arraylist al = new Arraylist();
Personne p1 = new Personne("brahim",20);
Personne p2 = new Personne("ahmed", 16);
al.Add(p1);
al.Add(p2);
al.Sort();
foreach (Personne p in al)
Console.WriteLine(p);
Console.Read();
}
}
 Les List<T>

Représente une collection fortement typée d'objets.

C’est à dire que tous les objets sont de même type et le
type est déterminé lors de la déclaration de la collection.
Using System.Collections.Generic ;
…
List<Type>Ref_Collection = new List<Type>();

Cette collection est manipulée exactement comme un

ArrayList sauf qu’on a plus besoin de faire les casts
d’objets puisque le système reconnait les types des objets
contenus dans la collection.
 Les HashTable

Un HashTable représente une collection de pair clé-valeur. Sa

taille est dynamique elle change automatiquement en
fonction du nombre d’éléments stockés. La suppression,
l’ajout et la modification sont assez simple.
Déclaration
Using System.Collections;
…
HashTable HT = new HashTable();
Remarque :
La clé est unique. Elle ne peut pas être nulle alors que la
valeur peut l’être.
Pour ajouter un élément à la fin
HashTable HT = new HashTable();
…
HT.add(Clé,Valeur);
Pour parcourir les clés :
HashTable HT = new HashTable();
…
foreach (Type_Clé X in HT.keys)
{//Traitement sur X }
Pour parcourir les valeurs :
HashTable HT = new HashTable();
…
foreach (Type_Valeur X in HT.values)
{//Traitement sur X }
Pour parcourir la liste des couples d’un Hashtable :
HashTable HT = new HashTable();
…
foreach (DictionaryEntry X in HT)
{//Traitement sur X.value ou X.key }
Pour supprimer un élément :
HashTable HT = new HashTable();
…
HT.remove(key)
Pour atteindre un élément :
HashTable HT = new HashTable();
…
Object Obj=HT[key]
Pour vérifier si une clé existe ou non :
HashTable HT = new HashTable();
…
if (HT.ContainsKey(key) // retourne true si la clé existe et false sinon
{…}
 Exemple

Hashtable ht = new Hashtable();

ht.Add(1, "said");
ht.Add(2, "nabil");
ht.Add(3, "ikram");
ht.Add(4, "oussama");
foreach (DictionaryEntry myEntry in ht)
{
Console.WriteLine("Key: " + myEntry.Key + " valeur: " +
myEntry.Value);
}
 Les Dictionary<TKey,TValue>

Représente une collection à double entrée

fortement typée.
Dictionary<TKey,Tvalue> Ref_Collection = new
Dictionary<TKey,Tvalue> ();

Cette collection est manipulée exactement comme

un HashTable sauf qu’on a plus besoin de faire les
casts d’objets puisque le système reconnait les
types des objets contenus dans la collection.
• La spécificité de Dictionary<> est qu’il n’utilise
plus un objet DictionaryEntry pour manipuler
nos couples clé/valeur, mais le type générique
KeyValuePair.
Exemple:
Dictionary<int, string> Dico = new Dictionary<int, string>();
Dico.Add(0, "Premier");
Dico.Add(1, "Deuxième");
Dico.Add(2, "Troisième");
foreach (KeyValuePair<int, string> k in Dico)
Console.WriteLine(k);
 Exercice
Un fournisseur a un numéro, une raison sociale, un téléphone et une adresse.
Ecrire une classe fournisseur qui dispose de propriétés, constructeurs et
d’une méthode afficher qui affiche les informations sur le fournisseur.
Ajouter à la classe Fournisseur une méthode qui retourne le nombre de
fournisseurs créés et apporter les modifications nécessaires à cette classe
On souhaite créer des procédures de mise à jour des fournisseurs. Les
fournisseurs seront stockés dans un objet HashTable avec comme clé le
numéro. Ecrire le code correspondant aux différentes procédures:
- Ajouter
- Supprimer
- Modifier
- Rechercher
- AfficherListeFournisseurs
- AfficherNombreFournisseursCréés
 Collection SortedList

• Une collection SortedList est une collection de

paires clé/valeur. Elle ressemble au HashTable
et est traitée de la même manière mais les
entrées sont triées par les clés. Si la clé est de
type primitif c’est automatique mais si les clés
sont des objets complexes il faut que la
méthode Compare de l’interface IComparer
soit implémentée pour les classes utilisées.
 Exemple
SortedList sorted = new SortedList();
sorted.Add("A", "Premier");
sorted.Add("C", "Troisième");
sorted.Add("B", "Second");
sorted.Add("F", "Sixième");
sorted.Add("E", "Cinquième");
sorted.Add("D", "Quatrième");
foreach (DictionaryEntry e in sorted)
Console.WriteLine(e.Key + " : " + e.Value);
Console.WriteLine("Taille : {0}, Capacité :{1}", sorted.Count,
sorted.Capacity);
sorted.TrimToSize();
Console.WriteLine("Taille : {0}, Capacité :{1}", sorted.Count,
sorted.Capacity);
 La collection SortedList<TKey,TValue>
La collection SortedList<TKey,TValue> est la version générique
correspondant à la collection SoretedList.
Exemple:
SortedList<string, string> s = new SortedList<string, string>();
s.Add("A", "Premier");
s.Add("C", "Troisième");
s.Add("B", "Second");
s.Add("F", "Sixième");
s.Add("E", "Cinquième");
s.Add("D", "Quatrième");
foreach (KeyValuePair<string, string> k in s)
Console.WriteLine(k);
 Les énumérations

• Une énumération va nous permettre de créer

notre propre type de variable afin d’en
restreindre les valeurs possibles. Dans
l’exemple suivant, nous allons prendre
l’exemple des jours de la semaine.
• Déclaration et initialisation
Premièrement, nous allons créer l’énumération
« Jours » grâce au mot clé «enum» (Par
convention, le nom d’une énumération est
souvent écrit en PascalCase).
Exemple :
enum Jours { lun, mar, mer, jeu, ven, sam, dim };
Utiliser une énumération
Exemple :
class Program
{
enum Jours { lun, mar, mer, jeu, ven, sam, dim };
static void Main(string[] args)
{
Jours jourDeStage; //variable de type "Jours"
jourDeStage = Jours.jeu;
Console.WriteLine(jourDeStage);
Console.ReadLine();
}
}
N.B:la déclaration de « Jours » se faisait hors de la méthode main.
 Autre remarque

les membres d’une énumération peuvent également être appelés avec leur numéro:
Exemple :
class Program
{
enum Jours { lun, mar, mer, jeu, ven, sam, dim };
static void Main(string[] args)
{
Jours jourDeStage;
jourDeStage = (Jours)0;
Console.WriteLine(jourDeStage);
Console.ReadLine();
}
}
(Jours)0 équivaut à lundi, (Jours)1 équivaut à mardi etc.
 Dernière remarque
on peut forcer l’attribution d’un numéro à un membre
Dans l’exemple suivant nous allons attribuer la valeur 1 à lundi, au lieu de 0, sa valeur
par défaut :
Exemple :
class Program
{
enum Jours { lun=1, mar, mer, jeu, ven, sam, dim };
static void Main(string[] args)
{
Jours jourDeStage;
jourDeStage = (Jours)3; //équivaut donc à mercredi.
Console.WriteLine(jourDeStage);
Console.ReadLine();
}
}
 Les structures

Une structure va nous permettre de rassembler plusieurs

types de donnée dans un groupe plus grand. Une structure
ressemble un peu à une classe mais une structure est du type
valeur à la différence des classes qui sont de type référence.

Déclaration et initialisation
Nous allons prendre l’exemple d’un coureur, un coureur a un
nom, un prénom ainsi qu’un numéro de dossard. Nous allons
dons créer la structure « Coureur » qui va contenir ses
champs. Nous déclarons la structure en dehors du main mais
nous déclarons les différents champs en « public » afin que
ceux-ci soient accessibles dans le main.
 La sérialisation
La sérialisation est le processus de conversion d'un objet en un flux d'octets.
Elle permet d’enregistrer l’état d’un objet pour pouvoir le recréer
ultérieurement après. Le processus inverse est appelé dé-sérialisation.
Il existe différents types de sérialisation :
Sérialisation binaire : Utilise le codage binaire pour stocker des données
Sérialisation XML : Sérialise un objet en un flux XML (XML est un format de
stockage et de structuration des données)

Pour rendre les objets d’une classe sérialisables, on rajoute l’attribut

[Serializable] devant la classe : [Serializable]class Nom_Classe {…}
Pour rendre les objets d’une classe non sérialisables on rajoute l’attribut
[NonSerialized] devant la classe : [NonSerialized]class Nom_Classe {…}

Remarque : La classe à sérialiser doit être public

 Sérialisation binaire

using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
….
Stream S = File.Open("chemin_Fichier",
FileMode.Create);
BinaryFormatter BF = new BinaryFormatter();
BF.Serialize(S, Objet_A_sérialiser);
S.Close();
 Sérialisation XML

using System.Xml.Serialization;
using System.IO;
….
Stream S = File.Open("xx.xml",FileMode.Create);
XmlSerializer X = new
XmlSerializer(ObjetASerialiser.GetType());
X.Serialize(S, ObjetASerialiser);
S.Close();
 Dé-Sérialisation binaire

using System.Runtime.Serialization;
using
System.Runtime.Serialization.Formatters.Binary;
using System.IO;
….
Stream S = File.Open("chemin_Fichier ",
FileMode.Open);
BinaryFormatter BF = new BinaryFormatter();
Object A = BF.Deserialize(S);
S.Close();
 Dé-Sérialisation XML

using System.Xml.Serialization;
using System.IO;
….
Stream S = File.Open("chemin_Fichier ",
FileMode.Open);
XmlSerializer X = new
XmlSerializer(ObjetASerialiser.GetType());
Object A = X.Deserialize(S);
S.Close();
 REGEX

• Les expressions régulières constituent un

moyen efficace pour vérifier si un élément
respecte un modèle. Par exemple est ce
qu’une adresse E-mail s’écrit bien sous le
format texte@texte.texte ou est ce qu’un
nombre se compose bien de 2 chiffres après la
virgule…
• Il existe un langage permettant d’exprimer des
expressions régulières.
 Définition

• Les Regex sont un outil (ou plutôt un système)

très puissant permettant de vérifier la syntaxe
d'une chaîne de caractères. Plus précisément,
c'est vérifier que la chaîne de caractères à
examiner respecte un motif ou une série de
motifs (notre Regex) désignant la syntaxe
attendue de la phrase.
• Les Regex sont utilisées pour trois grands types
d'action :
- Vérifier la syntaxe(forme) d'une chaîne de caractères
(ex : adresse ip de forme chiffre.chiffre.chiffre.chiffre)
- Remplacer une partie de la chaîne (token) par un
élément spécifique
- Découper une chaîne de caractères
Leur utilisation la plus courante est de vérifier la
syntaxe d'une chaîne, c'est-à-dire contrôler qu'elle
respecte un format prédéfini et normé, décrit par les
combinaisons d'opérateurs et de valeurs de la chaîne
Regex.
 Symboles utilisés
• abc : Chaine de caractères = « abc »
• * : Répétition 0 ou plusieurs fois
• + : Répétition 1 ou plusieurs fois
• ? : Répétition 0 ou 1 fois
• \d : un chiffre (on utilise aussi [0-9])
• [abc] : a, b ou c
• [^abc] : différent de a, de b et de c
• [a-f] : de a jusqu’à f
• . : Correspond à tout caractère sauf \n (retour à la ligne )
• \w : un caractère alphanumérique(on utilise aussi [a-zA-Z0-9])
• {x}: x fois exactement(exemple: \d{2} : 2 nombres décimaux)
• {x,}:x fois au moins
• {x, y}:x fois minimum, y maximum
• \. : un point
 La classe Regex
• La classe Regex se trouvant dans l’espace de nom
System.text.regularExpressions représente une
expression régulière qui sera fournie au moment de
l’instanciation de la classe. Elle offre des méthodes
permettant de valider, d’extraire ou de modifier du
texte répondant à l’expression régulière :
- La méthode IsMatch de la classe Regex reçoit en
entrée un texte qui va servir de base pour la recherche
et retourne un booléen indiquant si le texte contient
une partie respectant l’expression régulière utilisée.
• La méthode Replace de la classe Regex permet de remplacer dans
un texte, les parties du texte répondant au modèle par un autre
texte.
• La méthode Match reçoit en entrée un texte qui va servir de base
pour la recherche et retourne un objet de type match permettant
de récupérer des informations sur le premier élément trouvé qui
respecte le modèle. Cet objet offre des propriétés :
– Success : Booléen qui indique si le modèle a été trouvé ou non
– Index : Entier qui retourne la position où le modèle a été trouvé…
• La méthode Matchs reçoit en entrée un texte qui va servir de base
pour la recherche et retourne un objet de type MatchCollection qui
est une collection d'objets Match permettant de récupérer des
informations sur l'ensemble des éléments trouvés qui respectent le
modèle. La propriété Count donne le nombre d'éléments qui
respectent le modèle.
 Exemples
Cet exemple parcours le tableau pour vérifier si ses éléments sont des
nombres décimaux :
Regex rx = new Regex("^-?\d+(\.\d{2})?$");
String[] T = {"10.25","-14","0.01","100",".34","0.34",
"1,052.21"};
String test;
for(int i= 0;i<T.Length;i++)
{ test = T[i];
if (rx.IsMatch(test))
MessageBox.Show(test + " est un nombre décimal.");
else
MessageBox.Show(test + " n’est pas un nombre décimal.");
}
Cet exemple cherche dans un texte une sous chaine
correspondant à l’expression régulière et le remplace par
un vide
Regex rx = new Regex(TextBox2.Text);
String s = TextBox1.Text;
if (rx.IsMatch(s))
{ MessageBox.Show("existe");
s = rx.Replace(s, "");
TextBox1.Text = s;}
else
{ MessageBox.Show("n'existe pas");}
Cet exemple utilise l'objet match pour récupérer des informations sur le premier
élément trouvé qui respecte le modèle
Regex rx = new Regex(TextBox2.Text);
String s =TextBox1.Text;
Match m= rx.Match(s);

if (m.Success)
{
MessageBox.Show("existe");
MessageBox.Show(m.Index.ToString());
MessageBox.Show(m.Value);}

else{
MessageBox.Show("n'existe pas");
}
Cet exemple utilise l'objet matchCollection pour récupérer des informations
sur l'ensemble des éléments trouvés qui respectent modèle trouvé
Regex rx = new Regex(TextBox2.Text);
String s= TextBox1.Text;
//Le modèle peut se trouver plusieurs fois, on utilise une collection
MatchCollection MCol = rx.Matches(s);
MessageBox.Show("Nombre de modèles trouvés : " +
MCol.Count.ToString());
foreach(Match m in MCol)
{
MessageBox.Show("index :" +
m.Index.ToString()+Environment.NewLine+ "Valeur :" + m.Value.ToString());
}