POO en C#

Programmation Orientée
Objet en C#
HAJJOUJI A.Mounim / ISTA GEST Programmation Orientée Objet en C# 1

I. Introduction
II. Définition d'une classe
III. Constructeurs et destructeur
IV. Instanciation
V. Exemple
VI. Méthodes et variables de classe
VII.Héritage
VIII.Classe et méthodes abstraites
IX. Les classes sealed
X. Les méthodes virtual
XI. Classes .NET d'usage courant
XII.La gestion des erreurs
XIII.Sérialisation et Desérialisation d’objets
XIV.Les interfaces
XV.Le polymorphisme
HAJJOUJI A.Mounim / ISTA GEST 2
Programmation Orientée Objet en C#
I. Introduction
Notion d’Objet
Les objets représentent la notion fondamentale pour

comprendre la technologie de l’orienté objet. Dans la
nature, tout est objet: arbres, montagnes, maisons, avions,
voitures….
Tous les objets du monde réel partagent deux
caractéristiques fondamentales: ils ont tous un état
(attributs ou propriétés) et un comportement.
-L’ état permet de décrire un objet dans son aspect
statique ou dynamique.
-Le comportement renseigne les actions qu’un objet peut
faire ou subir et qui peuvent être à l’origine d’un
changement d’état.
La Programmation Orientée Objet (POO)
La programmation orientée objet consiste à écrire des

programmes informatique basés sur la définition et l’utilisation
d’objets.
Les objets logiciels sont similaires aux objets du monde réel:
Dans un programme informatique, un objet possède un état
défini dans des variables et un comportement défini dans
des méthodes ou fonctions.

Notion de Classe
Une classe est une unité de code (programme) dans lequel
on défini un objet. Chaque classe possède un nom, un
début, une fin et contient des variables (état de l’objet) et
des méthodes (comportement de l’objet).
Une classe est donc un moule à partir duquel sont construits
des objets.
Représentation schématique Nom de la classe

d’une classe Attributs ou propriétés de la classe
Méthodes de la classe

II. Définition d'une classe
Syntaxe générale de déclaration:
[Modificateurs_de_classe] class Nom_de_la_classe
{
Variables membres
….
Méthodes membres
…..
}
Modificateurs de classe :
public : une classe public est accessible depuis n'importe où.
partial : Définit des classes partielles dans le même assembly.
abstract : une classe abstract ne peut pas être instanciée directement. Elle
sert de classe de base dans une relation d'héritage.
sealed : une classe sealed ne peut être dérivée.

Variables membres:
Syntaxe générale de déclaration d'une variable :
[Modificateur _d_accès] Type nom_de_variable ;
On peut citer trois catégories de variables:

Variables déclarées dans une classe: représentent les attributs ou propriétés
de la classe
Variables déclarées dans une méthode: variables locales.
Variables faisant partie de la déclaration d’une méthode: appelées paramètres
de la méthode.
Toute variable doit avoir un type (exception pour var).

Le type peut être un type valeur ou primitif (int, bool, double…)
Comme il peut être un type référence (class, interface, delegate)

Méthodes membres:
Syntaxe générale de déclaration d'une méthode :
[Modif_accès] Type_retourné Nom_de_la_méthode(Liste_paramètres )
{
// instructions de la méthode
}
Une méthode est un sous programme identifié par un nom, pouvant recevoir
ou non des paramètres et ayant ou non un type de retour (si la méthode ne
retourne aucune valeur le type de retour est void).
Chaque méthode est caractérisée par sa signature. La signature est
constituée du nom de la méthode et la liste de ses paramètres.
La surcharge de méthode consiste à définir plusieurs méthode qui ont le
même nom mais qui diffèrent par le type et le nombre de paramètres

Modificateurs d’accès:
Les modificateurs d’accès déterminent si d’autres classes peuvent utiliser un

attribut ou invoquer une fonction (principe d’encapsulation).
Dans C# les modificateurs d'accès permettent de spécifier les cinq niveaux

d'accessibilité suivants :
public : l'accès n'est pas restreint.
protected : l'accès est limité à la classe conteneur ou aux types dérivés de la
classe conteneur.
Internal : l'accès est limité à l'assembly actuel.
protected internal : l'accès est limité à l'assembly actuel ou aux types dérivés de
la classe conteneur.
private : l'accès est limité au type conteneur.

Les accesseurs/mutateurs ou (Propriétés)
Les propriétés sont des membres offrant un mécanisme souple pour la lecture,
l'écriture ou le calcul des valeurs de champs privés. Elles peuvent être utilisées
comme si elles étaient des membres de données publiques, mais en fait, ce sont
des méthodes spéciales appelées accesseurs. Elles facilitent l'accès aux
données tout en préservant la sécurité et la souplesse des méthodes.
Syntaxe générale de déclaration d'un accesseur :

public type_attribut nom_propriété
{
get { …
return valeur;
…
}
set {
….
…..
nom_attribut = value …;
…
}
} Programmation Orientée Objet en C#
III. Constructeurs et destructeur
Un constructeur est la première méthode appelée lors de la création

(instanciation) d’un objet.
-Une classe peut avoir plusieurs constructeurs qui diffèrent par leurs
paramètres
-Un constructeur par défaut est créé automatiquement
Un destructeur est une méthode sans paramètres appelée
automatiquement lors de la destruction de l’objet (rarement utilisé)
Syntaxe générale de déclaration d'un constructeur :
public Nom_de_la_classe(Liste_paramètres )
{
// instructions de la méthode
}

IV. Déclaration et Instanciation d’un objet
L’instanciation est l’opération qui consiste à créer une

instance (exemplaire) d’un objet à partir de sa classe. Pour
créer un objet, on instancie une classe en appelant
l'opérateur new. Celui ci appelle le constructeur adéquat.
Un objet est une variable ayant pour type celui de sa classe
Syntaxe générale de déclaration et instanciation d’un objet :
[Modificateur _d_accès] nom_classe nom_variable= new nom_classe(…) ;
On peut egalement déclarer un objet et l’instancier aprés :

[Modificateur _d_accès] nom_classe nom_variable;
…
nom_variable = new nom_classe(…) ;

V. Exemple: Partie I
Soit un objet Avion caractérisé par les attributs: marque, modèle,

