Introduction á C-sharp

Automne 2018
Le Langage C#
Support de cours
Fayçal Abouzaid

Le langage C# Collège Maisonneuve
Fayçal Abouzaid Page 2
Sommaire
1. Présentation du .NET Framework........................................................................................... 6
1.1 Objectifs............................................................................................................................. 7
1.2 Vue générale de l’architecture .NET ............................................................................... 7
1.3 Les Langages .NET.......................................................................................................... 8
1.4 Common Language Runtime........................................................................................... 8
1.5 Les différents types d’applications................................................................................... 9
1.6 Assemblages....................................................................................................................... 9
1.7 Environnement de développement ................................................................................ 10
1.8 Premier projet C# : Quelques concepts......................................................................... 11
1.9 Les interfaces graphiques ............................................................................................... 12
2. Éléments de base du langage C#........................................................................................... 14
2.1 Historique du langage C# .............................................................................................. 14
2.2 Conventions pour l’écriture des programmes................................................................ 14
2.3 Les types en C# ............................................................................................................... 15
2.4 Les opérateurs.................................................................................................................. 19
2.5 Les caractères et les chaînes de caractères.................................................................... 20
2.6 LesTypes nullables.......................................................................................................... 23
2.7 Les énumérations : Enum............................................................................................... 23
2.8 Les expressions régulières : La Classe regex.............................................................. 24
3 Les structures de décision et de répétition............................................................................ 28
3.1 Les opérateurs.................................................................................................................. 28
3.2 Les instructions de décisions.......................................................................................... 29
3.3 Les instructions de répétitions ....................................................................................... 31
3.4 Les tableaux..................................................................................................................... 33
4 Classes et objets....................................................................................................................... 37
4.1 Introduction..................................................................................................................... 37
4.2 Classes.............................................................................................................................. 37
4.3 Les structures : Struct...................................................................................................... 49
4.4 Visual Studio et les classes.............................................................................................. 51
4.5 Classes .NET d’usage courant ....................................................................................... 52