vitesse maximale, altitude maximale, vitesse en cours et altitude en
cours.
Un avion peut décoller, atterrir, voler…
1. Ecrire le code de la classe Avion
2. La classe Avion possède deux constructeurs:
-Un constructeur par défaut permettant d’initialiser tous les attributs
-Un constructeur recevant trois paramètres pour initialiser la
marque, la vitesse maximale et l’altitude maximale
3. La méthode decoller() augmente la vitesse_en_cours de 10 sans
dépasser la vitesse maximale. Elle augmente l’altitude en cours de
200 quand la vitesse en cours est >=300 sans dépasser l’altitude
maximale.
4. La méthode atterrir fait l’inverse

Représentation de la classe Avion
Avion Nom de la classe

mq
modele
v_max Attributs ou propriétés de la classe
altitude_max
v_en_cours
altitude_en_cours
Avion() Constructeurs
Avion(mq,v_max,a_max)
decoller()
atterir() Méthodes de la classe

V. Exemple (Suite): Partie II
5. Dans la méthode Main de votre classe principale écrire le code permettant

de créer un avion en utilisant le constructeur par défaut
6. Affecter en suite aux différents attributs les valeurs suivants:
mq: Boeing
modele: 737
v_max: 900 Km/H
Altitude_max: 10100 m
V_en_cours:0
Altitude_en_cours:0
7. Afficher ces différents valeurs

8. Faire la même chose en utilisant le deuxième constructeur
9. Créer deux avions différents et afficher leurs propriétés
10. Faire décoller le premier avion jusqu’à l’altitude 6000 m

V. Exemple (Suite): Partie III
11. Rendre private l’accessibilité des attributs mq, v_max et v_en_cours
12. Afin de permettre l’accès à mq ajouter un accesseur en lecture écriture
nommé marque
13. Ajouter également un accesseur en lecture écriture nommé vitesse_maximale
pour l’attribut v_max.
14. Ajouter un accesseur en lecture pour l’attribut v_en_cours

VI. Méthodes et variables de classe (static)
Les variables de classe
Quand on instancie plusieurs objets à partir d’une même classe chacun de ces
objets possède ses propres valeurs de variables d’instance. Dans certains cas
on a besoin d’avoir des variables ayant des valeurs indépendantes des objets
instanciés à partir de la même classe, ce genre de variables sont dites des
variables de classe et sont déclarées avec static. Ce genre de variables
peuvent être appelées directement sans instancier un objet de leurs classe, Il
suffit pour cela de précéder la variable avec le nom de sa classe suivi d’un point
Les méthodes de classe
Les méthodes de classe sont des méthodes déclarées avec le mot static.
Une méthode déclarée static peut être appelée sans instancier un objet de sa
classe. Il suffit pour cela de précéder la méthode avec le nom de sa classe suivi
d’un point.

les classes statiques
Les classes statiques contiennent uniquement des méthodes et attributs
statiques. Le contraire engendrerait un problème lors de la compilation.
Elles ne peuvent pas être instanciées

• Elles doivent contenir uniquement des méthodes et attributs statiques
• Elles sont scellées par défaut (ne peuvent pas être dérivées)
• Elles ne peuvent pas contenir de constructeur
Ce qu'il faut retenir :

Une classe statique ne contient que des éléments statiques, mais
des éléments statiques ne sont pas forcément contenus dans une
classe statique.
Les méthodes et attributs définis comme statiques sont
accessibles sans instancier d'objet.

VII. Héritage
Certains objets ont des attributs ou des méthodes en commun. Ces

propriétés et ces méthodes sont définies dans une classe mère à partir
de laquelle on dérive les autres classes. Le fait de dériver une classe à
partir d’une classe de base permet à la classe dérivée d’hériter les
attributs et les méthodes déclarées public ou protected
La programmation orientée objet permet à des classes d’hériter l’état et

le comportement d’autres classes.

Syntaxe générale de déclaration d’une classe dérivée :
[Modificateurs_de_classe] class Nom_de_la_classe_dérivée: classe_mère

{
Variables membres
….
Méthodes membres
….
}
Le mot clé base sert à accéder aux membres de la classe de base à partir
d'une classe dérivée
L'accès à une classe de base n'est autorisé que dans un constructeur, une
méthode d'instance ou un accesseur de propriété d'instance.
Le fait d'utiliser le mot clé base à partir d'une méthode statique constitue une
erreur.

Exemple Avion
Mq
…
Avion()
Avion(mq,v_max,a_max)
decoller()
atterir()
Avion_de_ligne Avion_cargo
nombre_de_places charge_max
nombre_de_voyageur charge_actuelle
embarquer_voyageur() Avion_de_chasse
embarquer_voyageur(int n) charger_tout()
debarquer_voyageur(int n) type_armes decharger_tout()
debarquer_tout() quantite
charger_armes(int q)
bombarder()
VIII.Classe et méthodes abstraites
Classe abstraite: abstract
Une classe abstraite est une classe qui ne peut pas être instanciée. Elle
sert de classe de base dans une relation d’héritage.
Syntaxe générale de déclaration d’une classe abstraite :
public abstract class Nom_de_la_classe

{
Variables membres
….
Méthodes membres
….
}

Méthode abstraite: abstract
Les classes abstraites peuvent également définir des méthodes
abstraites.
Une méthode abstraite est une méthode qui doit être réécrite et
redéfinie dans les classes dérivées.
Les méthodes abstraites n'ont pas d'implémentation. Ainsi, la définition de
la méthode est suivie d'un point-virgule au lieu d'un bloc de méthode
normal.
Les classes dérivées de la classe abstraite doivent implémenter toutes
les méthodes abstraites en utilisant le mot override.
Les déclarations de méthodes abstraites sont autorisées uniquement dans
les classes abstraites.
Syntaxe générale de déclaration d’une méthode abstraite :
public abstract nom_de_la_methode(..parametres..);

Exemple Figure
Classe abstraite
nom
couleur_trait
Méthodes abstraites couleur_remplissage
abstract surface()
abstract perimetre()
abstract tracer_figure()
Cercle Quadrilateral
rayon largeur
longueur
surface() surface()
perimetre() perimetre()
tracer_figure() tracer_figure()
Ces méthodes doivent être redéfinies

IX. Les méthodes: virtual
Le mot clé virtual sert à modifier une méthode, une propriété, un indexeur
ou une déclaration de l'événement et leur permet d'être substitués (redéfinis)
dans une classe dérivée.
Les méthodes déclarées virtual peuvent être redéfinies et reimplémentées
dans les classes dérivées. Le mot clé override permet de redéfinir une
méthode virtual.

X. Les classes sealed
Lorsqu'il est appliqué à une classe, le modificateur sealed empêche les
autres classes d'en hériter .
Une classe déclarée avec sealed ne peut pas être utilisée dans une relation
d’héritage.
On peut également utiliser le modificateur sealed sur une méthode ou une
propriété qui substitue une méthode ou une propriété virtuelle dans une
classe de base. Cela permet d' empêcher les classes à dériver de votre
classe de substituer (redéfinir) des méthodes ou des propriétés virtuelles
spécifiques.
Syntaxe générale de déclaration d’une classe sealed :
public sealed class Nom_de_la_classe

{
Variables membres
….
Méthodes membres
….
}
XI. Classes .NET d'usage courant
La bibliothèque de classe .NET Framework offre une multitude de classes,
interfaces et types valeur destinées à faciliter la programmation et permettant
d'accéder aux fonctionnalités du système.
Voici quelques classes de cette plate-forme
1.Les chaînes de caractères: La classe System.String

La classe présente un ensemble de méthodes et de propriétés permettant la
manipulation des chaînes de caractères.
Noter que dans cette classe on trouvera deux types de méthodes: les méthodes
de classe (static) et les méthodes d’instance
-Pour accéder aux méthodes static utiliser le nom de la
classe (c a d String)
-Pour accéder aux méthodes d’instance utiliser le nom de la
variable de type string

On notera un point important : lorsqu'une méthode rend une chaîne de
caractères, celle-ci est une chaîne différente de la chaîne sur laquelle a
été appliquée la méthode. Ainsi S1.Trim() rend une autre chaîne
différente de S1.
Une chaîne C peut être considérée comme un tableau de
caractères. Ainsi
C[i] est le caractère i de C
C.Length est le nombre de caractères de C
2.Les tableaux: La classe Array
Les tableaux dérivent de la classe Array :
3.Les collections
a. Les collections génériques
Outre le tableau, il existe diverses classes pour stocker des collections d'éléments.
Il existe des versions génériques dans l'espace de noms
System.Collections.Generic et des versions non génériques dans
System.Collections.

La classe générique List<T>
La classe System.Collections.Generic.List<T> permet d'implémenter
des collections d'objets de type T dont la taille varie au cours de
l'exécution du programme. Un objet de type List<T> se manipule presque
comme un tableau. Ainsi l'élément i d'une liste l est noté l[i].
Syntaxe générale de déclaration d’une List :
List<nom_type_ou_classe> nom_liste=new List<nom_type_ou_classe> ();
Exemple: déclaration d’une liste générique nommée lav contenant des Avions
List<Avion> lav=new List<Avion> ();

La classe Dictionary<TKey,TValue>
La classe System.Collections.Generic.Dictionary<TKey,TValue> permet
d'implémenter un dictionnaire. On peut voir un dictionnaire comme un
tableau à deux colonnes :
clé valeur
clé1 valeur1
clé2 valeur2
.. ...
Dans la classe Dictionary<TKey,TValue> les clés sont de type

Tkey, les valeurs de type TValue. Les clés sont uniques, c.a.d. qu'il ne
peut y avoir deux clés identiques. Lors de son déclaration Tkey et
TValue peuvent être de type quelconque
Syntaxe générale de déclaration d’un Dictionary :
Dictionary<nom_type_clé, nom_type_valeur> nom_liste=new
Dictionary<nom_type_clé, nom_type_valeur> ();

Exemple: déclaration d’un Dictionary nommée lp contenant des objets
Pays ayant comme clé le nom du pays
Dictionary<string, Pays> lp=new Dictionary<string, Pays> ();
Un Dictionary peut être manipulé comme un tableau. Ainsi

on peut accéder à un élément par la valeur de sa clé et non
par son indice.
Exemple:
Lp["Finland" ] renvoi le pays ayant dans la valeur de la clé
Finland

b. Les collections non génériques
L'espace de noms System.Collections contient des interfaces et classes
qui définissent différentes collections d'objets, par exemple, les listes, les
files d'attente, les tableaux de valeurs de bit, les tables de hachage et les
dictionnaires.
Une collection nom générique peut contenir des objets de type différents.
Pour extraire un objet de la collection il faut préciser son type par un cast.
Parmi les collection non génériques on trouve ArrayList et HachTable
La classe ArrayList
Syntaxe générale de déclaration d’un objet ArrayList :
ArrayList lav=new ArrayList ();

Exemple d’un programme qui crée 100 objets de
type Pays et les stock dans une collection
ArrayList:
..
Pays p;
ArrayList lp=new ArrayList();
int i;
for(i=1;i<=100;i++)
{
p=new Pays(); // instanciation d’un pays
p.nom=« pays » + i;
lp.Add(p); //Ajout à la collection
}

Extraction et affichage des pays stockés dans la collection
ArrayList:
..
int i;
Pays p;
for(i=0;i<lp.count;i++)
{
p=(Pays)lp[i]; // extraction d’un pays de la collection
//noter l’utilisation d’un cast (Pays)
Console.Write(p.nom);
}
La classe HashTable
Permet de créer des collection sous forme de clé et d’une valeur .

Toutes les collections offrent des méthodes
permettant de manipuler leurs éléments à
savoir: ajouter, inserer, supprimer…
4.Les classes Math et Random
a. La classe Math
Toute une série de fonctions mathématiques sont regroupées dans la
classe Math de l’espace de noms System. Cette classe Math contient
notamment :
• la définition de deux constantes, toutes deux de type double : Math.E
pour la valeur du nombre népérien ( 2.718...) et Math.PI pour la valeur du
nombre Pi (3.1415...) ;
• des fonctions de calcul mathématique : calcul de puissance, fonctions
trigonométriques, etc.
Les constantes et fonctions de cette classe sont qualifiées de static, ce
qui permet de les utiliser sans devoir créer un objet Math.
a. La classe Random
La classe Random contient les fonctions nécessaires à la génération de