5 Les fonctions membres........................................................................................................... 54
5.1 Définition des fonctions membres................................................................................. 54
5.2 Méthodes virtuelles et redéfinies.................................................................................... 54
5.3 Classes et méthodes abstraites ....................................................................................... 57
5.4 Surcharge de méthodes................................................................................................... 58
5.5 Passage de Paramètres.................................................................................................... 59
5.6 Propriétés sous la forme d’expressions.......................................................................... 61
5.7 Les indexeurs................................................................................................................... 61
5.8 La surcharge des opérateurs........................................................................................... 63
5.9 Les attributs ..................................................................................................................... 64
6 Les Exceptions ........................................................................................................................ 66
6.1 Erreurs et exceptions....................................................................................................... 66
6.2 Lancer une Exception..................................................................................................... 66
6.3 Exemples d’exceptions : ................................................................................................. 66
6.4 Capturer une Exception.................................................................................................. 67
6.5 Organisation des gestionnaires ...................................................................................... 68
6.6 Instruction try-finally ............................................................................................ 68
6.7 Instruction try-catch-finally.............................................................................. 68
6.8 Exceptions personnalisées.............................................................................................. 69
6.9 Relancer une exception................................................................................................... 70
6.10 Utilisation de StackTrace........................................................................................... 70
6.11 Opérateur de condition null : ?. (C#6)........................................................................ 71
6.12 Filtres d’Exceptions (C#6) ............................................................................................. 71
6.13 Nameof (C#6)............................................................................................................... 72
7 Délégués et Événements......................................................................................................... 73
7.1 Définition d'un délégué .................................................................................................. 73
7.2 Déclaration des délégués ................................................................................................ 73
7.3 Création du délégué ........................................................................................................ 74
7.4 Invocation du délégué..................................................................................................... 74
7.5 Associer un délégué à plusieurs méthodes.................................................................... 75
7.6 Ajouter ou supprimer des délégués................................................................................ 76

7.7 Utiliser les méthodes .NET............................................................................................ 78
7.8 Les événements ............................................................................................................... 78
8 Les Interfaces........................................................................................................................... 81
8.1 Déclaration de l’interface................................................................................................ 81
8.2 Membres........................................................................................................................... 81
8.3 Implémentation de l’interface ........................................................................................ 82
8.4 Utiliser is pour tester les types...................................................................................... 83
8.5 Utiliser as pour convertir................................................................................................. 84
8.6 Cacher les membres d’une classe de base..................................................................... 84
9 L’interface Graphique (WinForms)........................................................................................ 87
9.1 Contrôles .......................................................................................................................... 87
9.2 Boutons ............................................................................................................................ 89
9.3 Les étiquettes (Label)...................................................................................................... 89
9.4 Boîte de texte ................................................................................................................... 90
9.5 Les contrôles RadioButton et CheckBox....................................................................... 91
9.6 Le contrôle RichTextBox................................................................................................ 92
9.7 Les contrôles ListBox et CheckedListBox .................................................................... 94
9.8 Menus............................................................................................................................... 95
10 Introduction à Windows Presentation Foundation........................................................... 96
10.1 Introduction..................................................................................................................... 96
10.2 Principales caractéristiques de WPF.............................................................................. 96
10.3 Créer une application WPF simple ................................................................................ 97
10.4 Contrôle TextBox............................................................................................................ 99
10.5 Contrôle Bouton Radio............................................................................................... 100
10.6 Ajouter supprimer dynamiquement un élément ......................................................... 101
10.7 Créer un Menu............................................................................................................... 101
11 Collections et itérateurs - Génériques.............................................................................. 104
11.1 Exemples de collections................................................................................................ 104
11.2 La classe non générique ArrayList............................................................................... 104
11.3 Utilisation des énumérateurs........................................................................................ 106
11.4 Itérateurs ........................................................................................................................ 108
11.5 Les collections génériques............................................................................................ 109

12 ADO.NET.......................................................................................................................... 115
12.1. SQL Server et Visual Studio.......................................................................................... 115
12.2. Les Bases de ADO.NET............................................................................................... 117
Références .......................................................................................................................................... 128

1. Présentation du .NET Framework
“The .NET Framework is an integral Windows component for building and running the next
generation of software applications and Web services.”
Le Framework .NET est un ensemble d’outils de programmation proposés par Microsoft qui
permettent au programmeur de développer différents types d’applications : des applications
console, Windows Form ou WPF, des services Web, des applications Windows mobile et bien
d’autres.
La dernière mouture en date du Framework .NET est la version 4.7. Les différentes dates de
sorties des différentes versions présentées dans le tableau ci-dessous. Chaque mise à jour apporte
son lot de nouveautés et d’améliorations.
Version Date Visual Studio Distribué avec
1.0 Février 2002 Visual Studio
Windows XP Tablet and Media
Center Editions
1.1 24 Avril 2003 Visual Studio 2003 Windows Server 2003
2.0 7 Novembre 2005 Visual Studio 2005 Windows Server 2003 R2
3.0 6 Novembre 2006 Windows Vista, Windows Server 2008
3.5 19 Novembre 2007 Visual Studio 2008 Windows 7, Windows Server 2008 R2
4.0 12 Avril 2010 Visual Studio 2010
4.5 15 Aout 2012 Visual Studio 2012 Windows 8, Windows Server 2012
4.5.1 17 Octobre 2013 Visual Studio 2013
4.5.2 5 Mai 2014
4.6 20 Juillet 2015 Visual Studio 2015 Windows 10, Windows Server 2016
4.7 5 Avril 2017 Visual Studio 2017 Windows 10 Creators Update
4.7.1 Octobre 2017
4.7.2 Avril 2018
Core SDK 2.1.5
(Source Wikipedia)
Visual Studio Community est désormais gratuit. Il peut être téléchargé à l’adresse :
https://www.visualstudio.com/fr-fr/downloads

1.1 Objectifs
Les objectifs du .NET Framework sont nombreux. On peut citer :
• Une approche unifiée pour la conception d’applications : Win, Web, services, …
• Des facilités pour le développement et le déploiement d’applications,
• Une grande facilité d’intégration et interopérabilité entre différents composants.
Le Framework est constitué de deux composants:
• Le Common Language Runtime (CLR) qui est l’environnement d’exécution des
applications .NET
• Une librairie de classes unifiée partagée par les différents langages, la .NET Class
Library.
1.2 Vue générale de l’architecture .NET
La Common Language Specification (CLS) est une spécification qui gère la compatibilité des
langages avec le Framework, ce qui permet d’utiliser n’importe quel langage compatible, qui sera
ensuite compilé par son compilateur associé qui produira un programme en code intermédiaire
(Common Intermediate Language - CIL) anciennement MicroSoft Intermediate Language
(MSIL).
Le programme CIL sera ensuite traduit par la Common Language Runtime (CLR) en code natif
sur n’importe que plateforme où elle sera installée. La CLR traduit le CIL selon les besoins
spécifiques de l’application et de la machine hôte, c’est ce qui s’appelle la compilation ‘Just in
Time’ (JIT) et qui optimise donc les performances.
Ce fonctionnement largement inspiré de celui de la machine virtuelle JAVA, facilite la migration
d’un langage de développement spécifique vers la plateforme .Net (exemple du Visual Basic vers
le VB.Net).

L’architecture générale de la plateforme .NET est représentée par le schéma suivant :
1.3 Les Langages .NET
Tous les langages .NET sont nés égaux :
• Pas de différences fonctionnelles car plusieurs fonctionnalités ont été déplacées du
langage au framework comme par exemple les accès aux fichiers.
• Les différences sont surtout au niveau syntaxique et au niveau de certaines
caractéristiques bien précises.
• Il n’y a pas de différences de performances pour le code managé, c-à-d, exécuté par le
CLR.
• Tous les langages sont compilés en CIL et exécutés par la CLR.
• Il y a un grand niveau d’interopérabilité (cross-languages) ce qui fait que l’on peut dériver
en VB.NET une classe écrite en C#, par exemple.
1.4 Common Language Runtime
“The common language runtime is the execution engine for .NET applications”
Le CLR fournit un certain nombre de services, notamment :

• Le chargement et l’exécution du code,
• La compilation Juste-à-temps (JIT) qui réalise la conversion du code IL en code natif,
• La vérification de type (Common Type System),
• La gestion des exceptions,
• La gestion de la mémoire via le ‘garbage collector’ (ramasse-miettes),
• L’enregistrement dynamique des composants,
• Les contrôles de sécurité.
1.5 Les différents types d’applications
Les différents types d’applications que l’on peut développer dans l’environnement .NET sont :
• Les interfaces utilisateurs Windows (Windows Forms ou Windows Presentation
Foundation (WPF) qui est une spécification graphique plus récente de Microsoft .NET),
• Les applications en mode console Windows,
• Les services Windows,
• Les services Web, Windows Communication Foundation (WCF),
• Les applications Web, en particulier grâce à ASP.NET.
1.6 Assemblages
.NET regroupe les composants en assemblages (assemblies). Ce sont des fichiers avec l’extension
.dll ou .exe qui contiennent les classes compilées. La notion d’assemblage remplace les notions
classiques de dll et exe. Le compilateur ne génère plus de code machine mais génère un
assemblage.
L’assemblage est constitué de deux parties :
• Le langage intermédiaire (Intermediate Language - IL) qui est le code (DLL), et
• Le Metadata qui contient le manifeste décrivant le contenu de l’assemblage : nom,
version, signature, liste des fichiers, dépendances avec d’autres assemblages, infos de
sécurité, …
Chaque fichier a un nom et une clé cryptée permettant de l'authentifier.
1.6.1 Avantages des assemblages
L’utilisation des assemblages présente de nombreux avantages dont :
• L’enfer des DLLs résolu par une gestion plus restrictive des versions,
• La CLI traite les types de même noms comme distincts s’ils viennent de 2 assemblages
différents (multi-langages),
• La base des registres n’est plus sollicitée (les applications sont auto-descriptives),
• Les assemblages sont infalsifiables,
• Les assemblages sont prévus pour être portables,
• Un assemblage peut être morcelé en plusieurs fichiers.

1.6.2 Structure d’un assemblage
1.7 Environnement de développement
1.7.1 Présentation
Microsoft Visual studio 2013 est un environnement puissant de développement dédié au.NET
Framework. Cependant son utilisation n’est pas obligatoire puisque les programmes C# peuvent
être compilés en ligne de commande par un compilateur C#.
Assemblage
Foo2.netmodule
Métadonnées
de type
Code IL des
méthodes des types
Ressources
(image, sons …)
Foo1.exe Image.jpg
Manifeste
Ref ver Foo2
Ref ver Image.jpg
méthodes des types
Code IL des
méthodes des types

1.7.2 Les types de projets et les templates
À la création d’un nouveau projet, Visual Studio propose de choisir entre différents langages de
programmation et différents types d’applications.
1.8 Premier projet C# : Quelques concepts
Structure
générale
− solution
− projet
− classe (!)
− point d’entrée
− namespaces
Clause « using »
Commentaires :
//, /* */
Doc Comments:
/// output:
html/xml
Références
AssemblyInfo
Sensible à la
casse

.NET permet de créer une solution pouvant contenir plusieurs projets indépendants ou reliés par
l’intermédiaire des références. Chaque projet se compose d’au moins une classe - il en contient en
fait plusieurs. Pour chaque projet, on définit un point d’entrée (méthode Main()).
Un projet peut faire partie d’un espace de nom (namespace) qui permet de mieux organiser le
code. La directive « using» au début du programme, permet d’indiquer les bibliothèques qui
sont nécessaires au projet, ce qui évite d’écrire à chaque fois le chemin complet des objets
externes que nous utilisons. Ainsi on écrira «Console.WriteLine » au lieu de
«System.Console.WriteLine».
1.9 Les interfaces graphiques
- Win Forms : C’est l’interface graphique de .NET qui fournit l’accès via la CLR à l’API
Windows. On peut donc créer grâce aux WinForms des applications graphiques intégrants
des fenêtres et plusieurs types de boutons réagissant à des évènements tels que les clics de
souris.
- Windows Presentation Foundation (WPF) est une spécification graphique introduite
depuis le Framework 3.0. Il intègre le langage descriptif XAML. Il est entièrement vectoriel,
pour le dessin comme pour le texte. Cela permet d'augmenter la taille des objets en fonction
de la résolution de l'écran sans effet de pixelisation.

2. Éléments de base du langage C#
2.1 Historique du langage C#
• Version 1 : début 2001
• Version 2.0 : Visual studio 2005 ;
o Ajout des génériques, des itérateurs et des méthodes anonymes;
• Version 3.0 : Visual studio 2008
o Méthodes d’extension, les expressions lambda, LINQ (langage de requêtes);
• Version 4.0 : Visual studio 2010
o Bibliothèque parallèles de tâches (pour processeurs multi-cœurs), meilleure
prise en charge des services Web (modèle REST ou SOAP) et des WCF
(Windows Communications Foundation).
• Version 5.0 (Juin 2013) : Visual studio 2012.
o Méthodes asynchrones;
o Attributs améliorés.
• Version 6.0 (Avril 2015) : Visual studio 2015.
o Filtres d’exceptions;
o Auto-initialisation des propriétés;
o Catch et finally asynchrones;
o Constructeurs primaires …
• Version 7.1 (Août 2017) : Visual studio 2017.
o Main asynchrone avec de nouvelles syntaxes pour Main();
o Expressions Littérales par défaut ;
o Tuples ;
o Pattern matching générique ;
2.2 Conventions pour l’écriture des programmes
• Les noms des classes, structs, et méthodes commencent par une lettre majuscule
(exemple, Class1et Methode1). Si le nom est constitué de mots joints, on met en
majuscules le début de chaque mot (par exemple: MaPremiereClasse,
CalculeTonSolde).
• Commencer les noms des interfaces avec la lettre “I” (par exemple: IMonInterface
et IInterface1).
• Les noms des variables locales commencent par une minuscule et la première lettre de
chaque mot suivant est en majuscules (exemple: maVariable, tonInt, ou
monDoubleTypeVariable).
• Il conseillé d’utiliser des noms de variables significatifs qui indiquent la signification de
ce qu’ils représentent : monNumeroCompte ou tonNAS.

• L’accolade ouvrante ({) doit être sur une nouvelle ligne sous la déclaration de classe ou de
membre. L’accolade fermante (}) est placée sur la même colonne sur une ligne distincte.
• Il faut laisser une ligne vide après chaque opération distincte : déclarations de variables,
boucles ou tests.
2.3 Les types en C#
Un programme C# est une collection de types :
Classes, interfaces, structures, délégués ou énumérations.
C# fournit un ensemble de types prédéfinis : int, byte, char, string, object,… Mais
on peut aussi définir ses propres types.
Les types sont des données membres d’une classe :
Champs, constantes, tableaux ou évènements
Ce sont aussi des fonctions membres d’une classe :
Méthodes, opérateurs, constructeurs, propriétés et indexeurs
Ce peut être encore d’autres types.
Il y a 2 catégories de types: les types valeur et les types référence.
2.3.1 Types valeurs et références
Le Type Valeur contient des données et ne peut avoir la valeur ‘null’. Il est constitué de :
- Primitives int i ; float x;
- Enumérations enum State { Off, On }
- Structures struct Point {int x, y;}

Le Type référence : contient des références vers des objets et peut être ‘null’. Il est constitué
de :
- Racine object
- Chaîne string
- Classes class Foo: Bar, IFoo {… }
- Interfaces interface IFoo: IBar {… }
- Tableau string[] a = new string [10]
- Delegates delegate void Empty();
Remarquez que le type string est un cas particulier. C’est un type référence qui se comporte
comme un type valeur.
•••• Les types valeur
Les caractéristiques principales des types valeur sont:
• Pas d’allocation dans le tas (heap en anglais) mais sur la pile (stack) ce qui
implique une durée de vie limitée par la portée et moins de travail pour le GC,
• Une meilleure utilisation de la mémoire,
• Moins de références indirectes,
• La copie physique lors de l’assignation et du passage des paramètres (sauf ref).
Exemple

•••• Les types Référence
Les types référence héritent de System.Object. Ils sont introduits par les mots-clés :
Class, array, delegate, interface, string
La variable est une référence vers un objet alloué sur le tas; notez qu’on peut avoir plusieurs
références vers un même objet. Les objets sont créés avec le mot-clé new et détruits
automatiquement par le GC (Garbage Collector).
Il n’y a pas de copie physique lors du passage de paramètres contrairement au type valeur. Il y a
cependant une exception : le type string qui est un type référence qui se comporte comme un
type valeur.
2.3.2 Boxing et Unboxing
Les types valeurs ne sont pas alloués sur le tas. Comment peuvent-ils être utilisés dans des
structures de données ou des méthodes qui attendent une référence? Pour cela, on aura recours à
une conversion du type valeur vers une type référence (objet). Cette conversion est le « Boxing
».
L’opération inverse, c’est-à-dire convertir un objet en type valeur, s’appelle « unboxing ». Elle
est plus délicate et doit donc être explicitée, par l’utilisation d’un cast (conversion explicite).
2.3.3 Les types définis par l’utilisateur
On peut définir ses propres types de variables qui seront alors pris dans la liste suivante :
Énumérations enum
Tableaux (Arrays) int[][], string[]
Interface interface
Type référence class
Type valeur struct
Pointeur de fonction delegate

2.3.4 Les types prédéfinis
.NET offre un certain nombre de types prédéfinis
Le type entier
Les autres types numériques

2.3.5 Exemples de types
2.4 Les opérateurs
Les opérateurs permettent d’effectuer des opérations arithmétiques sur les variables.
- Opérateurs Arithmétiques : +, –, *, /
- Opérateur Modulo : %
- Opérateurs incrémentation et décrémentation : ++, ––
2.4.1 Les opérateurs d’affectation
Exemple
2.4.2 Les opérateurs de comparaison
Ils permettent de tester des conditions et renvoient une valeur booléenne (true ou false).
<, >, <=, >=, ==, !=
Avec la signification habituelle.

2.4.3 La conversion entre types
Il y a 2 types de conversions : implicite et explicite selon que l’on précise ou non que l’on veut
faire une conversion. Voici 2 exemples de conversion implicite licite :
double maVar = 4 ;
float maVar = 33 ;
Les conversions implicites suivantes sont interdites :
int x = 4 ;
short z1 = x ; // erreur de compilation
double y = 3.3 ;
short z2 = y ; // erreur de compilation
Il ne doit donc pas y avoir de conversion implicite vers un type plus petit.
Pour une conversion explicite il faut utiliser un cast comme dans les exemples suivants :
short z1 = (short)x ;
short z2 = (short)y ;
2.5 Les caractères et les chaînes de caractères
2.5.1 Le type caractère : char
Les caractères sont stockés comme des caractères Unicode sur 16 bits. Exemples :
char monChar = 'A';
char monChar = 'x0041';
On peut faire un cast sur le code ASCII comme dans :
char monChar = (char)65;
2.5.2 Le Type chaîne de caractères : string
La déclaration et l’initialisation du type string sont comme suit:
string monString = "Bienvenue dans le monde du string!";
La concaténation se fait avec les opérateurs : +, +=
string salut= "Salut";
string virgule= ", ";
string monde = "Le monde!";
string monString = salut + virgule + monde;

2.5.3 La classe StringBuilder
Le type string est immutable, ce qui oblige à utiliser la classe StringBuilder pour changer le
contenu d’un string :
StringBuilder monString = new StringBuilder("Salut,");
Append
monString.Append("World!");
Insert
monString.Insert(6," "); //insérer un espace en 6ème
// position
2.5.4 Diverses opérations sur les strings
• Opérateur Egalité : ==
Console.WriteLine(tonString == monString);
• Pour accéder à un caractère de la chaîne on utilise []
Console.WriteLine(monString[7]);
• Le caractère @ évite d’utiliser l’échappement :
Au lieu de :
string monDoc = "C:DocumentsLettersfriends.doc";
On aura :
string monDoc = @"C:DocumentsLettersfriends.doc";
2.5.5 Exemple de lecture à partir du clavier

2.5.6 Convertir les Strings en Nombres
long monLong = Convert.ToInt64(monString); //convertir à long
float monFloat = Convert.ToSingle(monString);//float
double monDouble = Convert.ToDouble(monString);//double
decimal monDecimal = Convert.ToDecimal(monString);//decimal
On peut aussi utiliser Parse
Single.Parse(monString) // float
Decimal.Parse(monString) // decimal
Double.Parse(monString) // double
2.5.7 Interpolation de chaînes (C# 6)
Ce mécanisme permet d’insérer des variables dans des strings.
string person = "Paul";
Console.WriteLine($"Bienvenue, {person}!");
On peut ainsi formater la chaîne :
Console.WriteLine($"dépôt de {montant:C} dans le compte.n");
2.5.8 Formatage des résultats
On peut afficher les nombres sous différents formats qui sont :
Currency : Format monétaire
Console.WriteLine ("{0:C}", 1.2); // 1.2$
Console.WriteLine ("{0:C}", -1.2); // (1.2$)
Décimal
Console.WriteLine ("{0:D5}", 123); // 00123
Point fixe
Console.WriteLine("{0:F2}", 12);
// 12.00 – 2 chiffres après la virgule
Console.WriteLine("{0:F0}", 12);
// 12 – pas de chiffre après la virgule
Numérique
Console.WriteLine("{0:N}", 1230000000);
// 1,230,000,000.00
Scientifique
Console.WriteLine("{0:E}", 12300000); // 1.230000E+007

Héxadecimal
Console.WriteLine ("{0:X}", 123); // 7B
Console.WriteLine ("{0:X}", 65535); // FFFF
2.6 LesTypes nullables
Ils ont été introduits depuis C#2005. Ils servent à assigner la valeur null à une variable ce qui
est utile pour les Bases de Données où l’on veut pouvoir représenter un champ vide.
Déclaration:
monType? maVariable;
Exemples:
int? monInt = null;
bool? monBool = null;
float? monFloat = 1.23F;
On peut assigner une valeur par défaut à un type en utilisant l’opérateur ??
double? monDouble = null;
double monDouble1 = monDouble ?? -1.0;
2.7 Les énumérations : Enum
Les énumérations servent à grouper certaines constantes de même catégorie. Elles dérivent de la
classe System.Enum.

2.8 Les expressions régulières : La Classe regex
Les expressions régulières permettent de tester le format d'une chaîne de caractères. On peut par
exemple vérifier qu'une chaîne représente une date au format "jj/mm/aa" ou qu’une adresse
courriel est valide. Pour réaliser la comparaison, on utilise un modèle (motif) et on compare la
chaîne de caractère à ce modèle.
Les expressions régulières utilisent l’espace de noms :
System.Text.RegularExpressions; qui fournit les méthodes:
• IsMatch(String) : cette méthode indique si la chaîne d'entrée est conforme à
l'expression régulière.
• Match(String) : cette méthode permet de rechercher dans la chaîne d'entrée
spécifiée la première occurrence de l'expression régulière.
• Replace(String, String): Cette méthode permet de remplace Dans la chaîne
d'entrée spécifiée, toutes les chaînes qui correspondent à un modèle d'expression
régulière par une chaîne de remplacement spécifique.
Les symboles utilisables dans un modèle sont les quantificateurs et les caractères spéciaux dont
nous présentons les plus importants ci-après :

2.5.1 Les Quantificateurs
Symbole Résumé
*
Correspond à 0 ou plusieurs occurrences de l’expression qui précède. Exemple : 'zo*'
correspond à "z" et "zoo".
+
Correspond à 1 ou plusieurs occurrences de l’expression qui précède.
Exemple : 'zo+' correspond à "zo" et "zoo", mais pas à "z".
?
Correspond à 0 ou 1 occurrence de l’expression qui précède.
Exemple : 'zo(os)?' correspond à "zo" dans "zo" ou "zoos".
{n}
Correspond exactement à n fois le caractère. Par exemple, "o{2}" ne correspond pas
à "o" dans "Bob," mais aux deux premiers "o" dans "fooooot".
{n,}
Correspond à au moins n fois le caractère. Par exemple, "o{2,}" ne correspond pas à
"o" dans " Bob", mais à tous les "o" dans "fooooot".
"o{1,}" équivaut à "o+" et "o{0,}" équivaut à "o*".
{n,m}
Correspond à au moins n et à au plus m fois le caractère. Par exemple, "o{1,3}"
correspond aux trois premiers "o" dans "foooooot" et "o{0,1}" équivaut à "o?".
x|y
Correspond soit à x soit à y. Par exemple, "z|foot" correspond à "z" ou à "foot".
"(z|f)oo" correspond à "zoo" ou à "foo".
Les caractères spéciaux
Symbole Résumé
b
Délimiteur : correspond à une limite représentant un mot, autrement dit, à la
position entre un mot et un espace.
Par exemple, "erb" correspond à "er" dans "lever", mais pas à "er" dans
"verbe".
t Tabulation.
w Caractères (a-z, A-z, 0-9 et underscore).
W
Tout caractère qui n’est pas une lettre. Équivaut à "[^A-Za-z0-9_]".
^entre les crochets signifie non.
s
Correspond à tout espace blanc, y compris l'espace, la tabulation, le saut de
page, etc. Équivaut à "[ fnrtv]".
S Correspond à tout caractère d'espace non blanc. Équivaut à "[^ fnrtv]".
d Chiffres (0-9).
D Tout caractère qui n’est pas un chiffre.
. Correspond à tout caractère unique, sauf le caractère de nouvelle ligne.
$ Correspond à la fin de la saisie (chaîne ou ligne).
^ Correspond au début de la saisie

2.5.2 Les Groupes
Construction Signification
() Définit un groupe simple.
(?<name>) Groupe de nom "name"
(?i:) Ignore la casse
n
Correspond au groupe précédent (groupe #n)
Par exemple, (w)1 trouve les caractères doubles dans un mot.
k<name> Correspond au groupe précédent spécifié par son nom (name).
2.5.3 Exemples d’utilisation des ER
Voici quelques exemples d’utilisation des expressions régulières.
Exemple 1 : expression régulière pour trouver des mots dupliqués
string input;
string pattern = @"b(w+)s1b";
input = Console.ReadLine();
Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
MatchCollection matches = rgx.Matches(input);
if (matches.Count > 0)
{
Console.WriteLine("{0} ({1} matches):", input,
matches.Count);
foreach (Match match in matches)
Console.WriteLine(" " + match.Value);
}
Exemple 2 : Adresse email valide
Regex valideMail = new
Regex(@"^[a-zA-Z0-9_.-]{4,30}@{1}[a-zA-Zd.-]{3,63}.{1}[a-zA-Z]{2,4}$");
Console.Write("Votre courriel : ");
string monCourriel = Console.ReadLine();
if (valideMail.IsMatch(monCourriel))
Console.WriteLine("adresse correcte!");
else
Console.WriteLine("adresse incorrecte!");

Exemple 3 : Suppression des espaces inutiles
// Suppression des espaces inutiles
string input = " Ce texte contient des espaces ";
string pattern = "s+";
string remplacement = " ";
Regex rgx = new Regex(pattern);
string resultat = rgx.Replace(input, remplacement);
Console.WriteLine("Chaîne d'origine: {0}", input);
Console.WriteLine("chaîne transformée: {0}", resultat);

3 Les structures de décision et de répétition
3.1 Les opérateurs
Les différentes catégories d’opérateurs sont :
- Les opérateurs de relation :
>, >=, <, <=, ==(égal), !=(différent)
- Les opérateurs logiques :
&&, &, ||, | , !
Exemples :
Si x=5, y=10
(x > 5) && (y == 10) // false
- Le second opérande n’est pas évalué
(x > 5) & (y ==10) // false
(x == 5) || (y == 12) // true
- Le second opérande n’est pas évalué
(x == 5) | (y ==12) // true
! (x == 7) // true

3.2 Les instructions de décisions
3.2.1 Les tests
Le test d’une condition se fait par l’instruction if dont la syntaxe est la suivante :
if (condition)
instruction(s)_1 // Si condition vraie
[else
instruction(s)_2] // Si condition fausse
Ce qui est entre [ ] étant facultatif.
Exemple
3.2.2 L’instruction switch
L’instruction switch permet de traiter plusieurs cas en une seule instruction. Sa syntaxe est la
suivante :
switch (expression) {
case constante-1:
instruction(s)
instruction de saut
case constante-2:
instruction(s)
instruction de saut
case constant-3:
...
...
[default:
instruction(s)
instruction de saut ]
}

Exemple
Exécution en cascade du switch : tant que l’instruction switch n’a pas rencontré un
break, l’exécution se poursuit en séquence.
switch(n)
{
case 1: // descend jusqu’au cas 3
case 2: // descend jusqu’au cas 3
case 3:
Console.WriteLine("case1 & 2 arrivent ici!");
break;
// ...
}

3.2.3 Expression conditionnelle
Une expression conditionnelle se fait grâce à l’opérateur ternaire ( ? : ) dont la syntaxe est :
condition ? expression_siVrai : expression_siFaux
Exemple:
resultat = (x != 0.0) ? Math.Tan(x) : 1.0;
Identique à :
if (x != 0.0)
resultat = Math.Tan(x);
else
resultat = 1.0;
3.3 Les instructions de répétitions
Les instructions de répétitions se font par l’intermédiaire de boucles qui sont au nombre de 3 :
for, while et do while.
3.3.1 Boucle for
La boucle « for » correspond à la structure « Pour » en algorithmique. Sa syntaxe est la suivante :
for ([initialisation]; [contrôle]; [incrémentation])
instruction(s)
Exemple :
for (int compteur = 1; compteur <= 5; compteur ++)
{
Console.WriteLine(compteur);
}
• continue et break
Ces 2 instructions permettent de réaliser des ruptures de séquences dans les boucles.
for (int compteur = 1; compteur <= 10; compteur +=2)
if (compteur == 3) continue;
 Permet de sauter directement à l’étape compteur = 4.

for (int compteur = 1; compteur <= 10; compteur +=2)
if (compteur == 7) break;
 Sort de la boucle quand compteur == 7
Comme le montrent ces exemples, ils correspondent à des « goto » cachés et de ce fait, doivent
être évités au possible.
3.3.2 Boucle while
La boucle while correspond à l’instruction ‘Tant que’ en algorithmique. Sa syntaxe est :
while (expression)
instruction(s);
L’instruction peut ne pas s’exécuter si l’expression est fausse.
Exemple:
int compteur = 1;
while (compteur != 0)
{
compteur ++;
if (compteur == 2) continue; // Saute la valeur 2
if (compteur > 5) break; // Termine la boucle
console.WriteLine(compteur );
}
3.3.3 Boucle do-while
La boucle « do while » traduit une instruction du type « répéter jusqu’à » et sa syntaxe est donnée par :
do
instruction (s)
while (expression);
Exemple :
int x = 0;
do
{
x++;
if (x%2 != 0) // si le nombre est impair
continue;
if (x == 8)
break; // termine la boucle
console.WriteLine(x);
}
while(x < 100);

3.4 Les tableaux
Les tableaux permettent de stocker en mémoire des données du même type. En C#, un tableau
(array) est un type référence qui contient une séquence de variables d’un type donné (classe
System.Array)
Exemples de tableaux :

Tableaux multi-dimensionnels
Tableau multidimensionnel rectangle
int[,] matrice = new int [3,8]
Accès aux éléments :
matrice[0,0] = 133;
Tableau multidimensionnel en escalier
int[][] tbl = new int[8][];
tbl[0] = new int[3];
Accès aux éléments :
tbl[1][3] = 43;
Remarques sur les tableaux :
Le contrôle des bornes se fait par le runtime, et en cas de dépassement l’exception
IndexOfOutRangeException est levée.
Il existe d’autres structures de données qui permettent une modification dynamique du nombre
d’éléments. Voir la classe System.Collections qui contient les structures prédéfinies
ArrayList, HashTable, …
3.4.1 Utilisation des Propriétés et Méthodes avec les tableaux
Comme toute classe prédéfinie, la classe Array possède des propriétés et des méthodes prêtes à
être utilisées et dont nous présentons quelques-unes :
• La propriété Length donne le nombre d’éléments d’un tableau
int[,] monArray= new int[10,4];
Console.WriteLine(monArray.Length); // Affiche 40
• La propriété Rank donne le nombre de dimensions d’un tableau
int[,] monArray= new int[1, 3]; // 2 dimensions
int[,,] tonArray= new int[10, 4, 5]; // 3 dimensions
Console.WriteLine(monArray.Rank); // 2
Console.WriteLine(tonArray.Rank); // 3

3.4.2 Utilisation des tableaux
• La méthode Array.Sort permet de trier un tableau
int[] monArray = { 3, 4, 56, 8 };
Array.Sort(monArray); // 3,4,8,56
• La méthode Array.Reverse permet d’inverser un tableau
int[] monArray = { 3, 4, 8, 56 };
Array.Reverse(monArray); // 56,8,4,3
• Pour redimensionner un tableau on utilise Array.Resize
int [] monArray = { 1, 2, 3 };
string[] tonArray = { "Tom", "Dick", "Harry" };
Array.Resize(ref monArray, 6);
Array.Resize(ref yourArray, 6);

3.4.3 La boucle foreach
Une boucle foreach permet de parcourir les éléments d’une liste, a fortiori d’un tableau. Sa
syntaxe est la suivante :
foreach (type identificateur in expression) instruction(s);
Exemple:
int[,] monIntArray = { {1, 3, 5},{2, 4, 6} };
Console.WriteLine("nb d’éléments:{0}", monIntArray.Length
foreach(int i in IntArray)
Console.Write("{0} ", i);

4 Classes et objets
4.1 Introduction
4.1.1 Limites de l’approche procédurale
Les données et fonctions sont définies séparément. On doit donc passer les données en
paramètre à chaque fonction. Ceci pose :
• Le problème de la protection des données puisque les champs sont accessibles à tous ;
• Le problème de l’encapsulation en général.
4.1.2 Encapsulation et concept d’objet
En conception orientée objet, les données et les fonctions qui les manipulent sont regroupées
dans une même entité : l’objet. Les détails d’implémentation sont donc cachés et l’extérieur n’a
accès aux données qu’au travers de l’interface de l’objet.
Les avantages sont nombreux :
• Abstraction de données,
• Modularité,
• Facilités de modification (couplage faible),
• Réutilisabilité,
• Lisibilité des programmes: détails d’implémentation cachés.
4.2 Classes
Ce sont des types référence définis par l’utilisateur. Elles sont similaires aux classes C++ ou
Java. Leurs caractéristiques sont :
• L’héritage simple sur la classe ;
• Elles peuvent implémenter de multiples interfaces ;
• Le contrôle de l’accès aux membres se fait par les modificateurs d’accès :
public, private, internal, protected, protected internal
• Le mode par défaut est private ;
• Les membres des classes sont des :
• Constantes, champs (fields), méthodes, opérateurs (constructeurs et destructeurs);
• Propriétés, indexeurs, évènements ;
• Membres par classe (static) ou par instance ;
• Les classes sont instanciées par l’opérateur new.

4.2.1 Ajout d’une classe dans VS
4.2.2 Exemple de classe
Définition de variables et instanciation

4.2.3 Niveaux d’accessibilité des classes
Une classe peut avoir l’un des niveaux d’accessibilité suivants :
Public : pas de restriction d’accès,
Internal : accès limité aux classes du même assembly (par défaut).
Les classes imbriquées peuvent également avoir l’un des niveaux d’accessibilité suivants :
private: accès limité à la classe « englobant »
protected: accès limité à la classe englobant et aux classes dérivées
protected internal: accès limité aux classes de l’assembly et aux classes dérivées
qui sont dans un autre assembly.
Exemple d’accessibilité :
class globale
{
protected class Point
{
public int x; //champs accessibles aux autres
// classes.
public int y;
}
class Program
{
static void Main(string[] args)
{
Point p1 = new Point();
p1.x = 33;
p1.y = 22;
Console.WriteLine("x = {0}, y = {1}", p1.x, p1.y);
}
}
}

4.2.4 Variables membres (champs)
Une variable membre est caractérisée par :
• Un niveau d’accessibilité
• Un type
• Une valeur par défaut (optionnelle)
Exemple:
protected string nomEmploye = "Durand";
Une variable peut être déclarée « static ». Elle est alors partagée entre les différentes instances
de la classe.
Exemple :
public static string nomCompagnie;
Une variable peut-être déclarée « readonly » pour empêcher sa modification après la
construction de l’objet. Une valeur ne peut lui être assignée que lors de sa déclaration ou dans le
constructeur.
Exemple:
public readonly int age = 45;
Une constante doit avoir sa valeur fixée à la compilation.
Exemple:
protected const int NBMAX = 100;
4.2.5 Fonctions membres et méthodes
Les fonctions membres (méthodes) sont déclarées et implémentées au même endroit. Elles sont
caractérisées par :
• Un niveau d’accessibilité,
• Un type de retour (éventuellement void) et
• Une liste de paramètres.
Exemple :
public int MaMethode() {}
L’accessibilité est private par défaut. Une méthode peut être déclarée « static ». On
l’appelle alors via le nom de la classe et non pas via une instance.

Depuis la version 4, il y a des paramètres par défaut en C#. On peut donc définir une fonction en
précisant des valeurs par défaut à certains paramètres, comme dans l’exemple :
void optMethode(int un, double deux=0.0, string trois="salut")
Un appel possible à cette méthode est :
optMethode(99);
Par défaut, les paramètres sont passés par valeur. Il existe cependant un autre type de passage de
paramètres via ref.
• Surcharge de méthodes : la signature d’une méthode est caractérisée par son nom et la
signature des paramètres (y compris le type de passage des paramètres).
Une méthode peut également être déclarée « sealed », ce qui empêche de la surcharger dans
une classe dérivée.
4.2.6 Les propriétés
Les propriétés sont un mécanisme pour exposer des données. De l’extérieur, cela ressemble à une
variable publique. Elles permettent de cacher les détails d’implémentation et d’ajouter un
traitement additionnel (validation, tracing, …).
Exemple:
Depuis C# 3.0 il est possible d'implémenter les propriétés automatiquement ; ce qui rend la
déclaration de propriété plus concise quand aucune logique supplémentaire n'est requise dans les
accesseurs de propriété.
public string Nom { get; set; }
public int ClientID { get; set; }
Depuis C#6, il est possible de les initialiser :
public string Prenom { get; set; } = "Jane";
Public class Personne
{
private string nom;
public string Nom
{
get {return nom;}
set {nom = value;}
}
}
Personne unePersonne = new Personne ();
unePersonne.Nom = "Dupont";
Création automatique dans VS:
Bouton droit  Refactoriser  Encapsuler le champ.

4.2.6.1 Propriétés statiques

4.2.6.2 Propriétés readonly
On peut définir une propriété en lecture seule en ne fournissant que le code du get :
Les propriété auto-implémentée en lecture seule ne peuvent être initialisées que dans leurs
déclarations ou dans les constructeurs.
En C#6 il est possible d’initialiser une propriété auto-implémentée dans sa déclaration en
utilisant la syntaxe suivante :
Type PropertyName { get; set; } = initializer;
public class Produit
{
public decimal Prix { get; set; } = 10.25;
}

4.2.6.3 Accessibilité des accesseurs
Chaque accesseur a sa propre accessibilité :
public string NomEmploye
{
get { return nomEmploye;}
protected set { nomEmploye = value; }
}
Les modificateurs d'accès ne sont autorisés que sur l'un des accesseurs – habituellement set.
Si l’on a qu’un seul accesseur, alors il n’y a pas de modificateur d'accès sur l'accesseur.
4.2.7 Constructeur et destructeur
Le constructeur et le destructeur sont deux méthodes particulières qui sont appelées
respectivement à la création et à la destruction d'un objet.
4.2.7.1 Constructeurs
Caractéristiques du constructeur :
• Un constructeur est une fonction membre dont le nom est le même que celui de la
classe ;
• Un constructeur n’a pas de type ;
• On peut avoir plusieurs constructeurs ;
• En fonction du nombre et du type des arguments passés à l’appel, le bon constructeur
est choisi.
Il y a 3 catégories de constructeurs :
• Constructeurs d’instance :
Ce sont les constructeurs les plus fréquents et parfois appelés juste ‘constructeurs’. Ils portent le
même nom que la classe, et sont invoqués lors de la création d’un nouvel objet.
• Constructeurs privés :
Ils ne sont utilisés qu’avec des classes qui ne contiennent que des membres statiques.
• Constructeurs statiques :
Ils sont utilisés pour initialiser une classe. Ils sont appelés avant la création de tout objet et avant
tout appel à un membre statique de la classe.

Exemple de constructeur d’instance
class Point
{
public int x, y;
// Constructeur par défaut :
public Point()
{
x = 0;
y = 0;
}
// Un constructeur avec des paramètres
public Point(int x1, int y1)
{
x = x1;
y = y1;
}
}
class MaClasse
{
static void Main()
{
Point p1 = new Point();
Point p2 = new Point(2, 10);
Console.WriteLine("Premier Point : ({0}, {1})", p1.x, p1.y);
Console.WriteLine("Deuxième Point : ({0}, {1})", p2.x, p2.y);
}
}
4.2.7.2 Mot clé « this »
this est une référence sur l’objet courant qui est utilisée pour accéder aux données membres
dans un constructeur d'instance (ou des méthodes accesseurs). Dans ce cas, on peut utiliser les
mêmes noms pour les champs et les paramètres. Ce mot-clé ne peut être utilisé avec les
constructeurs statiques ou les champs.
4.2.7.3 Constructeurs privés
Ils sont utilisés avec des classes qui ne contiennent que des membres statiques.
Les autres classes, sauf celles imbriquées dans la même classe, ne sont pas autorisées à créer des
instances de cette classe.
public class MaClasse
{
private MaClasse() {} // private constructor
public string nomCompagnie;
public string dateEmbauche;
}

Le constructeur privé est un constructeur vide dont le travail est d'empêcher la génération d'un
constructeur par défaut pour la classe. Ainsi, l’instruction :
MaClasse mc = new MaClasse();
Provoque une erreur de protection.
Il est préférable de déclarer static une classe qui ne contient que des membres statiques.
4.2.7.4 Constructeurs statiques
Les constructeurs statiques sont utilisés pour initialiser une classe ou n'importe quelle donnée
statique, ou pour effectuer une action particulière devant être effectuée une seule fois. Ils sont
appelés avant la création de tout objet et avant tout appel à un membre statique de la classe.
class MaClasse
{
// Constructeur statique
static MaClasse()
{
Console.WriteLine("Je suis le constructeur statique! " +
"Je suis appelé automatiquement!");
}
public void MaMethode()
{
Console.WriteLine("Je suis MaMethode. J'ai été appelée après " +
"le constructeur statique!");
}
}
{
public static void Main()
{
MaClasse monObjet = new MaClasse();
monObjet.MaMethode();
}
}
4.2.7.5 Héritage
class MaClasseDerivee: MaClasseBase
{
// ...
}
La classe, MaClasseDerivee hérite de la classe MaClasseBase.
Le symbole (:) est utilisé entre le nom de la classe dérivée et le nom de la classe de base.
L’hérédité signifie que la classe dérivée contient tous les membres de la classe de base.
On peut également ajouter de nouveaux membres aux membres hérités.

4.2.7.6 Règles de contrôle de l'héritage:
Tous les membres de la classe de base sont héréditaires (sauf les constructeurs d’instance, les
destructeurs et les constructeurs statiques).
Un membre dans la classe dérivée avec le même nom que dans la classe de base, cache ce dernier.
Le membre de la classe de base n'est pas accessible par l'intermédiaire de la classe dérivée.
Les fonctions membres dans la classe de base peuvent être remplacées par celles de la classe
dérivée: polymorphisme.
Une classe peut hériter d'une classe seulement (pas d’héritage multiple). Cependant, elle peut
implémenter plus d'une interface.
Les structures ne peuvent pas hériter de classes ou d’autres structures ni être héritées, mais elles
peuvent implémenter des interfaces.
Exemple
class Citoyen
{
string identifiant = "111-2345-H";
string nom = "Pille Mandla";
public void GetInfosPersonnelles()
{
Console.WriteLine("Nom: {0}", nom);
Console.WriteLine("Numéro de carte : {0}", identifiant);
}
}
class Employe : Citoyen
{
string nomCompagnie = "Technology Group Inc.";
string idCompagnie = "ENG-RES-101-C";
public void GetInfo()
{
// Appel à la méthode GetPersonalInfo de la classe de base:
Console.WriteLine("Informations du Citoyen :");
GetInfosPersonnelles();
Console.WriteLine("nInformation sur son emploi :");
Console.WriteLine("Nom Compagnie : {0}", nomCompagnie);
Console.WriteLine("ID Compagnie : {0}", idCompagnie);
}
}
class MainClass
{
{
Employe E = new Employe();
E.GetInfo();
}
}

4.2.7.7 Les destructeurs
Les destructeurs sont utilisés pour détruire les objets. Un destructeur est déclaré ainsi:
~MaClasse()
{
// Instructions de destruction.
}
Ils portent le même nom que la classe, mais sont précédés par ~.
Exemple de destructeur
class Parent // parents
{
~Parent()
{
Console.WriteLine("On appelle le destructeur de Parent.");
}
}
class Enfant : Parent // enfants
{
~Enfant()
{
Console.WriteLine("On appelle le destructeur de Enfant.");
}
}
class GrandEnfant : Enfant // grand enfants
{
~GrandEnfant()
{
Console.WriteLine("On appelle le destructeur de GrandEnfant.");
}
}
{
{
GrandEnfant monObjet = new GrandEnfant();
}
}

4.2.8 Classes partielles
Il est possible de fractionner la définition d'une classe ou d'un struct, ou d'une interface sur
deux fichiers sources ou plus. Chaque fichier source contient une section de la définition de
classe, et toutes les parties sont combinées lorsque l'application est compilée.
public partial class Employee
{
public void DoWork() { }
}
public partial class Employee
{
public void GoToLunch() { }
}
4.2.9 Classes finales
Lorsqu'il est appliqué à une classe, le modificateur ‘sealed’ empêche les autres classes d'en
hériter.
class A
{}
sealed class B : A
{}
Dans cet exemple, la classe B hérite de la classe A, mais aucune classe ne peut hériter de B.
4.3 Les structures : Struct
Les structures sont similaires aux classes, mais diffèrent par un certain nombre de
caractéristiques :
- Ce sont des types valeur définis par l’utilisateur donc alloués sur la pile ;
- Elles héritent toujours d’objet ;
- Elles sont idéales pour des objets ‘légers’ ;
- int, float, double, etc., sont des structures ;
- Elles permettent la définition de types primitifs par l’utilisateur
Complex, point, rectangle, color, rational
- Elles supportent l’héritage multiple des interfaces ;
- Elles ont les même membres que les classes ;
- Les contrôles d’accès sont : public, internal, private;
- Elles sont Instanciées par l’opérateur new;
- Elles sont implicitement sealed, ce qui veut dire qu’il est impossible d'en hériter.

Exemple
4.3.1 Classes et Structures
class CPoint { int x, y; ... }
struct SPoint { int x, y; ... }
CPoint cp = new CPoint(10, 20);
SPoint sp = new SPoint(10, 20);

4.4 Visual Studio et les classes
4.4.1 Diagramme de classes
Il est possible de créer ou de visualiser un diagramme de classes dans Visual studio. Celui-ci est
accessible à partir de l’explorateur de solutions. Il permet de rajouter des classes et leurs
membres.
4.4.2 Documentation XML
On peut créer automatiquement une documentation XML pour documenter les classes et leurs
membres. Pour cela on suit les étapes suivantes :
Projet  Propriétés  Onglet Générer  Boîte sortie : spécifier un nom de fichier XML de
documentation.
Le fichier XML sera généré à la compilation et accessible à partir du répertoire du projet.
Les balises de documentation précèdent n’importe quel membre du projet et sont introduites par
///.
Exemples de balises proposées:
<summary>, <para>, <param>, <description>, <permission>,
<remarks>, …

4.5 Classes .NET d’usage courant
4.5.1 Fonctions mathématiques
Classe: System.Math
Cette classe ne contient que des champs et méthodes statiques. Parmi les méthodes disponibles
on peut trouver :
Méthodes numériques multi-types: Abs, Min, Max et Sign
Méthodes trigonométriques: Cos, Sin, …
Méthodes puissances : log et exp
Round, Ceiling, Floor
Exemple:
4.5.2 Dates et intervalles de temps
2 classes sont disponibles :
System.DateTime dont l’instance est une date.
System.TimeSpan: dont l’instance est un intervalle de temps.
Exemples:
DateTime t = new DateTime(2014,10,19,18,0,0);
string strDate = t.ToShortDateString();
string strTime = t.ToShortTimeString();
int day = t.DayOfYear;
DateTime now = DateTime.Now;
DateTime dans1Mois = t.AddMonths(1);
DateTime t2 = Convert.ToDateTime("2014/10/20");
int nbJours = DateTime.DaysInMonth(2014,2);
4.5.3 Accès au système de fichiers
L’espace de noms System.IO contient les classes permettant de manipuler les répertoires et les
fichiers. Parmi les classes intéressantes on dénombre les classes pour :
• La manipulation des répertoires: Directory et DirectoryInfo
• La manipulation des fichiers: File et FileInfo
• La manipulation des chemins d’accès: Path
• La lecture / écriture dans des streams: StreamWriter et StreamReader, …

Exemple:
string srcPath = "c:temp";
if (!Directory.Exists(srcPath))
{
Console.WriteLine("Le repertoire n'existe pas!");
}
else
{
string[] lstRepertoires = Directory.GetDirectories(srcPath);
string[] lstFichiers = Directory.GetFiles(srcPath);
DirectoryInfo df = new DirectoryInfo(srcPath);
foreach (FileInfo fileinfo in df.GetFiles())
Console.WriteLine(fileinfo.FullName);
string testFilePath = srcPath + "test.txt";
StreamWriter sw = File.CreateText(testFilePath);
sw.WriteLine("Test ....");
sw.Close();
}

5 Les fonctions membres
5.1 Définition des fonctions membres
Tous les membres d'une classe ou d’une structure (à l'exception des champs et des constantes)
sont des fonctions membres :
Méthodes
Propriétés
Événements
Indexeurs
Opérateurs définis par l’utilisateur
Constructeurs
Destructeurs
• Le polymorphisme
Soit, par exemple, une méthode appelée DessineFenetre. On peut associer cette méthode
avec divers objets qui représentent les différents types de fenêtres.
Selon l'objet associé à la méthode, le résultat va être différent.
monBouton.DessineFenetre(); // dessine un bouton
monMsg.DessineFenetre(); // dessine une message box
maSurface.DessineFenetre(); //dessine une fenêtre à peindre
5.2 Méthodes virtuelles et redéfinies
Pour utiliser les méthodes polymorphes on déclare la méthode DessineFenetre() avec le
mot-clé virtual dans la classe de base:
public virtual void DessineFenetre() {
// La définition de la méthode est dans la classe de base.
}
Ensuite, dans chacune des classes qui héritent de la classe de base, on déclare une méthode
DessineFenetre() en utilisant le mot-clé override:
public override void DessineFenetre() {
// La définition de la méthode est dans une des classes dérivées.
}

5.2.1 Redéfinition de méthode
On peut redéfinir une autre méthode qui a le même nom, la signature et la même accessibilité que
dans la classe de base. Quand on redéfinit une méthode, on peut changer son comportement
d'origine dans la classe dérivée. Une méthode redéfinie peut redéfinir toutes les méthodes
déclarées avec les modificateurs suivants:
virtual
abstract
override
Pour qu’une méthode redéfinisse celle de la classe de base, il faut modifier sa déclaration avec le
mot-clé override.
Une méthode abstraite est implicitement virtuelle, et donc peut-être redéfinie sans utiliser le
modificateur virtual (elle ne peut pas de toute façon utiliser ce modificateur).
On ne peut pas utiliser le modificateur virtual avec les modificateurs suivants:
static, abstract ou override.
On ne peut pas combiner le modificateur override avec les modificateurs suivants:
static, abstract, virtual ou new.
5.2.2 Appel aux Membres de la Classe de base
Si on désire appeler une méthode redéfinie de la classe de base on utilise le mot-clé base.
base.GetInformation();
On ne peut pas utiliser le mot-clé base dans une méthode statique.
S’il est nécessaire de construire l'objet de la classe de base avant de construire l'objet de la classe
dérivée, on appelle le constructeur ainsi :
public MaDerivee(int x) : base(x)
{
// ...
}
Ceci est le constructeur de la classe MaDerivee, qui construit l'objet de la classe de base à la
volée.

5.2.3 Redéfinition des méthodes Virtuelles de la Classe de Base
// La classe de base :
public class AiresClass
{
// champs:
protected double x, y;
// Constructeurs:
public AiresClass()
{ }
public AiresClass(double x, double y)
{
this.x = x;
this.y = y;
}
// Méthodes:
public virtual double Aire()
{
return 0;
}
}
// La classe Point utilise un constructeur
sans paramètres :
class Point : AiresClass
{
public Point() : base()
{ }
}
// La classe Cercle :
class Cercle : AiresClass
{
public Cercle(double r): base(r, 0)
{ }
public override double Aire()
{
// L'aire d'un cercle.
// Le rayon est représenté par x:
return Math.PI * x * x;
}
}
// La classe Sphere :
class Sphere : AiresClass
{
public Sphere(double r): base(r, 0)
{ }
{
// Le rayon est représenté par x:
return 4 * Math.PI * x * x;
}
}
// La classe Cylindre:
class Cylindre : AiresClass
{
public Cylindre(double r, double h)
: base(r, h)
{ }
{ // x : rayon y : hauteur
return 2*Math.PI *x*x + 2*Math.PI*x*y;
}}
class MaClasse
{
{
// Lire les valeurs au clavier et les convertir:
Console.Write("Entrer le rayon: ");
double rayon = Convert.ToDouble(Console.ReadLine());
Console.Write("Entrer la hauteur: ");
double hauteur = Convert.ToDouble(Console.ReadLine());
// Créer les objets:
Point monPoint = new Point();
Cercle monCercle = new Cercle(rayon);
Sphere maShpere = new Sphere(rayon);
Cylindre monCylindre = new Cylindre(rayon, hauteur);
// Afficher les résultats:
Console.WriteLine("Aire du point = {0:F2}",
monPoint.Aire());
Console.WriteLine("Aire du cercle = {0:F2}",
monCercle.Aire());
Console.WriteLine("Aire de la sphère = {0:F2}",
maShpere.Aire());
Console.WriteLine("Aire du cylindre = {0:F2}",
monCylindre.Aire());
}
}

5.3 Classes et méthodes abstraites
Le but d'une classe abstraite est d’être héritée par d'autres classes. Elle ne peut donc pas être
instanciée. Une méthode abstraite est, par défaut, une méthode virtuelle. Elle ne peut exister qu'à
l'intérieur d'une classe abstraite.
abstract class MaBaseClasse // classe abstraite
{
public abstract void MaMethode(); // méthode abstraite
...
}
Les mots clés suivants ne sont pas permis dans la déclaration d’une méthode abstraite : static,
virtual.
Exemple :
// Class abstraite :
abstract class ClassDeBase
{
// Champs:
protected int nombre = 100;
protected string nom = "Dale Sanders";
// Méthode abstraite :
public abstract void MaMethode();
// Propriétés abstraite :
public abstract int Nombre
{ get; }
public abstract string Nom
{ get; }
}
// Hériter de la classe:
class MaClasseDerivee : ClassDeBase
{
// Surcharge des propriétés:
public override int Nombre
{
get { return nombre; }
}
public override string Nom
{
get { return nom; }
}
// Surcharge de la méthode:
public override void MaMethode()
{
Console.WriteLine("Nombre = {0}",
Nombre);
Console.WriteLine("Nom = {0}", Nom);
}
}
class ClassePrincipale
{
{
MaClasseDerivee monObjet = new MaClasseDerivee();
monObjet.MaMethode();
}
}

5.4 Surcharge de méthodes
La surcharge de méthodes consiste à donner le même nom à plus d'une méthode et laisser le
compilateur charger la méthode appropriée en fonction du nombre et du type de paramètres.
Exemple: La fonction est surchargée
int AuCarre(int x)
double AuCarre (double f)
Elle peut être appelée de 2 manières différentes :
AuCarre (3.25);
AuCarre (44);
Note: Le lien entre la méthode spécifique et l'appel est fait au moment de la compilation, c’est ce
que l’on appelle une liaison statique (ou anticipée).
Un autre cas est possible quand les paramètres sont de même type mais en nombres différents.
void MaMethode(int m1) { }
void MaMethode(int m2, int m3) { }
Exemple
class MaClasse
{
// Paramètre de type string :
static void MaMethode(string s1)
{
Console.WriteLine(s1);
}
// Paramètre de type entier :
static void MaMethode(int m1)
{
Console.WriteLine(m1);
}
// Paramètre de type double :
static void MaMethode(double d1)
{
Console.WriteLine(d1);
}
static void Main()
{
string s = "Voilà ma chaîne";
int m = 134;
double d = 122.67;
MaMethode(s);
MaMethode(m);
MaMethode(d);
}
}

5.5 Passage de Paramètres
Il y a deux façons de passer un paramètre à une méthode :
• par valeur (passage par défaut) ou
• par référence.
5.5.1 Passage par référence
Le passage de paramètres par référence permet de modifier les valeurs des variables de manière
persistante. Pour passer un paramètre par référence, on déclare le paramètre avec le mot-clé ref.
Exemple
// Exemple Permuter
class MaClasse
{
static void Permuter(ref int x, ref int y)
{
int temp = x;
x = y;
y = temp;
}
static void Main()
{
int x = 25;
int y = 33;
Console.WriteLine("Avant la permutation: x={0}, y={1}", x, y);
Permuter(ref x, ref y);
Console.WriteLine("Après la permutation: x={0}, y={1}", x, y);
}
}
Il y a trois modificateurs de paramètres, qui permettent la modification de la valeur des variables
après le retour à la méthode appelante. Ces trois modificateurs sont : ref, out et params.
Lorsqu’on utilise ref pour passer une variable à une méthode, la variable doit être initialisée en
premier, sinon on génère une erreur du compilateur.
Le modificateur out ne nécessite pas l'initialisation de la variable avant de la transmettre à la
méthode, mais l'initialisation doit se faire dans la méthode elle-même.
private void methodeTest(out int resultat) {}
L’appel se fait par:
methodeTest(out n);
Le mot clé params est utilisé avec des tableaux. Il permet de transmettre n'importe quel
nombre de paramètres à une méthode sans qu’il soit nécessaire de les déclarer dans un tableau.
Ce mot clé est requis uniquement dans la déclaration de la méthode.

Par exemple soit la fonction :
static void MaMethode(params object[] monObjArray)
L’appel à la méthode se fait par :
MaMethode(123, 'A', "Ma chaine originale");
Les paramètres passés dans cet appel sont tous du type object, ce qui signifie qu’ils peuvent
inclure tous les types hérités de la classe object.
Exemple :
{
// Déclaration de MaMethode qui utilise des paramètres entiers :
public void MaMethode(params int[] monIntArray)
{
Console.WriteLine("Ma liste d'entiers originale:"); // Liste originale
for (int i = 0; i < monIntArray.Length; i++)
Console.WriteLine(monIntArray[i]);
Console.WriteLine();
monIntArray[1] = 555; // Changer le 2ème élément
Console.WriteLine("Ma liste d'entier après le changement:"); //après le changement
for (int i = 0; i < monIntArray.Length; i++)
Console.WriteLine(monIntArray[i]);
}
// Déclaration de MaMethode qui utilise des paramètres objets :
public void MaMethode(params object[] monObjArray)
{
Console.WriteLine("Ma liste d'objets originale:"); //avant le changement
for (int i = 0; i < monObjArray.Length; i++)
Console.WriteLine(monObjArray[i]);
// Changer le 3ème élément:
monObjArray[2] = "Ma nouvelle chaîne";
Console.WriteLine("Ma liste d'objets après le changement:"); //après le changement:
for (int i = 0; i < monObjArray.Length; i++)
Console.WriteLine(monObjArray[i]);
}
}
class MainClass
{
static void Main()
{
// Déclaration d'un tableau d'objets:
object[] maObjListe = new object[] { 123, 'A', "Mon ancienne chaine" };
// Passer 4 entiers à la "première" MaMethode:
mc.MaMethode(11, 22, 33, 44); // utiliser des paramètres numériques
// Passer un tableau d'objets à la "2ème" MaMethode
mc.MaMethode(maObjListe); // utiliser un tableau d'objets
}
}

5.6 Propriétés sous la forme d’expressions
C# 6 a introduit une syntaxe concise pour :
• Méthodes qui contiennent seulement une instruction return ;
• Propriétés read-only dans lesquelles get contient seulement un return ;
• Méthodes qui contiennent une instruction simple.
Exemple :
La fonction :
static int Cube(int x)
{
return x * x * x;
}
s’écrira en C#6
static int Cube(int x) => x * x * x;
5.7 Les indexeurs
Les indexeurs, permettent de manipuler des classes comme des tableaux ou des collections. On
peut donc accéder aux éléments de l’indexeur en utilisant les crochets ([]).
Un indexeur est similaire aux propriétés puisqu’il peut aussi utiliser les accesseurs get et set
pour exprimer ses caractéristiques.
La déclaration d’un indexeur est de la forme:
indexer-type this [parameter-type parameter]
{
get {};
set {};
}

où:
indexer-type est le type de l’indexeur.
parameter-type est le type du paramètre.
parameter est un paramètre ou une liste de paramètres
Exemple
class MaClasse
{
private string[] monTableau = new string[10];
// Déclaration de l'indexeur :
public string this[int index]
{
get
{
return monTableau [index];
}
set
{
monTableau [index] = value;
}
}
}
public class MainClass
{
{
MaClasse s = new MaClasse();
// Utiliser l'indexeur pour initialiser les éléments #1 et #2:
s[1] = "Tom";
s[2] = "Edison";
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Element #{0}={1}", i, s[i]);
}
}
}
5.7.1 Utilisation des indexeurs
Il est courant d'utiliser les accesseurs set et get pour contrôler les limites de l'indexeur et éviter
les erreurs. Par exemple:
if (!(index < 0 || index >= 10))
// ...
Il est permis aux interfaces d'avoir des indexeurs. Ils sont déclarés de la même manière avec les
exceptions suivantes:
- Les indexeurs des interfaces n’utilisent pas les modificateurs.
- Il n'y a pas d’implémentation d’accesseurs dans les interfaces.

5.8 La surcharge des opérateurs
La surcharge permet d’assigner de nouveaux rôles pour certains opérateurs. Par exemple, on peut
surcharger l’opérateur ‘+’ pour la classe Point :
public static Point operator+(Point p1, Point p2)
{
// Implémentation de l’opérateur +
// Voir exemple
}
D’autres exemples sont : operator-– , operator==
Exemple
public class Point
{
public int x;
public int y;
// Constructeur:
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
// Surcharge de l'opérateur +:
public static Point operator +(Point p1, Point p2)
{
// Retourner la somme comme un point:
return new Point(p1.x + p2.x, p1.y + p2.y);
}
static void Main()
{
// Ajouter les 2 obbjets Point utilisant l'opérateur + surchargé:
Point sum = p1 + p2;
// Afficher les objets:
Console.WriteLine("Point #1: ({0}, {1})", p1.x, p1.y);
Console.WriteLine("Point #2: ({0}, {1})", p2.x, p2.y);
Console.WriteLine("Sum of the two points: ({0}, {1})", sum.x, sum.y);
}
}

5.8.1 Opérateurs surchargeables
5.8.2 Redéfinir la méthode ToString()
Cette redéfinition est très utile pour l’affichage. Par exemple, au lieu de :
Console.WriteLine("Point #1: ({0},{1})", p1.x, p1.y);
On voudrait :
Console.WriteLine("Point #1: {0}", p1);
Pour cela on surcharge la méthode ToString(). On réalise la surcharge de la manière
suivante :
// Surcharge de la méthode ToString
public override string ToString()
{
return (String.Format("({0}, {1})", x, y));
}
5.9 Les attributs
Les attributs sont des informations additionnelles qui permettent de modifier les déclarations des
entités de programme (types, membres, paramètres, etc., …). Ils servent à différentes choses
comme par exemple marquer une méthode comme obsolète, indiquer une compilation
conditionnelle, …
Ils sont dérivés de la classe abstraite System.Attribute. L’attribut est mis entre [].

Exemple:
[method: DllImport("user32.dll")]
C’est un attribut qui permet d’utiliser du code ‘unsafe’.
Les éléments cibles des attributs sont:
Assembly, field, event, method, parameter, property, return, type
Autres exemples d’attributs
Obsolète:
[Obsolete("Vous devriez coder en Csharp! ", true)]
public void CodeEnCPlusPlus()
{
// Le corps de la méthode obsolète.
}
Quand on compile cette méthode, le compilateur génère l’erreur : 'MaClasse.CodeEnCPlusPlus()' is
obsolete: ‘Vous devriez coder en Csharp!‘. Si le 2ème paramètre est à false, le compilateur génère un
warning, sinon c’est une erreur fatale.
Conditionnel:
[Conditional("MACONSTANTE")]
public void MaMethode(string s) {}
MaMethode n’est exécutée que si la constante MACONSTANTE est définie avec une
directive: #define MACONSTANTE

6 Les Exceptions
6.1 Erreurs et exceptions
En C#, une exception est un objet de la classe System.Exception ou une de ses
sous-classes. Les mots-clés utilisés pour traiter les exceptions sont : throw, catch, et finally.
La gestion des exceptions requiert l’utilisation des mots-clés :
- throw: Pour lancer ou relancer une exception.
- try-catch: Pour capturer et traiter une exception.
- try-finally: Pour libérer les ressources après le lancement de l’exception
indépendamment de sa capture.
- try-catch-finally: Pour capturer et traiter une exception et libérer les ressources.
6.2 Lancer une Exception
throw [expression];
où:
expression est l’exception.
6.3 Exemples d’exceptions :
- InvalidCastException
- OverFlowException
- ArgumentNullException
- ArithmeticException
- DivideByZeroException
Par exemple, l’appel à la méthode System.IO.File.OpenRead() peut provoquer le
lancement des exceptions suivantes :
- SecurityException
- ArgumentException
- ArgumentNullException
- PathTooLongException
- DirectoryNotFoundException
- UnauthorizedAccessException
- FileNotFoundException
- NotSupportedException

Exemple
string monString = "Salut.";
// Afficher la chaîne
Console.Write("La chaîne est {0}", monString);
monString = null;
if (monString == null)
{
throw new ArgumentNullException(); // lancer l'exception
}
// Cette ligne n'est pas exécutée:
Console.Write("monString est null.");
6.4 Capturer une Exception
Pour capturer une exception, le code suspect est mis dans un bloc try :
try
{// Le code à protéger. }
Le gestionnaire de l’erreur est mis dans un bloc de capture:
catch [(declaration)]
{ // Le code du gestionnaire d’exception. }
Où declaration est la déclaration de l’objet exception (optionnel).
Exemple
class MaClasse
{
public void MaMethode(string monString)
{
if (monString == null)
// Lancer l'exception
throw (new ArgumentNullException());
}
{
MaClasse MaClasse = new MaClasse();
// Le code suspect
try
{
string monString = null;
MaClasse.MaMethode(monString);
}
// Traitement de l'exception:
catch (Exception e)
{
Console.WriteLine("L'exception suivante est capturée : n{0}", e);
}
// Continuer après le traitement de l'exception:
Console.WriteLine("Le programme continue ...");
}
}

6.5 Organisation des gestionnaires
Quand on utilise plus d'un bloc catch, il est important de capturer les exceptions spécifiques
avant les moins spécifiques. Si un gestionnaire adéquat n’existe pas dans la méthode actuelle, le
moteur d’exécution cherche dans les autres méthodes.
Exemple:
catch (ArithmeticException e) // premier gestionnaire
{
//...
}
...
...
catch (Exception e) // dernier gestionnaire
{
// ...
}
6.6 Instruction try-finally
L’utilisation du mot-clé finally permet d’introduire un code de nettoyage qui sera exécuté
dans tous les cas. Cela permet, par exemple de libérer des ressources.
try
{ // bloc-try }
finally
{ // bloc-finally }
Où :
try-block : contient le code suspect à essayer
finally-block : contient les instructions de ‘nettoyage’ à exécuter indépendamment
de l'exception lancée.
6.7 Instruction try-catch-finally
try
{ // bloc-try }
catch
{ // bloc-catch }
finally
{ // bloc-finally }

6.8 Exceptions personnalisées
On peut créer une exception personnalisée en la déclarant comme dérivée de
ApplicationException.
Avantage : personnaliser le texte du gestionnaire pour expliquer l’erreur.
class MonExceptionPersonnalisee: ApplicationException
Un constructeur avec un string comme paramètre est utilisé pour envoyer le message à la
classe héritée:
MonExceptionPersonnalisee(string message): base(message)
{ }
Exemple
// Une exception personnalisée
public class MonException : Exception
{
// Constructeur de la classe MonException:
public MonException(string message): base(message)
{ }
}
static void Main()
{
// Créer une instance de MonException:
MonException e = new MonException("qui contient mon message personnalisé");
try
{
throw e; // Lancer l'exception
}
catch (MonException)
{
// Capturer l'exception:
Console.WriteLine("L'exception {0} a été traitée avec succès.", e);
}
catch
{
Console.WriteLine("Exception inconnue traitée.");
}
finally
{
// Le code dans ce bloc est toujours exécuté:
Console.WriteLine("Le programme continue ici.");
}
// Afficher un message après le bloc finally :
Console.Write("Fin d'exécution.");
}

6.9 Relancer une exception
Cela consiste à envoyer une exception à une autre méthode ou au Main pour avoir plus de
détails. Pour cela on utilise throw sans paramètres:
catch
{ throw; }
Le bloc de capture peut ajouter un message.
Exemple
static void Main()
{
maClasse mc = new maClasse();
try
{
mc.MaMethode1(); // évènement #1
}
catch (Exception e)
{
Console.WriteLine("Capturée dans le Main: {0}", e); // évènement #6
Console.WriteLine("On continue le nettoyage ...");
}
}
public void MaMethode1()
{
try
{
MaMethode2(); // évènement #2
}
catch (Exception)
{
Console.WriteLine("Capturée dans MaMethode1"); // évènement #4
Console.WriteLine("Nettoyage ...");
// Relancer la même exception:
throw; // évènement #5
}
}
{
throw new Exception("lancée par MaMethode2"); // évènement #3
}
6.10 Utilisation de StackTrace
StackTrace permet de garder la trace de l’exception au fur et à mesure qu’elle est capturée.
catch (Exception e)
{
Console.WriteLine("Capturée dans le Main: {0}", e.StackTrace);
Console.WriteLine("On continue le nettoyage ...");
}

6.11 Opérateur de condition null : ?. (C#6)
Le code suivant
{
var exampleObject = new ExampleClass();
try
{
exampleObject.SomeMethod();
}
finally
{
if (exampleObject != null)
{
exampleObject.Dispose();
}
}
}
peut se réécrire en C#6 :
{
var exampleObject = new ExampleClass();
try
{
exampleObject.SomeMethod();
}
finally
{
exampleObject?.Dispose();
}
}
6.12 Filtres d’Exceptions (C#6)
C# 6 a introduit des filtres d’exceptions qui permettent de capturer une basée sur un type et une
condition qui spécifiée dans une clause ‘when’.
catch(ExceptionType name) when(condition)
ou encore dans une exception généralisée:
catch when(condition)
Exemple:
try
{
Console.WriteLine("Filtres d'exception.");
throw new Exception();
}
catch (Exception ) when (
(DateTime.Now.DayOfWeek == DayOfWeek.Saturday) ||
(DateTime.Now.DayOfWeek == DayOfWeek.Sunday))
{
Console.WriteLine("Capturée.");
}

6.13 Nameof (C#6)
Utilisé pour obtenir le nom d’une variable sous la forme d’un string.
Ce qui peut être pratique dans la gestion des exceptions.
Exemple :
if (x == null) throw new ArgumentNullException(nameof(x));
WriteLine(nameof(personne.Addresse.CodePostal)); // affiche "CodePostal"

7 Délégués et Événements
7.1 Définition d'un délégué
Un délégué est un type (référence) qui permet de stocker des références à des fonctions. Il est
utilisé pour encapsuler une méthode d'une signature spécifique et la passer en paramètre. Il est
semblable à un pointeur de fonction en C++, sauf qu'il est de type sécurisé.
Le délégué délègue la méthode associée pour réaliser son travail.
Les délégués sont utiles pour la gestion des événements. Ils sont déclarés de manière similaire aux
fonctions :
• Mot-clé delegate,
• Sans corps de fonction,
• Un type de retour et une liste de paramètres.
On peut déclarer une variable avec le type délégué. Cette variable sera initialisée comme une
référence à toute fonction qui a le même type de retour et la même liste de paramètres que le
délégué. On peut alors appeler cette fonction en utilisant la variable de type délégué comme s'il
s'agissait d'une fonction.
Les avantages de l’utilisation des délégués sont alors :
• La possibilité de passer une variable de type délégué à une fonction comme paramètre,
• la fonction peut utiliser le délégué pour appeler une fonction, quelle qu’elle soit, et sans la
connaître avant l'exécution.
Le mot-clé delegate offre la possibilité de créer des classes particulières, appelées
"délégations", dont les instances sont nommées "délégués".
7.2 Déclaration des délégués
Syntaxe : [modifiers] delegate result identifier ([parameters])
où:
modifiers : est une combinaison valide de modificateurs d’accès plus le modificateur new.
Result : est le type du délégué qui est le même que celui de la méthode encapsulée.
Identifier : est le nom du délégué.
Parameters : est une liste optionnelle de paramètres.

Exemple:
delegate void MonDelegue(object o1, object o2);
Ce délégué peut encapsuler des méthodes avec la même signature :
static void MaMethode(object o1, object o2) { ... }
7.3 Création du délégué
La création se fait selon les étapes suivantes :
1. Déclarer le délégué (dans un namespace ou une classe). Par exemple:
delegate void MonDelegue (object o1, object o2);
2. Déclarer la méthode qui lui sera associée. Exemple:
public static void MaMethode(object id, object nom){…}
Noter que les types de la valeur de retour et des paramètres sont identiques.
3. Créer un objet délégué :
MonDelegue delegObj = new MonDelegue(MaMethode);
Noter que le paramètre du délégué est le nom de la méthode encapsulée.
On peut aussi créer un objet délégué sans utiliser new:
MonDelegue delegObj = MaMethode;
7.4 Invocation du délégué
On utilise les mêmes paramètres utilisés pour appeler la méthode associée. Exemple:
delegObj(119, "Jane Doe");
Ou, à partir d’une méthode :
public static void AppelDelegue (MonDelegue meth)
{
meth(119, "Jane Doe");
}
On peut aussi utiliser la méthode .NET Invoke :

delegObj.Invoke(119, "Jane Doe");
Exemple
// Déclarer un délégué:
delegate void MonDelegue(int n, string s);
class MainClass
{
static void Main()
{
// Instancier la classe:
MaClasse obj = new MaClasse();
// Instancier le delegué:
MonDelegue d = new MonDelegue(obj.MaMethode);
// Invoquer le delegue:
obj.AppelDelegue(d);
}
}
class MaClasse
{
// Une méthode pour invoquer le delegué:
public void AppelDelegue(MonDelegue meth)
{
meth(119, "Jane Doe");
}
// La méthode encapsulée :
public void MaMethode(int id, string nom)
{
Console.WriteLine("ID = {0}nNom = {1}", id, nom);
}
}
7.5 Associer un délégué à plusieurs méthodes
L’association entre un délégué et une méthode est réalisée dynamiquement lors de l’exécution. Le
délégué ne sait pas lors de la compilation, quelle méthode il va encapsuler. Ce qui importe, c’est la
signature et le type de retour de la méthode.
On peut donc associer le même délégué avec plus d’une méthode dans un programme.

Exemple
public class Calc
{
// Declarer un délégué:
public delegate double Calcul(int x, int y, int z);
// Declarer les méthodes:
public static double Somme(int n1, int n2, int n3)
{
return n1 + n2 + n3;
}
public static double Moyenne(int n1, int n2, int n3)
{
return (n1 + n2 + n3) / 3;
}
{
double resultat;
// Instancier le délégué, lui associer Moyenne :
Calcul monCalc = new Calcul(Moyenne);
// Invoquer le délégué:
resultat = monCalc(3, 6, 9);
Console.WriteLine("Moyenne: {0}", resultat);
// Instancier un autre objet et l'associate à Somme :
monCalc = new Calcul(Somme);
// Invoquer le délégué:
resultat = monCalc(3, 6, 9);
Console.WriteLine("Somme: {0}", resultat);
}
}
7.6 Ajouter ou supprimer des délégués
Les délégués peuvent être combinés en utilisant l’opérateur + pour créer un délégué composé.
L’invocation de ce délégué va provoquer l’invocation de ses constituants.
Le but de la composition est d’encapsuler plus d’une méthode dans le même délégué. Cette
opération est le multicasting.
On peut aussi supprimer un délégué d’une composition en utilisant le –.
On peut utiliser += et –=.
De manière similaire, on peut utiliser les méthodes .NET Combine et Remove qui sont membres
de la classe System.delegate.
Exemple

// Déclarer un délégué:
delegate void MonDelegue();
class MaClasse
{
{
Console.Write("MaMethode #1 ");
}
{
Console.Write("MaMethode #2 ");
}
}
class MainClass
{
static void Main()
{
// Instancier MaClasse:
// Déclarer un objet délégué et référencer MaMethode1:
MonDelegue d1 = new MonDelegue(mc.MaMethode1);
// Déclarer un objet délégué et référencer MaMethode2:
MonDelegue d2 = new MonDelegue(mc.MaMethode2);
// Déclarer le délégué d3 en additionnant d1 et d2.
// Cela invoquera MaMethode1 et MaMethode2:
MonDelegue d3 = d1 + d2;
// Déclarer le délégué d4 en retirant d1 de d3.
// Cela invoquera MaMethode2 uniquement:
MonDelegue d4 = d3 - d1;
Console.Write("Invoquer d1, référencer ");
d1();
Console.Write("nInvoquer d2, référencer ");
d2();
Console.Write("nInvoquer d3, référencer ");
d3();
Console.WriteLine("nInvoquer d4, référencer ");
d4();
}
}

7.7 Utiliser les méthodes .NET
// Combiner d1 et d2, pour former d3:
MonDelegue d3 = (MonDelegue) delegate.Combine(d1, d2);
// enlever d1 de d3, pour donner d4:
MonDelegue d4 = (MonDelegue) delegate.Remove(d3, d1);
Quand on utilise les méthodes .NET, il est nécessaire d’utiliser un ‘cast’ pour convertir le
résultat au type delegate.
7.8 Les événements
L'une des utilisations les plus importantes des délégués est la programmation d'événements,
notamment dans l'environnement Windows.
Un clic sur un bouton déclenche un événement pour lequel la réponse à cet événement peut
prendre plusieurs formes.
Le programmeur doit écrire la réponse appropriée à cet événement.
Un événement est reçu (réception) ou émis (émission).
Plusieurs types d'évènements sont possibles :
- Modifier du texte dans une zone de texte,
- Passer à un autre contrôle, …
La réception de l'événement dépend totalement de l'application en développement.
7.8.1 L'utilisation des événements
On commence par déclarer un délégué à utiliser comme gestionnaire (ou récepteur) :
delegate void RightButtonDown(object sender, EventArgs e);
On utilise ensuite le nom du délégué (RightButtonDown) comme type de l’évènement déclaré
avec le mot-clé event.
Par exemple, pour appeler l’évènement PressDown, on le définit comme suit:
event RightButtonDown PressDown;
Le mot clé event protège l'accès au délégué de la manière suivante :
• Il n'est plus possible d'utiliser l'affectation seule (opérateur =), il faut utiliser += ou -= ;
• L'ajout et le retrait sont réalisés de manière synchrone, c-à-d que chaque évènement
attend la fin du précédent pour s'exécuter. Si un évènement lance une exception, les
suivants ne seront pas exécutés;
• Il n'est pas possible d'appeler le delegate en dehors de la classe où l'event est
déclaré.

Exemple:
class MonEventArgs : EventArgs
{
// Champs:
private string stock;
private int variation;
// Propriétés:
public string MonStock
{
get { return stock; }
}
public int MaVariation
{
get { return variation; }
}
// Constructeur:
public MonEventArgs(string s, int c)
{
stock = s;
variation = c;
}
}
class Emetteur
{
public delegate void MonGestionnaire(object source, MonEventArgs e);
public event MonGestionnaire Changement;
// Mettre à jour le stock
public void MettreAJour(string s, int c)
{
MonEventArgs e = new MonEventArgs(s, c);
if (Changement != null)
Changement(this, e);
}
}
// Classe qui reçoit l'évènement
class Recepteur
{
public Recepteur(Emetteur s)
{
// Ajouter l’évènement:
s.Changement += new Emetteur.MonGestionnaire(OnStockChange);
}
void OnStockChange(object source, MonEventArgs e)
{
string plusOuMoins;
if (e.MaVariation > 0)
plusOuMoins = "moins";
else plusOuMoins = "plus";
int ch = Math.Abs(e.MaVariation);
Console.WriteLine("{0} {1} {2}", e.MonStock, plusOuMoins, ch);
}
}

// Classe principale
class Program
{
{
Emetteur s = new Emetteur();
Recepteur r = new Recepteur(s);
// Afficher les résultats:
Console.WriteLine("Ventes 2015:");
s.MettreAJour("tIntroduction à C#:", -20);
s.MettreAJour("tLivres C++:", 11);
s.MettreAJour("tLivres VB .NET:", -15);
s.MettreAJour("tLivres de Science Fiction:", 120);
}
}

8 Les Interfaces
Une interface permet de déclarer le contenu de la classe qui l’implémente. C’est un contrat qui
décrit le comportement de la classe qui implémente l’interface.
Si l’interface contient le nom d’une méthode, la classe qui l’implémente est obligée de contenir
l’implémentation de cette méthode.
8.1 Déclaration de l’interface
interface IMonInterface
{
// membres de l’interface
}
La déclaration peut être modifiée par une combinaison valide de modificateurs d’accès ou par le
mot-clé new. Elle peut aussi être précédée par des attributs.
Les membres d’une interface peuvent être:
• Des Méthodes
• Des Propriétés
• Des Indexeurs
• Des Événements
Cependant, l’interface ne peut pas contenir de champs. Les membres de l’interface sont publics
par défaut et on ne peut pas utiliser de modificateurs d’accès sur les membres.
8.2 Membres
Les membres d’une interface sont des signatures de méthodes, des propriétés, des indexeurs, ou
des évènements. Par exemple:
interface ICompteur
{
void Compter(int i);
int SetCompteur();
}
Une interface peut elle-même implémenter une ou plusieurs interfaces, comme dans l'exemple :
interface IMonInterface: Interface1, Interface2
{
// membres de l’interface
}

Dans cet exemple, IMonInterface implémente Interface1 et Interface2.
8.3 Implémentation de l’interface
L'interface peut être implémentée par une classe ou une structure comme le montre cet exemple :
class MaClasse:IMonInterface
{
// implémentation de la classe
}
Par cette déclaration, la classe MaClasse est tenue de mettre en œuvre tous les membres de
l’interface IMonInterface.
Une classe peut implémenter plus d'une interface:
Une classe peut également implémenter une autre classe en plus des interfaces:
class MaClasse: MaBaseClasse, IMonInterface1, IMonInterface2
{
// implémentation de la classe
}
Exemple
interface IPoint
{
// Propriétés :
int MonX
{
get; set;
}
int MonY
{
get; set;
}
}
class Point : IPoint
{
// Champs:
private int x;
private int y;
// Constructeur:
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
// implementation des propriétés :
public int MonX

{
get { return x; }
set { x = value; }
}
public int MonY
{
get { return y; }
set { y = value; }
}
public static void AfficherMonPoint(IPoint monPoint)
{
Console.WriteLine("({0},{1})", monPoint.MonX, monPoint.MonY);
}
}
class MaClasse
{
static void Main()
{
Point monPoint = new Point(12, 300);
Console.Write("Mon point est créé avec les coordonnées: ");
Point.AfficherMonPoint(monPoint);
}
}
8.4 Utiliser is pour tester les types
Usage :
expression is type
où:
type est une référence à un type
Expression est l’objet à tester
Le résultat est true ou false
Exemple
interface I1
{
}
interface I2
{
}
class Class1 : I1, I2
{
}
class MaClasse
{
static bool TesterType(object obj)
{
if (obj is I1 & obj is I2 & obj is Class1)
return true;
else
return false;

Introduction á C-sharp

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

Similaire à Introduction á C-sharp

Similaire à Introduction á C-sharp (20)

Dernier

Dernier (20)

Introduction á C-sharp