nombres aléatoires.
Cette classe possède une méthode nommée Next ayant trois surcharges,
permettant de générer un nombre aléatoire.
. Next(): retourne un nombre aléatoire entre zéro inclus et la limite
supérieur d’un int.
. Next(int n): retourne un nombre aléatoire entre zéro inclus et
inférieur au nombre passé en paramétre.
. Next(int n1, int n2): retourne un nombre aléatoire >= n1 et < n2.

5.Classes de manipulation de dates et d’heures
a. La structure DateTime
La structure DateTime permet d’effectuer diverses opérations sur les dates :
déterminer le jour de la semaine, calculer une date à x jours, déterminer si
une date est antérieure ou postérieure à une autre, etc. Un objet DateTime
peut contenir une date comprise entre le premier janvier de l’an un à midi et
le 31 décembre 9999. Il comprend à la fois une date et une heure avec accès
à la milliseconde. On parle de classe DateTime bien qu’il s’agisse plus
précisément d’une structure.
b. La structure TimeSpan
La structure TimeSpan intervient dans les calculs sur dates (plus

précisément dans les intervalles entre dates « Durée »). Ici aussi, nous
parlons de classe alors qu’il s’agit plus précisément d’une structure.
Remarque: Lors des opérations sur les dates et les durées on a

Date + ou - une durée on obtient une date
Durée + ou – une durée on obtient une durée
Date + ou – une date incorrect
HAJJOUJI A.Mounim / ISTA GEST
37
Pour plus de détails voir chapitre
3 « classes non visuels »
paragraphe 4 « classes de
manipulation de dates et
d’heures »
dans le livre C# et .NET

6.Classes de manipulation de fichiers, dossiers…
Toutes les classes permettant de manipuler les fichiers et les
dossiers Existent dans le namespace System.IO
Parmi ces classes on peut citer:
Classes de manipulation de Classes de manipulation de
fichiers dossiers
FileInfo Directory
File DirectoryInfo
FileStream DriveInfo
StreamReader Path
StreamWriter
BinaryReader
BinaryWriter

Manipulation des
répertoires et des fichiers

Travailler sur les répertoires.
Les classes DirectoryInfo et Directory.

La classe Path.
La classe Environment.

Classe DirectoryInfo et la Classe Directory du Framework
La classe Directory est utilisée pour travailler sur un ensemble de
dossier, la Classe directoryInfo donne des renseignements sur un
dossier particulier (Après instanciation ).
La Classe Directory possède les méthodes suivantes.
Exists Teste si le dossier existe.

CreateDirectory Crée le dossier
Delete Efface le dossier
Move Déplacement de dossier
GetCurrentDirectory Retourne le dossier de travail de l'application en cours
SetCurrentDirectory Définit le dossier de travail de l'application.
GetDirectoryRoot Retourne le dossier racine du chemin spécifié.
GetDirectories Retourne le tableau des sous dossiers du dossier spécifié.
GetFiles Retourne les fichiers du dossier spécifié.
GetFilesSystemEntries Retourne fichier et sous dossier avec possibilité d'un filtre.
GetLogicalDrives Retourne les disques
GetParent Retourne le dossier parent du dossier spécifié.
La Classe Directory est statique : onA.Mounim

HAJJOUJI l'utilise
/ ISTAdirectement.
GEST 42
Exemples:
a. Afficher dans une ListeBox les sous dossiers d’un dossier donné
b. Afficher dans une ListeBox les fichiers .jpg d'un répertoire.
c. Créer un répertoire
La Classe DirectoryInfo possède les propriétés suivantes.

Name Nom du dossier (sans extension)
Full Name Chemin et nom du dossier
Exists
Parent Dossier parent
Root Racine du dossier
Create, Delete, MoveTo
CreateSubdirectory
GetDirectories Retourne les sous-dossiers
GetFiles Retourne des fichiers
GetFileSystemInfos
La Classe DirectoryInfo n'est pas statique : il faut instancier un

dossier avant de l'utiliser.
Exemples:
a. Afficher le répertoire parent d'un dossier

b. Créer un répertoire
c. Effacer un répertoire et ses sous-répertoires
La Classe Path
La Classe statique Path a des méthodes simplifiant la manipulation des
répertoires:
Exemple:
Si C= "C:\Windows\MonFichier.txt"
Path.GetDirectoryName(C) retourne "C:\Windows
Path.GetFileName(C) retourne "Monfichier.txt"
Path.GetExtension(C) retourne ".txt"
Path.GetFileNameWithoutExtension(C) retourne "MonFichier"
Path.PathRoot(C) retourne "c:\"
Il y a aussi les méthodes GetFullPath ChangeExtension, Combine,
HasExtension...
GetFullPath: Transforme un chemin relatif en chemin absolu à l'aide du
répertoire courant.

La Classe DriveInfo
Pour un disque particulier, il faut instancier un DriveInfo avec la lettre du
drive, ensuite, on a accès à toutes les propriétés du lecteur.
DriveInfo di =new DriveInfo ("c:")

di.Name retourne le nom du lecteur ( "c:" ici)
VolumeLabel Nom (label) du lecteur (en lecture écriture)
DriveType ( Fixed, Removal, CDRom, Ram, Networl, Unknown)
DriveFormat (NTFS, Fat32)
TotalSize, TotalFreeSpace, AvailableFreeSpace
La Classe Environment
Donne des informations concernant l'environnement et la plate-forme en
cours ainsi que des moyens pour les manipuler. Par exemple: les
arguments de la ligne de commande, le code de sortie, les paramètres des
variables d'environnement, le contenu de la pile des appels, le temps écoulé
depuis le dernier démarrage du système ou le numéro de version du
Common Language Runtime mais aussi certains répertoires .
Environment.CurrentDirectory 'donne le répertoire courant : ou le processus
en cours démarre.
Environment.MachineName 'Obtient le nom NetBIOS de l'ordinateur local.
Environment.OsVersion 'Obtient un objet contenant l'identificateur et le
numéro de version de la plate-forme en cours.
Environment.SystemDirectory 'Obtient le chemin qualifié complet du
répertoire du système
Environment.UserName 'Obtient le nom d'utilisateur de la personne qui
a lancé le thread en cours.
La fonction GetFolderPath avec un argument faisant partie de l'énumération
SpecialFolder retourne le répertoire d'un tas de choses:
Exemple: Quel est le répertoire Système?
Environment.GetFolderPath(Environment.SpecialFolder.System)
Exemple: créer une boite de dialogue 'Choix de répertoire'
FolderBrowserDialog fB =new FolderBrowserDialog();
fB.RootFolder = Environment.SpecialFolder.Desktop;
fB.Description = "Sélectionnez un répertoire";
fB.ShowDialog();
If (fB.SelectedPath == String.Empty) MessageBox.Show ("Pas de
sélection");
else MessageBox.Show (fB.SelectedPath);
fB.Dispose() Programmation Orientée Objet en C#
Travailler sur les fichiers.
Classes FileInfo, File et Stream
La classe File est utilisée pour travailler sur un

ensemble de fichier ou un fichier (sans
instanciation préalable: ce sont des méthodes
statiques), la Classe FileInfo donne des
renseignements sur un fichier particulier (Il faut
instancier au préalable un objet FileInfo).

La classe File
La Classe File possède les méthodes suivantes.
Exists Teste si le fichier existe.
Create Crée le fichier
Copy Copie le fichier
Delete Efface le fichier
GetAttributes , SetAttributes Lire ou écrire les attributs.
GetCreationTime , GetLastAccessTime , GetLastWriteTime et les
Set.. correspondant.
Move Déplacement de fichier
Replace Framework 2
ReadAllText, WriteAllText Framework 2 lire ou écrire un texte dans un
fichier
ReadAllLines, WriteAllLines Framework 2 lire ou écrire des lignes
dans un fichier
ReadAllBytes, WriteAllBytes Framework 2 lire ou écrire des octets
dans un fichier
Toutes les méthodes Open (pour un FileStream) OpenRead,
OpenWrite, OpenText. HAJJOUJI A.Mounim / ISTA GEST 48
Exemples:
Déplacer un fichier de c: vers d:?
File.Move("c:\monText.txt", "d:\monText.txt");
Copier un fichier de c: vers d:?
File.Copy("c:\monText.txt", "d:\monText.txt", True);
Le dernier argument facultatif (framework 2) permet de remplacer cible s'il existe.
Efface un fichier:
File.Delete("d:\monText.txt");
Un fichier est-il en lecture seule?
If (File.GetAttributes("c:\monText.txt") && FileAttributes.ReadOnly) ...

La classe FileInfo
La Classe FileInfo possède les propriétés suivantes.
Name Nom du fichier (sans chemin)
FullName Nom complet avec chemin
Extension Extension (.txt par exemple)
Length Longueur du fichier.
Directory Répertoire parent
DirectoryName Répertoire ou se trouve le fichier
Exists Existe?
LastAccessTime Date du dernier accès, LastWriteTime existe aussi.
Attributes Attributs
Il faut faire un AND entre Attributes et une valeur de l'énumération FileAttributes (
Archive, Compressed, Directory, Encrypted, Hidden, Normal, ReadOnly, System,
Temporaly).

Exemple:
Pour un fichier, afficher successivement le nom, le nom avec répertoire, le
répertoire, la longueur, la date de dernière écriture et si le fichier est en
ReadOnly.
string sNom = "c:\\monfichier.txt« ;
FileInfo Fi; //On déclare un FileInfo
Fi=new FileInfo( sNom); 'on instance ce FileInfo avec comme paramètre le nom du
fichier
MessageBox.Show("Nom="& Fi.Name);
MessageBox.Show("Nom complet ="& Fi.FullName);
MessageBox.Show("Répertoire="& Fi.DirectoryName);
MessageBox.Show("Longueur="& Fi.Length.ToString);
MessageBox.Show("Date de modification=" +
Fi.LastWriteTime.ToShortDateString);
MessageBox.Show("ReadOnly=" + (Fi.Attributes &&
FileAttributes.ReadOnly).ToString);

Utiliser les "Stream".
Le Stream (flux, torrent, courant) est une notion générale, c'est donc un flux de
données provenant ou allant vers un fichier, un port, une connexion TCP/IP...
Ici on utilise un Stream pour lire ou écrire dans un fichier.
L'accès est séquentiel: les données sont traitées du début à la fin du fichier.
Pour écrire dans un fichier texte:
Il faut instancer un objet de la classe StreamWriter . On écrit avec Write ou
WriteLine.(ajoute un saut de ligne) Enfin on ferme avec Close.
On peut instancier avec le constructeur de la classe StreamWriter et avec New, ou
par la Classe File.
StreamWriter SW =new StreamWriter ("MonFichier.txt"); // crée ou si existe écrase
Il existe une surcharge permettant de ne pas écraser mais d'ajouter à la fin du

fichier:
StreamWriter SW =new StreamWriter ("MonFichier.txt", True); // crée ou si existe
ajoute
Avec la classe File:

StreamWriter SW =File.CreateText ("MonFichier.txt") ;// crée ou si existe écrase
StreamWriter SW =File.AppendText("MonFichier.txt") ;// crée ou si existe ajoute
Ensuite pour écrire 2 lignes:
SW.WriteLine ("Bonjour");
SW.WriteLine ("Monsieur");
Enfin on ferme:
SW.Close();
Pour lire dans un fichier Texte:

Il faut instancier un objet de la classe StreamReader. On lit avec Read (un
nombre d'octet) ReadLine (une ligne) ReadToEnd (de la position courante
jusqu'à la fin). Enfin on ferme avec Close.
Avec le constructeur de la Classe Stream Reader:
StreamReader SR =new StreamReader ("MonFichier.txt");
Avec la Classe File:
StreamReader SR =File.OpenText ("MonFichier.txt") ;

Comment lire chaque ligne du fichier et s'arrêter à la fin?
En effet on ne sait pas habituellement combien le fichier contient de ligne, si le
fichier contient 2 lignes il faut en lire 2 et s'arrêter sinon on tente de lire après la
fin du fichier et cela déclenche une erreur.
3 solutions:
1-Utiliser ReadToEnd qui lit en bloc jusqu'à la fin.
2-Avant ReadLine mettre un Try: quand l'erreur 'fin de fichier' survient elle est
interceptée par Catch qui sort du cycle de lecture et ferme le fichier.
3-Utiliser Peek qui lit dans le fichier un caractère mais sans modifier la position
courante de lecture.
La particularité de Peek est de retourner -1 s'il n'y a plus de caractère à lire sans
déclencher d'erreur, d'exception.
La troisième solution est la plus générale et la plus élégante:
While( SR.Peek!=-1)
{
Ligne=SR.ReadLine();
}
Enfin on ferme:
SR.Close();

XII. La gestion des erreurs
Dans un programme, certaines actions peuvent provoquer des

erreurs à l’exécution et le programme est interrompu c’est ce
qu’on appelle des exceptions. En effet une simple tentative
de division par zéro, l’écriture sur un fichier en lecture seule ou
inexistant peut faire tout planter. Pour éviter cette situation C#
permet de mettre les instructions susceptibles de provoquer
des exceptions dans un bloc try .. catch pour traiter les
erreurs d’exécution sans que le programme ne soit interrompu.
Après catch on peut utiliser un objet Exception déclaré entre
parenthèse

Dans .NET FrameWork il y’a une multitude de classes se
rapportant à des types d’exceptions spécifiques parmi
lesquelles:
-ArithmeticException : « Exception déclenchée par des
opérations de calcul »
-DivideByZeroException: « division par zéro »
-IndexOutOfRangeException: « indice d’un tableau non
valide »
-…
-…
-Toutes ces classes dérivent de la classe mère
Exception

La gestion d'une exception se fait selon le schéma
suivant :
try{
code susceptible de générer une exception
} catch (Exception e){
traiter l'exception e
}
…//on peut avoir plusieurs catch
…
finally // le bloc finally est toujours executé
{
….
}
instruction suivante
Exemple 1:
static void Main(string[] args) {
int age = 0;
Console.WriteLine("Quel âge avez-vous?");
//code à risque
try
{
age = int.Parse(Console.ReadLine());
Console.WriteLine("Vous avez donc " + age + " ans");
}
//Le code placé ici s'execute si une exception est levée
catch
{
Console.WriteLine("Désolé vous devez écrire un nombre!");
}
finally
{
Console.WriteLine("\n*** Merci de votre visite ***");
}
Console.ReadLine();
} Programmation Orientée Objet en C#
Exemple 2: Capturer et afficher le message et le type
D’une exception
static void Main(string[] args) {
int x, y ;
double r;
try //code à risque
{
Console.WriteLine(« donner un nombre:");
x = int.Parse(Console.ReadLine());
Console.WriteLine(« donner un autre nombre:");
y = int.Parse(Console.ReadLine());
r=x/y;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + " " + ex.GetType().ToString());
}
finally {
Console.WriteLine("\n*** Merci de votre visite ***");
} HAJJOUJI A.Mounim / ISTA GEST 60
}
Exemple 3: Capturer et traiter plusieurs type d’exception
try
{
uint a = uint.Parse(Console.ReadLine());
Console.Write("Entrez un deuxieme nombre : ");
uint b = uint.Parse(Console.ReadLine());
uint c = a / b;
Console.WriteLine("Le résultat de la division est " + c);
}
catch (OverflowException) //type uint ne peut être négatif
{
Console.WriteLine("Entrez un nombre positif s'il vous plait");
}
catch (DivideByZeroException) //on ne peut diviser par zéro
{
Console.WriteLine("Désolé vous ne pouvez pas diviser par zero");
}
catch (FormatException) //chaine de caractères non autorisées car uint
{
Console.WriteLine("Les chaine de caractères ne sont pas autorisées");
}
finally
{
Console.WriteLine("\n*** Au revoir! ***");
Console.ReadLine();
Exemple 4: Générer une exception dans une méthode
Voir chapitre 5 Traitement

d’erreurs paragraphe 5 Générer
une exception dans une méthode
dans le livre C# et .NET

XIII. Sérialisation et Desérialisation d’objets
1. Notion de Sérialisation
La sérialisation consiste à stocker les valeurs des
attributs d'une instance d'un objet dans un fichier qui peut
être au format binaire, xml ou Soap.
La sérialisation binaire concerne les champs publics et privés de l'objet
et le nom de la classe, y compris l'assembly contenant la classe.
 Pour pouvoir sérialiser des objets créés à partir d’une classe, la

classe doit être marquée comme étant sérialisable avec Le mot
[Serialiasable()]
 Si on ne veut pas sérialiser certaines attributs de la classe on
utilise le mot [NonSerialized()]

2. Exemple de Sérialisation binaire
a. Déclaration de la classe
Considérons une classe nommée Compte dont la
déclaration est la suivante:
[Serialisable()]
Public class Compte
{
public int num_cpte;
public string nom_proprietaire;
public double solde;
[NonSerialized()] public string agence;
}
 Le mot [Serialiasable()] indique que les objets

créés à partir de cette classe peuvent être sérialisés
 L’attribut agence est marqué comme étant non
sérialisé HAJJOUJI A.Mounim / ISTA GEST 64
b. Sérialisation
Dans le corps du programme, il faut mettre:
using System.IO;
using System.Runtime.Serialization.Formatters.binary
La sérialisation se fera dans un fichier qui doit être créé. Pour

cela on utilise la classe Stream et la classe File toutes les
deux appartiennent System.IO
Pour enregistrer l’objet dans un format binaire on utilise la

classe BinaryFormatter qui appartient à
System.Runtime.Serialization.Formatters.binary

Création d’un objet Compte et sérialisation dans un fichier
..
Compte cp; //déclaration d’un objet compte
cp=new Compte(); // instantiation de cp
// remplissage des données
cp. num_cpte= 2000;
cp. nom_proprietaire="Ali";
cp.solde=200000;
cp.agence="Fes medina";
// ******************************************
Stream fcompte = File.Create("c:\\compte.bin"); // création du fichier
BinaryFormatter bf = new BinaryFormatter(); // création d’un objet formateur

//binaire nomé bf
bf.Serialize(fcompte, cp);// sérialisation de l’objet cp
fcompte.Close();// fermeture du fichier

..
}
c. Desérialisation de l’objet
.. déserialisation consiste à récupéré un objet préalablement sérialisé.
La
Pour déserialiser
Compte notre objet
cp; //déclaration d’un Compte on peut utiliser le programme suivant:
objet compte
if (File.Exists("c:\\compte.bin"))// on teste si le fichier existe
{
Stream fc = File.OpenRead("c:\\compte.bin");// ouverture du fichier
BinaryFormatter bf = new BinaryFormatter(); // création d’un objet
// formateur binaire nomé bf
cp = (Compte)(bf.Deserialize(fc));// déserialisation
MessageBox.Show(cp.nom_proprietaire + cp.solde.Tostring()
fc.Close();
..
}

XIII. Les interfaces
Une interface définit les méthodes que des classes (celles qui
implémentent l’interface en question) doivent implémenter.
Les interfaces constituent souvent une alternative aux classes
abstraites. Dans l’interface, on trouve uniquement la signature
de ces méthodes, on ne trouve pas de code (ce qui n’est
possible que dans les classes abstraites). On ne peut pas
non plus trouver de qualificatif comme public, private ou
protected car c’est à la classe implémentant l’interface de
décider.

• Les interfaces ressemblent aux classes abstraites sur un
seul point : elles contiennent des membres expliquant
certains comportements sans les implémenter.
• Les classes abstraites et les interfaces se différencient

principalement par le fait qu'une classe peut
implémenter un nombre quelconque d'interfaces, alors
qu'une classe abstraite ne peut hériter que d'une seule
classe abstraite ou non.

Vocabulaire et concepts :
• Une interface est un contrat, elle peut contenir des
propriétés, des méthodes et des événements mais
ne doit contenir aucun champ ou attribut.
• Une interface ne peut pas contenir des méthodes déjà
implémentées.
• Une interface doit contenir des méthodes non
Implémentées.
• Une interface est héritable.
• Une interface peut être dérivée d’une autre interface.
• Pour pouvoir construire un objet à partir d'une interface, il
faut définir une classe non abstraite implémentant toutes
les méthodes de l'interface.

1. Définition d’une interface
Syntaxe générale de déclaration:
[Modificateurs] interface Nom_de_l_interface
{
prototype de propriétés //sans implémentation
….
prototypes de méthodes //sans implémentation
…..
}
Exemple:
interface IFigure
{
double surface();
double perimetre();

2. Classe implémentant une interface
Une classe peut implémenter plusieurs interfaces
Exemple 1:
Class cercle : IFigure
{
…
…
double surface()
{
… code de la méthode surface
}
double perimetre()
{
… code de la méthode perimetre
}
XIV.Le polymorphisme
Il existe un concept essentiel en POO désignant la

capacité d'une hiérarchie de classes à fournir
différentes implémentations de méthodes portant le
même nom ainsi que la capacité qu'ont des objets
enfants de modifier les comportements hérités de
leur parents.
Ce concept d'adaptation à différentes "situations"
se dénomme le polymorphisme qui peut être
implémenté de différentes manières.

 Polymorphisme d'objet
C'est une interchangeabilité entre variables d'objets de classes de la même
hiérarchie sous certaines conditions.
 Polymorphisme par héritage de méthode

Lorsqu'une classe enfant hérite d'une classe mère, des méthodes supplémentaires
nouvelles peuvent être implémentées dans la classe enfant mais aussi des
méthodes des parents peuvent être substituées pour obtenir des implémentations
différentes (redéfinition : override).
 Polymorphisme par héritage de classes abstraites

Une classe abstraite est une classe qui ne peut pas s'instancier elle-même ; elle doit
être héritée. Certains membres de la classe peuvent ne pas être implémentés, et
c'est à la classe qui hérite de fournir cette implémentation.
Polymorphisme par implémentation d'interfaces

Une interface décrit la signature complète des membres qu'une classe doit
implémenter, mais elle laisse l'implémentation de tous ces membres à la charge de
la classe d'implémentation de l'interface.

1. Polymorphisme d'objet en C#
Soit une classe Mere et une classe Fille héritant de la classe Mere :
Une variable de type Mere peut se référer à un objet de type Fille

Une variable de type Fille ne peut pas se référer à un objet de type Mere
1.1 instanciation dans le type initial et utilisation dans le même
type
Mere x , u ;
Fille y , w ;
.....
x = new Mere( ) ; // instanciation dans le type initial
u = x ; // affectation de références du même type
y = new Fille( ) ; // instanciation dans le type initial
w = y ; // affectation de références du même type

1.2 Polymorphisme d'objet implicite
Mere x ;
Fille ObjF = new Fille( ) ;
x = ObjF; // affectation de références du type descendant implicite
Une variable de type Mere peut se référer à un objet de type Fille

mais ne peut pas accéder aux membres (variables, méthodes…)
de l’objet de type Fille sauf si ceuxci sont redéfinis
Exemple:

public class Chien:Animal
public class Animal {
{ public int nombreDePattes;
public string nom; //redefinition de la méthode afficher()
public int age; public override void afficher()
{
//méthode virtuelle pouvant être
//redéfinie dans une classe dérivée Console.WriteLine("Class Chien");
public virtual void afficher() }
{ //nouvelle méthode viellir
// new permet de définir une
Console.WriteLine(" class Animal"); //nouvelle méthode ayant la même signature
} //que celle de la classe mére
public new void viellir()
public void viellir() {
{ Console.WriteLine("Le chien viellit");
Console.WriteLine("L'animal viellit");
}
}
}
}

class Program
{
static void Main(string[] args)
{
Animal a;
Chien c;
c = new Chien();
a = new Animal();
a.afficher(); //appel de la méthode afficher()
//de la classe Animal
a = c;
a.afficher();//appel de la méthode afficher()
//ayant été redéfinie dans la classe
Chien
// car a se réfère à un objet de type
Chien
Console.ReadKey();

1.3 Polymorphisme d'objet explicite par transtypage
Mere x ; // Déclaration d’une variable de type Mere
Fille y ; // Déclaration d’une variable de type Fille
Fille ObjF = new Fille( ) ;
x = ObjF ; // x pointe vers un objet de type Fille
y = (Fille) x ; // transtypage et affectation de références du type ascendant
explicite compatible dynamiquement.
La validité du transtypage n'est pas vérifiée statiquement par le compilateur, si

votre variable de référence pointe vers un objet qui n'a pas la même nature que
l'opérateur de transtypage, c'est lors de l'exécution qu'il y aura production d'un
message d'erreur indiquant le transtypage impossible.
• Il est donc impératif de tester l'appartenance à la bonne classe de l'objet à
transtyper avant de le transtyper, le langage C# dispose d'un opérateur
permettant de tester cette appartenance (opérateur is en C#).
• L'opérateur as est un opérateur de transtypage de référence d'objet
semblable à l'opérateur de cast ( ). L'opérateur as fournit la valeur null en cas
d'échec de conversion alors que l'opérateur ( ) lève une exception.

Exemple
Mere x ;
Fille y ;
{ affectation de références du type ascendant explicite mais dangereuse
si x est uniquement Mere : }
y = (Fille)x ; <--- erreur lors de l'exécution ici
{affectation acceptée statiquement (lors de la compilation) mais refusée
dynamiquement ( lors de l’execution), car x pointe vers un objet de type
Mere }
Autre exemple:
Animal a;
Chien c, objC;
objC = new Chien();
a = objC;
if (a is Chien) // on verifie si a se refere à un objet de type Chien
{
c = (Chien)a; //revoi une exception si erreur
//c = a as Chien;// renvoi null si erreur
} else Console.WriteLine("erreur");
L'opérateur is, qui effectue une vérification de type dynamique, est
utilisé pour vérifier quelle est effectivement la classe d'un objet à
l'exécution.
L'expression : objet is classeT renvoie True si objet est une
instance de la classe désignée par classeT ou de l'un de ses
descendants, et False sinon. Si objet a la valeur null, le résultat est
False.
Pour éviter l’erreur d’exécution de l’exemple précédent on peut écrire:
Mere x ;
Fille y ;
if ( x is Fille) // test d'appartenance de l'objet référencé par x à la
bonne classe
y = (Fille)x ;

2. Le polymorphisme de méthodes en C#
-Surcharge de méthode: méthodes ayant le même nom mais pas
la même signature
-Masquage de méthode : Ecrire une méthode dans une classe

dérivée ayant lâ même signature que celle dans la classe mère
-Redéfinition de méthode: redéfinir une méthode ( override)

dans la classe dérivée ayant été marquée (virtual) dans sa classe
mère

2.1 Surcharge:
2.2 Masquage de méthode :

Exemple:
public class Chien:Animal La méthode viellir
{
public int nombreDePattes; de la classe Chien
//redefinition de la méthode afficher() masque celle de la
public override void afficher()
{
classe Animal
Console.WriteLine("Class Chien");
}
{
Console.WriteLine("Le chien viellit");
}
}
2.3 Redéfinition de méthode:
Exemple
public class Chien:Animal La méthode
{
public int nombreDePattes; afficher() est une
redéfinition de la
//redefinition de la méthode afficher() méthode afficher()
public override void afficher()
{ de la classe Animal
Console.WriteLine("Class Chien");
}

{
Console.WriteLine("Le chien viellit");
}

POO en C#

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

POO en C#

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Orientée

HAJJOUJI A.Mounim / ISTA GEST Programmation Orientée Objet en C# 1

Les objets représentent la notion fondamentale pour

La programmation orientée objet consiste à écrire des

HAJJOUJI A.Mounim / ISTA GEST 4

Représentation schématique Nom de la classe

HAJJOUJI A.Mounim / ISTA GEST 5

public : une classe public est accessible depuis n'importe où.

partial : Définit des classes partielles dans le même assembly.

sealed : une classe sealed ne peut être dérivée.

Syntaxe générale de déclaration d'une variable :

[Modificateur _d_accès] Type nom_de_variable ;

On peut citer trois catégories de variables:

Toute variable doit avoir un type (exception pour var).

HAJJOUJI A.Mounim / ISTA GEST 7

HAJJOUJI A.Mounim / ISTA GEST 8

Les modificateurs d’accès déterminent si d’autres classes peuvent utiliser un

Dans C# les modificateurs d'accès permettent de spécifier les cinq niveaux

HAJJOUJI A.Mounim / ISTA GEST 9

Syntaxe générale de déclaration d'un accesseur :

Un constructeur est la première méthode appelée lors de la création

Syntaxe générale de déclaration d'un constructeur :

HAJJOUJI A.Mounim / ISTA GEST 11

L’instanciation est l’opération qui consiste à créer une

On peut egalement déclarer un objet et l’instancier aprés :

HAJJOUJI A.Mounim / ISTA GEST 12

Soit un objet Avion caractérisé par les attributs: marque, modèle,

HAJJOUJI A.Mounim / ISTA GEST 13

Avion Nom de la classe

HAJJOUJI A.Mounim / ISTA GEST 14

5. Dans la méthode Main de votre classe principale écrire le code permettant

7. Afficher ces différents valeurs

HAJJOUJI A.Mounim / ISTA GEST 15

HAJJOUJI A.Mounim / ISTA GEST 16

Les variables de classe

Les méthodes de classe

HAJJOUJI A.Mounim / ISTA GEST 17

Elles ne peuvent pas être instanciées

Ce qu'il faut retenir :

HAJJOUJI A.Mounim / ISTA GEST 18

Certains objets ont des attributs ou des méthodes en commun. Ces

La programmation orientée objet permet à des classes d’hériter l’état et

HAJJOUJI A.Mounim / ISTA GEST 19

[Modificateurs_de_classe] class Nom_de_la_classe_dérivée: classe_mère

HAJJOUJI A.Mounim / ISTA GEST 20

Syntaxe générale de déclaration d’une classe abstraite :

public abstract class Nom_de_la_classe

HAJJOUJI A.Mounim / ISTA GEST 22

public abstract nom_de_la_methode(..parametres..);

HAJJOUJI A.Mounim / ISTA GEST 23

Ces méthodes doivent être redéfinies

HAJJOUJI A.Mounim / ISTA GEST 24

HAJJOUJI A.Mounim / ISTA GEST 25

public sealed class Nom_de_la_classe

1.Les chaînes de caractères: La classe System.String

HAJJOUJI A.Mounim / ISTA GEST 27

HAJJOUJI A.Mounim / ISTA GEST 28

List<Avion> lav=new List<Avion> ();

HAJJOUJI A.Mounim / ISTA GEST 29

Dans la classe Dictionary<TKey,TValue> les clés sont de type

HAJJOUJI A.Mounim / ISTA GEST 30

Dictionary<string, Pays> lp=new Dictionary<string, Pays> ();

Un Dictionary peut être manipulé comme un tableau. Ainsi

HAJJOUJI A.Mounim / ISTA GEST 31