Tlangcdiez

http://www.labo-dotnet.
com

Auteur : Ary Qulor et Mathieu Szablowski
Ver si on 2. 0 10 novembr e 2004
Nombr e de pages : 83

Ecole Suprieure dInformatique de Paris
23. rue Chteau Landon 75010 PARIS
www.supinfo.com

Programmation en C#
SUPINFO DOT NET TRAINING COURSE
Pr ogr ammat i on en C# 2 / 83

ht t p: / / www. l abo- dot net . com
Ce document est la proprit de SUPINFO et est soumis aux rgles de droits dauteurs
Tabl e des mat i r es

1. VUE DENSEMBLE DE LA PLATE-FORME MICROSOFT .NET.......................................................... 6
1.1. PRESENTATION DE LA PLATE-FORME .NET................................................................................................... 6
1.1.1. .NET Framework................................................................................................................................... 6
1.1.2. .NET My Services.................................................................................................................................. 6
1.1.3. Serveurs .NET Entreprise Server .......................................................................................................... 7
1.1.4. Visual Studio .NET................................................................................................................................ 7
1.2. VUE DENSEMBLE DU FRAMEWORK .NET..................................................................................................... 7
1.2.1. .NET Framework................................................................................................................................... 7
1.2.2. Substrat de la plate-forme..................................................................................................................... 7
1.2.3. Services dapplication........................................................................................................................... 7
1.2.4. Common Laguage Runtime ................................................................................................................... 7
1.2.5. Bibliothque de classe........................................................................................................................... 7
1.2.6. ADO.NET.............................................................................................................................................. 7
1.2.7. ASP.NET ............................................................................................................................................... 7
1.2.8. Services Web XML ................................................................................................................................ 8
1.2.9. Interfaces utilisateur ............................................................................................................................. 8
1.2.10. Langages ............................................................................................................................................... 8
1.3. AVANTAGES FRAMEWORK .NET .................................................................................................................. 8
1.3.1. S'appuyer sur les normes et les pratiques du Web ................................................................................ 8
1.3.2. Utiliser des modles d'application unifis............................................................................................. 9
1.3.3. Facile d'emploi pour les dveloppeurs.................................................................................................. 9
1.3.4. Classes extensibles................................................................................................................................ 9
1.4. COMPOSANTS DU FRAMEWORK .NET........................................................................................................... 9
1.4.1. Common Language Runtime ................................................................................................................. 9
1.4.2. Bibliothque de classes du .NET Framework...................................................................................... 10
1.4.3. ADO.NET : donnes et XML............................................................................................................... 10
1.4.4. Formulaires Web et services Web XML.............................................................................................. 11
1.4.5. Interface utilisateur pour Windows..................................................................................................... 12
1.5. LANGAGES DU .NET FRAMEWORK ............................................................................................................. 12
2. VUE DENSEMBLE DU C#........................................................................................................................... 14
2.1. STRUCTURE DU PROGRAMME C#................................................................................................................. 14
2.1.1. Hello World......................................................................................................................................... 14
2.1.2. La classe.............................................................................................................................................. 14
2.1.3. La mthode Main................................................................................................................................. 14
2.1.4. La directive using et l'espace de noms System.................................................................................... 15
2.2. OPERATIONS ELEMENTAIRES DENTREE/SORTIE.......................................................................................... 16
2.2.1. La classe Console................................................................................................................................ 16
2.3. METHODES CONSEILLEES............................................................................................................................ 17
2.3.1. Commentaire dapplications............................................................................................................... 17
2.3.2. Cration dune documentation XML................................................................................................... 17
2.3.3. Gestion des exception.......................................................................................................................... 19
2.4. COMPILATION, EXECUTION ET DEBOGAGE .................................................................................................. 19
2.4.1. Appel au compilateur .......................................................................................................................... 20
2.4.2. Excution de lapplication .................................................................................................................. 20
2.4.3. Dbogage ............................................................................................................................................ 20
3. UTILISATION DES VARIABLES DE TYPE VALEUR............................................................................ 22
3.1. SYSTEME DE TYPES COMMUNS (CTS, COMMON SYSTEM TYPE) ................................................................. 22
3.1.1. Vue densemble du systme de types communs ................................................................................... 22
3.1.2. Comparaison des types valeur et rfrence......................................................................................... 22
3.1.3. Comparaison des types valeur dfinis par lutilisateur et des types valeur intgrs .......................... 22
3.1.4. Types simples ...................................................................................................................................... 22
3.2. ATTRIBUTION DE NOMS AUX VARIABLES .................................................................................................... 23
3.2.1. Rgles et recommandations pour laffectation de noms aux variables ............................................... 23
3.2.2. Mots cls en C#................................................................................................................................... 24

3.3. UTILISATION DE TYPES DE DONNEES INTEGRES........................................................................................... 24
3.3.1. Dclaration de variables locales......................................................................................................... 24
3.3.2. Attribution de valeurs aux variables ................................................................................................... 25
3.3.3. Assignation compos........................................................................................................................... 25
3.3.4. Oprateurs courants............................................................................................................................ 26
3.4. CREATION DE TYPES DE DONNEES DEFINIS PAR LUTILISATEUR .................................................................. 26
3.4.1. Types numration (enum) .................................................................................................................. 26
3.4.2. Types Structure (struct)....................................................................................................................... 27
3.5. CONVERSION DE TYPES DE DONNEES........................................................................................................... 27
3.5.1. Conversion implicite de types de donnes........................................................................................... 27
3.5.2. Conversion explicite de types de donnes ........................................................................................... 28
4. INSTRUCTIONS ET EXCEPTIONS............................................................................................................ 29
4.1. INTRODUCTION AUX INSTRUCTIONS............................................................................................................ 29
4.1.1. Blocs d'instructions ............................................................................................................................. 29
4.1.2. Types d'instructions............................................................................................................................. 29
4.2. UTILISATION DES INSTRUCTIONS CONDITIONNELLES .................................................................................. 30
4.2.1. L'instruction if ..................................................................................................................................... 30
4.2.2. L'instruction switch ............................................................................................................................. 30
4.3. UTILISATION DES INSTRUCTIONS D'ITERATION............................................................................................ 31
4.3.1. L'instruction while............................................................................................................................... 31
4.3.2. L'instruction do ................................................................................................................................... 32
4.3.3. L'instruction for................................................................................................................................... 32
4.3.4. L'instruction foreach ........................................................................................................................... 34
4.4. UTILISATION DES INSTRUCTIONS DE SAUT................................................................................................... 34
4.4.1. L'instruction goto ................................................................................................................................ 34
4.4.2. Les instructions break et continue....................................................................................................... 35
4.5. GESTION DES EXCEPTIONS FONDAMENTALES.............................................................................................. 35
4.5.1. Objets exception.................................................................................................................................. 35
4.5.2. Utilisation des blocs try et catch......................................................................................................... 36
4.5.3. Blocs catch multiples........................................................................................................................... 37
4.6. LEVEE D'EXCEPTIONS.................................................................................................................................. 38
4.6.1. L'instruction throw.............................................................................................................................. 38
4.6.2. La clause finally .................................................................................................................................. 38
5. METHODES ET PARAMETRES................................................................................................................. 39
5.1. UTILISATION DES METHODES...................................................................................................................... 39
5.1.1. Dfinition des mthodes ...................................................................................................................... 39
5.1.2. Appel de mthodes............................................................................................................................... 40
5.1.3. Utilisation de l'instruction return........................................................................................................ 40
5.1.4. Retour de valeurs ................................................................................................................................ 41
5.2. UTILISATION DES PARAMETRES................................................................................................................... 41
5.2.1. Dclaration et appel de paramtres.................................................................................................... 41
5.2.2. Mcanismes de passage de paramtres............................................................................................... 42
5.2.3. Passage par valeur.............................................................................................................................. 42
5.2.4. Passage par rfrence......................................................................................................................... 43
5.2.5. Paramtres de sortie ........................................................................................................................... 43
6. TABLEAUX..................................................................................................................................................... 45
6.1. VUE D'ENSEMBLE DES TABLEAUX ............................................................................................................... 45
6.1.1. Qu'est ce qu'un tableau ? .................................................................................................................... 45
6.1.2. Notation de tableau en C#................................................................................................................... 45
6.1.3. Rang de tableau................................................................................................................................... 45
6.1.4. Accs aux lments d'un tableau......................................................................................................... 45
6.1.5. Vrification des limites de tableau...................................................................................................... 46
6.2. CREATION DE TABLEAUX ............................................................................................................................ 47
6.2.1. Cration d'instances de tableau .......................................................................................................... 47
6.2.2. Initialisation d'lments de tableau..................................................................................................... 47
6.2.3. Initialisation d'lments de tableaux multidimensionnels ................................................................... 47
7. NOTIONS FONDAMENTALES DE LA PROGRAMMATION ORIENTEE OBJET............................ 48

7.1. CLASSES ET OBJ ETS..................................................................................................................................... 48
7.2. QUEST-CE QUUNE CLASSE ?...................................................................................................................... 48
7.3. QUEST QUUN OBJ ET ?............................................................................................................................... 48
7.4. COMPARAISON ENTRE UNE CLASSE ET UNE STRUCTURE.............................................................................. 48
7.5. UTILISATION DE LENCAPSULATION............................................................................................................ 49
7.6. DONNEES DE LOBJ ET, DONNEES STATIQUES ET METHODES STATIQUES...................................................... 49
7.7. C#ET LORIENTATION OBJ ET ...................................................................................................................... 49
7.7.1. Dfinition de classes simples............................................................................................................... 49
7.7.2. Instanciation de nouveaux objets ........................................................................................................ 50
7.7.3. Utilisation du mot cl this ................................................................................................................... 50
7.7.4. Classes imbriques.............................................................................................................................. 51
7.8. DEFINITION DE SYSTEMES ORIENTES OBJ ET................................................................................................. 51
7.8.1. Hritage .............................................................................................................................................. 51
7.8.2. Hirarchie des classes......................................................................................................................... 51
7.8.3. Hritage simple et multiple ................................................................................................................. 51
7.8.4. Polymorphisme.................................................................................................................................... 52
7.8.5. Classes de base abstraites................................................................................................................... 52
7.8.6. Interfaces............................................................................................................................................. 52
7.8.7. Liaison anticipe et tardive................................................................................................................. 52
8. UTILISATION DE VARIABLES DE TYPE REFERENCE...................................................................... 53
8.1. COMPARAISON ENTRE LES TYPES VALEUR ET LES TYPES REFERENCE.......................................................... 53
8.2. DECLARATION ET LIBERATION DES VARIABLES REFERENCE........................................................................ 53
8.3. COMPARAISON DE VALEURS ET COMPARAISON DE REFERENCES................................................................. 54
8.4. UTILISATION DE REFERENCES COMME PARAMETRES DE METHODE.............................................................. 55
8.5. UTILISATION DE TYPE REFERENCE COURANTS............................................................................................. 57
8.5.1. System.Exception................................................................................................................................. 57
8.5.2. System.String....................................................................................................................................... 58
8.6. HIERARCHIE DES OBJ ETS............................................................................................................................. 58
8.6.1. Mthode ToString................................................................................................................................ 58
8.6.2. Mthode Equals................................................................................................................................... 58
8.6.3. Mthode GetType ................................................................................................................................ 59
8.6.4. Mthode Finalize................................................................................................................................. 59
8.6.5. Mthode GetType ................................................................................................................................ 59
8.6.6. Oprateur TypeOf ............................................................................................................................... 59
8.6.7. Rflexion.............................................................................................................................................. 59
8.7. ESPACE DE NOMS DU FRAMEWORK.NET .................................................................................................... 59
8.7.1. Espace de noms System.IO.................................................................................................................. 60
8.7.2. Espace de noms System.Xml................................................................................................................ 60
8.7.3. Espace de noms System.Data.............................................................................................................. 60
8.8. CONVERSION DE DONNEES.......................................................................................................................... 61
8.8.1. Conversions implicites ........................................................................................................................ 61
8.8.2. Conversions explicites......................................................................................................................... 61
8.8.3. Conversions de types rfrence........................................................................................................... 61
8.8.4. Boxing/Unboxing................................................................................................................................. 62
9. CREATION ET DESTRUCTION DOBJETS............................................................................................. 63
9.1. UTILISATION DE CONSTRUCTEURS.............................................................................................................. 63
9.1.1. Constructeurs dinstances................................................................................................................... 63
9.1.2. Constructeurs statiques....................................................................................................................... 64
9.1.3. Constructeurs de structures ................................................................................................................ 65
9.2. OBJ ETS ET MEMOIRE ................................................................................................................................... 65
9.3. GESTION DES RESSOURCES.......................................................................................................................... 65
9.3.1. Finalize................................................................................................................................................ 66
9.3.2. Destructeurs ........................................................................................................................................ 66
9.3.3. IDisposable et Dispose........................................................................................................................ 66
10. HERITAGE DANS C#......................................................................................................................... 67
10.1. DERIVATION DE CLASSE.............................................................................................................................. 67
10.1.1. Syntaxe ................................................................................................................................................ 67

10.1.2. Utilisation du mot cl protected.......................................................................................................... 67
10.1.3. Appel de constructeurs de classe de base ........................................................................................... 67
10.2. IMPLEMENTATION DE METHODES................................................................................................................ 68
10.2.1. Utilisation de virtual et override......................................................................................................... 68
10.2.2. Utilisation de new ............................................................................................................................... 68
10.3. UTILISATION DINTERFACES........................................................................................................................ 68
10.4. UTILISATION DES CLASSES ABSTRAITES ET SCELLEES................................................................................. 70
11. OPERATEURS, DELEGUES ET EVENEMENTS .......................................................................... 72
11.1. SURCHARGE DOPERATEURS....................................................................................................................... 72
11.2. DELEGATIONS............................................................................................................................................. 73
11.3. EVENEMENTS.............................................................................................................................................. 73
12. PROPRIETES ET INDEXEURS........................................................................................................ 77
12.1. PROPRIETES................................................................................................................................................. 77
12.2. INDEXEURS ................................................................................................................................................. 80
13. ATTRIBUTS......................................................................................................................................... 82


1. Vue densemble de la plate-forme
Microsoft .NET
1.1. Prsentation de la plate-forme .NET
La plate-forme Microsoft.NET fournit l'ensemble des outils et technologies ncessaires la cration
d'applications Web distribues. Elle expose un modle de programmation cohrent, indpendant du
langage, tous les niveaux d'une application, tout en garantissant une parfaite interoprabilit avec les
technologies existantes et une migration facile depuis ces mmes technologies.

La plate-forme .NET prend totalement en charge les technologies Internet bases sur les normes et
indpendantes des plates-formes, telles que http (Hypertext Transfer Protocol), XML (Extensible
Markup Language) et SOAP (Simple Object Access Protocol).

C#est un nouveau langage spcialement conu pour la cration d'applications .NET.
En tant que dveloppeur, il vous sera utile de comprendre le fondement et les fonctionnalits de la
plate-forme Microsoft .NET avant d'crire du code C#.

La plate-forme .NET offre plusieurs technologies de base. Ces technologies sont dcrites dans les
rubriques suivantes.
1.1.1. .NET Framework
La technologie du .NET Framework se fonde sur un nouveau Common Language Runtime. Celui-ci
fournit un ensemble commun de services pour les projets crs dans Microsoft Visual Studio.NET,
indpendamment du langage. Ces services fournissent des blocs de construction de base pour les
applications de tous types, utilisables tous les niveaux des applications.
Microsoft Visual Basic, Microsoft Visual C++et d'autres langages de programmation de Microsoft
ont t amliors pour tirer profit de ces services.
Microsoft Visual J # .NET a t cr pour les dveloppeurs J ava qui souhaitent crer des
applications et des services l'aide du .NET Framework. Les langages tiers crits pour la plate-forme
.NET ont galement accs ces services. Le .NET Framework est prsent plus en dtails dans la suite
de ce module.
1.1.2. .NET My Services
.NET My Services est un ensemble de services Web XML centrs sur l'utilisateur. Grce .NET My
Services, les utilisateurs reoivent des informations pertinentes lorsqu'ils en ont besoin, directement
sur les priphriques qu'ils utilisent en fonction des prfrences qu'ils ont dfinies.
Grce .NET My Services, les applications peuvent communiquer directement via SOAP et XML
partir de toute plate-forme prenant en charge SOAP.

Les principaux services .NET My Services sont les suivants :
- Authentification .NET Passport
- Possibilit d'envoyer des alertes et de grer les prfrences pour la rception des alertes
- Stockage d'informations personnelles (contacts, adresses lectroniques, calendriers, profils, listes,
portefeuille lectronique et emplacement physique)
- Possibilit de grer des banques de documents, d'enregistrer les paramtres des applications, de
sauvegarder vos sites Web prfrs et de noter les priphriques possds

1.1.3. Serveurs .NET Entreprise Server
Les serveurs .NET Enterprise Server permettent une volutivit, une fiabilit, une gestion et une
intgration inter et intra organisations. Ils offrent en outre un grand nombre de fonctionnalits dcrites
dans le tableau ci-dessous.
1.1.4. Visual Studio .NET
Visual Studio .NET constitue un environnement de dveloppement destin la cration d'applications
sur le .NET Framework. Il fournit d'importantes technologies catalysantes afin de simplifier la
cration, le dploiement et l'volution continue d'applications Web et de services Web XML scuriss,
volutifs et haute disponibilit.
1.2. Vue densemble du Framework .NET
1.2.1. .NET Framework
.NET Framework fournit le canevas de compilation et d'excution ncessaire la cration et
l'excution d'applications .NET.
1.2.2. Substrat de la plate-forme
Le .NET Framework doit tre excut sur un systme d'exploitation.
Actuellement, le .NET Framework est conu pour fonctionner sur les systmes d'exploitation
Microsoft Win32. Dans l'avenir, il sera tendu pour s'excuter sur d'autres plates-formes, telles que
Microsoft WindowsCE.
1.2.3. Services dapplication
En excutant le .NET Framework sur Windows, les dveloppeurs disposent de certains services
d'application, tels que Component Services, Message Queuing, Windows Internet Information
Services (IIS) et Windows Management Instrumentation (WMI). Le .NET Framework expose ces
services d'application par l'intermdiaire de classes de sa bibliothque de classes.
1.2.4. Common Laguage Runtime
Le Common Language Runtime facilite le dveloppement d'applications, fournit un environnement
d'excution robuste et scuris, prend en charge plusieurs langages de programmation tout en
simplifiant le dploiement et la gestion des applications.
Son environnement est galement qualifi de manag , ce qui signifie que des services courants,
tels que le garbage collection et la scurit, y sont automatiquement fournis.
1.2.5. Bibliothque de classe
La bibliothque de classes .NET Framework expose des fonctionnalits Runtime et fournit d'autres
services utiles tous les dveloppeurs. Les classes simplifient le dveloppement des applications
.NET. Les dveloppeurs peuvent ajouter des classes en crant leurs propres bibliothques de classes.
1.2.6. ADO.NET
ADO.NET est la nouvelle gnration de la technologie ADO (ActiveX Data Object) de Microsoft.
Elle fournit une prise en charge amliore du modle de programmation dconnect, ainsi qu'une prise
en charge riche du XML.
1.2.7. ASP.NET
Microsoft ASP.NET est une structure de programmation fonde sur le Common Language Runtime. Il
peut tre employ sur un serveur pour crer des applications Web puissantes. Les formulaires Web
ASP.NET sont des outils puissants et faciles d'emploi permettant de crer des interfaces utilisateur
Web dynamiques.

1.2.8. Services Web XML
Un service Web est un composant Web programmable qui peut tre partag par des applications sur
Internet ou sur un intranet. Le .NET Framework fournit des outils et des classes pour la cration, le
test et la distribution de services Web XML.
1.2.9. Interfaces utilisateur
Le .NET Framework prend en charge trois types d'interfaces utilisateur :
- Les formulaires Web, qui fonctionnent avec ASP.NET.
- Les Windows Forms, qui fonctionnent sur les clients Win32.
- Les applications consoles, qui, par souci de simplicit, sont utilises pour la plupart des ateliers de
ce cours.
1.2.10. Langages
Tout langage conforme la norme CLS (Common Language Specification) peut fonctionner dans le
Common Language Runtime. Dans le .NET Framework, Microsoft prend en charge Visual Basic,
Visual C++, Microsoft Visual C#, Visual J #et Microsoft J Script. Les fournisseurs indpendants
peuvent proposer d'autres langages.

Figure 1 - Plateforme .NET
1.3. Avantages Framework .NET
Dans cette section, vous allez dcouvrir certains des avantages du .NET Framework.
Le .NET Framework a t conu pour rpondre aux objectifs suivants :
1.3.1. S'appuyer sur les normes et les pratiques du Web
Il prend totalement en charge les technologies Internet existantes, telles que HTML, XML, SOAP,
XSLT (Extensible Stylesheet Language for Transformations), XPath et autres normes Web. Il favorise
les services Web XML sans tat et connexion non permanentes.

1.3.2. Utiliser des modles d'application unifis
La fonctionnalit d'une classe .NET est accessible partir de tous les modles de programmation ou
langages compatibles avec .NET.
1.3.3. Facile d'emploi pour les dveloppeurs
Dans le .NET Framework, le code est organis en classes et en espaces de noms hirarchiques. Le
.NET Framework fournit un systme de types communs, galement qualifi de systme de types
unifis , qui peut tre utilis par tous les langages compatibles avec .NET. Dans ce systme de types
unifis, tous les lments du langage sont des objets. Il n'existe aucun type Variant, uniquement un
type String, et toutes les donnes de type String sont au format Unicode. Le systme unifi est dcrit
plus en dtail dans les modules ultrieurs.
1.3.4. Classes extensibles
La hirarchie du .NET Framework est visible par le dveloppeur. Vous pouvez accder aux classes
.NET et les tendre ( l'exception des classes protges) au moyen de l'hritage. Il est galement
possible d'implmenter un hritage inter langage.
1.4. Composants du Framework .NET
Dans cette section, vous allez vous familiariser avec Microsoft .NET Framework. Le .NET
Framework est un ensemble de technologies intgres la plate-forme Microsoft .NET. Cet ensemble
constitue les blocs de construction de base qui servent au dveloppement d'applications et de services
Web XML.
1.4.1. Common Language Runtime
Le Common Language Runtime facilite le dveloppement d'applications, fournit un environnement
d'excution robuste et scuris, prend en charge plusieurs langages de programmation tout en
simplifiant le dploiement et la gestion des applications. Le Runtime est appel environnement
manag et fournit automatiquement des services communs tels que le garbage collection, la scurit,
etc. Les fonctionnalits du Common Language Runtime sont dcrites dans le tableau ci-dessous.

Figure 2 - Fonctionnalits de la CLR


Composant Description
Chargeur de classes
Gre les mtadonnes, en plus du chargement des classes et de leur
disposition.
Compilateur MSIL
(Microsoft Intermediate
Language) en code natif
Convertit MSIL en code natif (juste--temps).
Gestionnaire de code Gre l'excution du code.
Garbage collector (GC)
Fournit une gestion automatique de la dure de vie de tous vos objets.
Il s'agit d'un mcanisme multiprocesseur et volutif.
Moteur de scurit
Fournit une scurit par preuve, fonde sur l'origine du code en plus
de l'utilisateur.
Moteur de dbogage
Permet de dboguer l'application et de tracer l'excution du code.
Vrificateur de type
N'autorise pas les conversions non scurises ou les variables non
initialises. Le langage MSIL peut tre vrifi pour garantir la
scurit de type.
Gestionnaire d'exceptions
Fournit un traitement structur des exceptions, intgr SEH
(WindowsStructured Exception Handling). La gnration de rapports
d'erreurs a t amliore.
Prise en charge multithread
Fournit des classes et des interfaces qui permettent la programmation
multithread.
Marshaleur COM Fournit le marshaling partir et destination de COM.
Prise en charge de la
bibliothque de classes de
base (BCL)
Intgre du code au runtime qui prend en charge la BCL.
Tableau 1 - Description des composants
1.4.2. Bibliothque de classes du .NET Framework
La bibliothque de classes du .NET Framework expose les fonctionnalits du Runtime et fournit
d'autres services essentiels de haut niveau via une hirarchie d'objets.

Espace de noms System
L'espace de noms System contient des classes fondamentales et de base qui dfinit les types de
donnes valeur et rfrence, les vnements et gestionnaires d'vnements, les interfaces, les attributs
et les exceptions de traitements couramment utiliss. D'autres classes fournissent des services qui
prennent en charge les conversions des types de donnes, la manipulation de paramtres de mthode,
les oprations mathmatiques, l'appel de programmes distance et en local, la gestion
d'environnements d'applications, de mme que la supervision d'applications gres et non gres.

L'espace de noms System.Collections fournit des listes tries, des tables de hachage et d'autres
mthodes de regroupement de donnes. L'espace de noms System.IO fournit des entres/sorties (E/S),
des flux, etc. L'espace de noms System.NET offre une prise en charge des sockets et de TCP/IP
(Transmission Control Protocol/Internet Protocol).
1.4.3. ADO.NET : donnes et XML
ADO.NET, la nouvelle gnration de la technologie ADO, fournit une prise en charge amliore du
modle de programmation dconnect, ainsi qu'une prise en charge riche du XML dans l'espace de
noms System.Xml.



Figure 3 - Espaces de noms composant ADO.NET

Espace de noms System.Data
L'espace de noms System.Data est constitu de classes qui forment le modle objet d'ADO.NET.
haut niveau, le modle objet ADO.NET se divise en deux couches : la couche connecte et la couche
dconnecte.
L'espace de noms System.Data comprend la classe DataSet, qui reprsente des plusieurs tables et leurs
relations. Ces ensembles DataSets sont des structures de donnes totalement autonomes, qui peuvent
tre peuples partir de diverses sources de donnes. L'une de ces sources pourrait tre du code XML,
une autre, une base de donnes OLE et une troisime, l'adaptateur direct pour SQL Server.

Espace de noms System.Xml
L'espace de noms System.Xml fournit la prise en charge XML. Il comprend un outil d'criture et un
analyseur XML, tous deux conformes aux spcifications du W3C. La transformation XSL (Extensible
Stylesheet Language) est assure par l'espace de noms System.Xml.Xsl. L'espace de noms
System.Xml.Serialization contient des classes utilises pour la srialisation des objets dans des
documents ou des flux au format XML.
1.4.4. Formulaires Web et services Web XML
ASP.NET est une structure de programmation fonde sur le Common Language Runtime, qui peut tre
employe sur un serveur pour crer des applications Web puissantes. Les formulaires Web ASP.NET
sont des outils puissants et faciles d'emploi permettant de crer des interfaces utilisateur Web
dynamiques.
Les services Web ASP.NET fournissent les blocs de construction servant l'laboration d'applications
Web XML distribues. Les services Web XML reposent sur des standards Internet ouverts, tels que
HTTP et XML.

Le Common Language Runtime fournit un support intgr pour la cration et l'exposition de services
Web XML, grce l'emploi d'une abstraction de programmation cohrente et familire la fois pour
les dveloppeurs de formulaires Web ASP (Active Server Pages) et Visual Basic. Le modle rsultant
est la fois volutif et extensible. Ce modle reposant sur des standards Internet ouverts (HTTP,
XML, SOAP et SDL), tout ordinateur client ou priphrique Internet peut y accder et l'interprter.


Espace de noms System.Web
Dans l'espace de noms System.Web, certains services de niveau infrieur, tels que la mise en cache, la
scurit ou la configuration, sont partags par les services Web XML et l'interface utilisateur Web.

Espace de noms System.Web.Services
L'espace de noms System.Web fournit des classes et des interfaces permettant la communication entre
les navigateurs et les serveurs.

Espace de noms System.Web.UI
L'espace de noms System.Web.UI fournit des classes et des interfaces qui vous permettent de crer des
contrles et des pages s'affichant dans vos applications Web comme interface utilisateur sur une page
Web.
1.4.5. Interface utilisateur pour Windows
Espace de noms System.Windows.Forms
Vous pouvez utiliser les classes de l'espace de noms System.Windows.Forms pour crer l'interface
utilisateur cliente. Cette classe vous permet d'implmenter l'interface utilisateur Windows standard
dans vos applications .NET.
De nombreuses fonctions qui n'taient auparavant accessibles que par l'intermdiaire d'appels d'api
sont prsent intgres aux formulaires eux-mmes, ce qui rend le dveloppement plus puissant et
plus facile.

Espace de noms System.Drawing
L'espace de noms System.Drawing fournit un accs aux fonctionnalits graphiques de base de GDI+.
Des fonctionnalits plus avances sont fournies dans les espaces de noms :
- System.Drawing.Drawing2D
- System.Drawing.Imaging
- System.Drawing.Text.
1.5. Langages du .NET Framework
Le .NET Framework prend en charge plusieurs langages de programmation. C#est le langage de
programmation spcialement conu pour la plate-forme .NET, mais C++ et Visual Basic ont
galement t mis jour pour prendre entirement en charge le .NET Framework.



Langage Description
C#
C#a t conu pour la plate-forme .NET. Il s'agit du premier langage
moderne orient composant dans la famille C et C++. Il peut tre
incorpor dans des pages ASP.NET.
Certaines de ses principales fonctionnalits sont : les classes, les
interfaces, les dlgus, le boxing et l'unboxing, les espaces de noms,
les proprits, les indexeurs, les vnements, la surcharge d'oprateurs,
la gestion de versions, les attributs, le code non scuris et la gnration
de documents XML. Aucun en-tte ou fichier IDL (Interface Definition
Language) n'est ncessaire.
Extensions manages pour
C++
Le langage C++manag est une extension minimale du langage C++.
Cette extension fournit un accs au .NET Framework qui comprend le
garbage collection, l'hritage d'implmentation simple et l'hritage
d'interface multiple. Cette mise jour dispense galement le
dveloppeur d'crire du code de raccord pour les composants. Il offre
un accs de bas niveau si besoin est.
Visual Basic .NET
Visual Basic .NET prsente diverses innovations importantes par
rapport aux versions prcdentes de Visual Basic. Visual Basic .NET
prend en charge l'hritage, les constructeurs, le polymorphisme, la
surcharge du constructeur, les exceptions structures, un contrle de
type plus strict, des modles de thread libres ainsi que de nombreuses
autres fonctionnalits. Il existe une seule forme d'assignation : aucune
mthode Let ou Set. Les nouvelles fonctions de dveloppement rapide
d'application, telles que le Concepteur XML, l'Explorateur de serveurs
et le Concepteur Web Forms, sont disponibles dans Visual Basic
partir de Visual Studio .NET. Avec cette version, VBScript offre une
fonctionnalit Visual Basic complte.
J Script .NET
J Script .NET est rcrit pour prendre entirement en charge .NET. Il
prend en charge les classes, l'hritage, les types et la compilation, et
comprend des fonctionnalits de performance et de productivit
optimises. J Script .NET est galement intgr avec Visual Studio
.NET. Vous pouvez utiliser n'importe quelle classe .NET Framework
dans J Script .NET.
Visual J #.NET
Visual J # .NET est un outil de dveloppement J ava destin aux
dveloppeurs J ava qui souhaitent crer des applications et des services
sur le .NET Framework. Visual J #.NET est entirement compatible
avec .NET et inclut des outils pour mettre jour et convertir
automatiquement les projets et les solutions Visual J ++6.0 existants au
nouveau format Visual Studio .NET. Visual J #.NET fait partie de la
stratgie de transition de J ava .NET (Java User Migration Path to
Microsoft .NET, JUMP to .NET ).
Langages tiers
Divers langages tiers prennent en charge le .NET Framework. Citons,
par exemple, APL, COBOL, Pascal, Eiffel, Haskell, ML, Oberon, Perl,
Python, Scheme et SmallTalk.
Tableau 2 - Description des langages

2. Vue densemble du C#
2.1. Structure du programme C#
Dans cette leon, vous allez apprendre la structure de base d'un programme C#.
Vous allez analyser un programme simple contenant toutes les fonctionnalits essentielles. Vous
apprendrez galement utiliser MicrosoftVisual Studiopour crer et modifier un programme C#.
2.1.1. Hello World
Le premier programme rdig par la plupart des utilisateurs dans un nouveau langage est l'invitable
Hello, World . Dans ce module, vous allez pouvoir examiner la version C#de ce premier
programme traditionnel.

L'exemple de code de la diapositive contient tous les lments essentiels d'un programme C#, et il est
facile tester ! Lorsqu'il est excut depuis la ligne de commandes, il affiche simplement :

Hello, World

Dans les rubriques suivantes, vous allez analyser ce programme simple pour dcouvrir plus en dtail
les blocs de construction d'un programme C#.

publ i c cl ass Hel l o
{
publ i c st at i c voi d Mai n( )
{
Syst em.Consol e.Wr i t eLi ne( " Hel l o, Wor l d! " ) ;
}
}
2.1.2. La classe
Dans C#, une application est une collection d'une ou plusieurs classes, structures de donnes et autres
types. Dans ce module, une classe est dfinie comme un ensemble de donnes associ des mthodes
(ou fonctions) qui peuvent manipuler ces donnes. Dans les modules suivants, vous tudierez les
classes et tout ce qu'elles offrent aux programmeurs en C#.

Si vous tudiez le code de l'application Hello, World , vous verrez une seule classe appele Hello.
Cette classe est introduite par le mot-cl class. Le nom de la classe est suivi d'une accolade ouvrante
({). Tous les lments compris entre cette accolade ouvrante et l'accolade ferme (}) font partie de la
classe.

Vous pouvez rpartir les classes d'une application C#dans un ou plusieurs fichiers. Vous pouvez
placer plusieurs classes dans un fichier, mais vous ne pouvez pas tendre une mme classe sur
plusieurs fichiers.

{
. . .
}
2.1.3. La mthode Main
Chaque application doit dmarrer un emplacement donn. L'excution d'une application C#dmarre
au niveau de la mthode Main. Si vous avez l'habitude de programmer en langage C, C++ou J ava,
vous tes dj familiaris avec ce concept.


Le langage C#respecte la casse. Main doit tre crit avec un M majuscule et le reste du mot en
minuscules.

Une application C#peut contenir plusieurs classes, mais un seul point d'entre. Vous pouvez avoir
plusieurs classes avec Main dans la mme application, mais une seule mthode Main est excute.
Vous devez spcifier la classe utiliser lors de la compilation de l'application.

La signature de la mthode Main est galement importante. Si vous utilisez Visual Studio, cette
signature est cre automatiquement en tant que static void. (Vous dcouvrirez ce que cela signifie
plus loin dans ce cours.) moins d'avoir une bonne raison de le faire, vous ne devez pas modifier la
signature.

Vous pouvez modifier la signature dans une certaine mesure, mais elle doit toujours tre statique ;
sinon, elle peut ne pas tre reconnue par le compilateur comme point d'entre de l'application.

L'application s'excute jusqu' la fin de la mthode Main ou jusqu' ce qu'une instruction return soit
excute par la mthode Main.
2.1.4. La directive using et l'espace de noms System
Dans Microsoft .NET Framework, C#est fourni avec de nombreuses classes d'utilitaires qui effectuent
diverses oprations utiles. Ces classes sont organises en espaces de noms. Un espace de noms est un
ensemble de classes associes. Il peut g utres espaces de noms.

Le .NET Framework se compose de nombreux espaces de noms, le plus important tant System.
L'espace de noms System contient les classes que la plupart des applications utilisent pour interagir
avec le systme d'exploitation. Les classes les plus frquemment utilises grent les entres/sorties
(E/S). Comme de nombreux autres langages, C#n'a pas de capacit d'E/S part entire ; il dpend par
consquent du systme d'exploitation pour fournir une interface compatible avec C#.

Vous pouvez faire rfrence des objets d'un espace de noms en les faisant prcder explicitement de
l'identificateur de cet espace de noms. Par exemple, l'espace de noms System contient la classe
Console, qui comporte plusieurs mthodes, telles que WriteLine. Vous pouvez accder la mthode
WriteLine de la classe Console de la manire suivante :

alement contenir d'a
Syst em.Consol e.Wr i t eLi ne( " Hel l o, Wor l d! " ) ;

Toutefois, l'utilisation d'un nom qualifi complet pour faire rfrence aux objets est dangereuse et
risque de provoquer des erreurs. Afin d'viter ce problme, vous pouvez spcifier un espace de noms
en plaant une directive using au dbut de votre application avant la dfinition de la premire classe.
Une directive using spcifie un espace de noms qui sera tudi si une classe n'est pas explicitement
dfinie dans l'application. Vous pouvez intgrer plusieurs directives using dans le fichier source, mais
elles doivent toutes tre places au dbut de ce fichier.

Avec la directive using, vous pouvez rcrire le code prcdent de la manire suivante :

usi ng Syst em;

{
{
Consol e.Wr i t eLi ne( " Hel l o, Wor l d! " ) ;
}
}


Dans l'application Hello, World , la classe Console n'est pas explicitement dfinie. Lors de la
compilation de l'application Hello, World , le compilateur recherche la classe Console et la trouve
dans l'espace de noms System.
Le compilateur gnre du code qui fait rfrence au nom qualifi complet System.Console.
2.2. Oprations lmentaires dentre/sortie
Dans cette leon, vous allez apprendre effectuer des oprations d'entre/sortie partir de commandes
en langage C# l'aide de la classe Console.
Vous apprendrez afficher des informations l'aide des mthodes Write et WriteLine, ainsi qu'
recueillir des informations d'entre partir du clavier l'aide des mthodes Read et ReadLine.
2.2.1. La classe Console
La classe Console fournit une application C#avec accs l'entre standard, la sortie standard et aux
flux d'erreur standard.

L'entre standard est normalement associe au clavier ; tout ce que l'utilisateur saisit partir du clavier
peut tre lu partir du flux d'entre standard. Le flux de sortie standard et le flux d'erreur standard sont
quant eux gnralement associs l'cran.

Mthodes Write et WhriteLine
Vous pouvez utiliser les mthodes Console.Write et Console.WriteLine pour afficher des informations
sur l'cran de la console. Ces deux mthodes sont trs similaires, une diffrence prs : la mthode
WriteLine ajoute une nouvelle paire ligne/retour chariot la fin de la sortie, tandis que la mthode
Write ne le fait pas.

Ces deux mthodes sont surcharges. Vous pouvez les appeler avec diffrents nombres et types de
paramtres. Par exemple, vous pouvez utiliser le code suivant pour crire 99 l'cran :

Consol e.Wr i t eLi ne( 99) ;

Vous pouvez utiliser le code suivant pour crire le message Hello, World l'cran :


Mthodes Read et ReadLine
Vous pouvez lire l'entre de l'utilisateur sur le clavier l'aide des mthodes Console.Read et
Console.ReadLine.

La mthode Read lit le caractre suivant partir du clavier. Elle renvoie la valeur int 1 si aucune
autre entre n'est disponible. Sinon, elle renvoie une valeur int reprsentant le caractre lu.

La mthode ReadLine lit tous les caractres jusqu' la fin de la ligne d'entre (le retour chariot).
L'entre est renvoye en tant que chane de caractres. Vous pouvez utiliser le code ci-dessous pour
lire une ligne de texte partir du l'cran :

clavier et l'afficher
st r i ng i nput = Consol e.ReadLi ne( ) ;
Consol e.Wr i t eLi ne( i nput ) ;

2.3. Mthodes conseilles
Dans cette leon, vous allez apprendre certaines mthodes conseilles lors de l'criture d'applications
C#. Vous dcouvrirez comment commenter les applications afin d'optimiser leur lecture et leur
gestion. Vous apprendrez galement grer les erreurs qui peuvent se produire lors de l'excution
d'une application.
2.3.1. Commentaire dapplications
Il est important de fournir une documentation adquate pour toutes vos applications. Vous devez
fournir des commentaires suffisants pour qu'un dveloppeur n'ayant pas particip la cration de
l'application d'origine soit en mesure de suivre et de comprendre son fonctionnement. Utilisez des
commentaires prcis et explicites. Les bons commentaires ajoutent des informations que l'instruction
de code seule ne suffit pas expliciter ; ils expliquent le pourquoi plutt que le qu'est-ce que
c'est . Si votre entreprise applique des rgles en matire de commentaires, vous devez les respecter.

C#permet d'ajouter des commentaires au code des applications de plusieurs manires : commentaires
sur une seule ligne, commentaires sur plusieurs lignes ou documentation gnre au format XML.

Vous pouvez ajouter un commentaire sur une seule ligne en utilisant les barres obliques (/ / ). Lors de
l'excution de votre application, tout ce qui suit ces deux caractres jusqu' la fin de la ligne est ignor.

/ / l i t l e nomde l ut i l i sat eur
Consol e.Wr i t eLi ne( " Comment vous appel ez- vous?" ) ;
name = Consol e.ReadLi ne( ) ;

Vous pouvez galement utiliser des commentaires de bloc qui couvrent plusieurs lignes. Ce type de
commentaires commence par la paire de caractres
/ * et cont i nue j usqu' l a pai r e de car act r es */ correspondante. Vous ne
pouvez pas imbriquer de commentaires de bloc.

/ * Recher che l a r aci ne l a pl us l eves de
L quat i on quadr at i que */
x = ( . . . ) ;
2.3.2. Cration dune documentation XML
Vous pouvez utiliser des commentaires C# pour gnrer une documentation XML pour vos
applications.

Les commentaires des documentations commencent par trois barres obliques (///) suivies d'une balise
de documentation XML. Pour consulter des exemples, reportez-vous la diapositive.

Vous pouvez utiliser les balises XML qui vous sont proposes, ou crer les vtres. Le tableau suivant
contient certaines balises XML et leur utilisation.


Balise Rle
<summar y></ summar y>
Fournir une brve description. Utilisez la balise <remarks>pour une description
plus longue.
<r emar ks> </ r emar ks>
Fournir une description dtaille. Cette balise peut contenir des paragraphes
imbriqus, des listes et d'autres types de balises.
<par a> </ par a>
Ajouter une structure la description dans une balise <remarks>. Cette balise
permet de dlimiter des paragraphes.
<l i st t ype=" " > </ l i st >
Ajouter une liste structure une description dtaille. Les types de listes pris en
charge sont bullet ( puce), number (numrote) et table (tableau).
Des balises supplmentaires (<term> </term>et <description>
</description>) sont utilises au sein de la liste pour mieux dfinir la structure.
<exampl e> </ exampl e>
Fournir un exemple de l'utilisation d'une mthode, d'une proprit ou d'un autre
membre de la bibliothque. Cela implique souvent l'utilisation d'une balise
<code>imbrique.
<code> </ code> Indiquer que le texte joint est un code d'application.
<c> </ c>
Indiquer que le texte joint est un code d'applicat La balise <code>est utilise
pour les lignes de code qui doivent tre spares de toute description jointe ; la
balise <c>est utilise pour le code incorpor une description jointe.
ion.
<see cref="member"/>
membre existe r
Indiquer la rfrence un autre membre ou champ. Le compilateur vrifie que ce
ellement.
<seealso cref="member"/>
autre membre ou champ. Le compilateur vrifie que ce
membre existe rellement. La diffrence entre les balises <see>et <seealso>
dpend du processeur qui manipule le document XML une fois ce dernier gnr.
Le processeur doit pouvoir gnrer les sections See (Voir) et See Also (Voir
aussi) pour que ces deux balises soient correctement diffrencies.
Indiquer la rfrence un
<except i on> </ except i on> Fournir une description pour une classe d'exception.
<per mi ssi on>
</ per mi ssi on>
Doc mbre. umenter l'accessibilit d'un me
<param name="name">
</ par am>
Fournir une description pour un paramtre de mthode.
<r et ur ns> </ r et ur ns> Documenter la valeur renvoye et le type de mthode.
<val ue> </ val ue> Dcrire une proprit.
Tableau 3 - Balises XML de la documentation

Vous pouvez compiler les balises XML et la documentation dans un fichier XML en utilisant le
compilateur C#avec l'option /doc :

csc myprogram.cs /doc:mycomments.xml

S'il n'y a pas d'erreur, vous pouvez visualiser le fichier XML gnr l'aide d'un outil tel qu'Internet
Explorer.

Le rle de l'option /doc consiste uniquement gnrer un fichier XML. Pour afficher le fichier, vous
avez besoin d'autre processeur. L'affichage du fichier sous Internet Explorer est simple, se limitant
rendre sa structure ; il permet le dveloppement ou la rduction des balises, mais il n'affiche pas la
balise <list type="bullet"> en tant que puce.


Exemple :

/ / / <summar y> La cl asse Hel l o af f i che un message
/ / / de bi envenue l ' cr an
/ / / </ summar y>
{
/ / / <r emar ks> On ut i l i sons l ' E/ S de l a consol e.
/ / / Pour pl us d' i nf or mat i ons sur Wr i t eLi ne, consul t ez
/ / / <seeal so cr ef =" Syst em. Consol e. Wr i t eLi ne" / >
/ / / </ r emar ks>
{
}
}
2.3.3. Gestion des exception
Une application C#solide doit pouvoir grer l'inattendu. Quel que soit le systme de dtection
d'erreurs ajout votre code, vous n'tes pas l'abri d'un problme.
Il se peut que l'utilisateur entre une rponse inattendue une invite ou tente d'enregistrer un fichier
dans un dossier supprim. Les possibilits sont infinies.

Si une erreur d'excution se produit dans une application C#, le systme d'exploitation renvoie une
exception. Interceptez les exceptions l'aide d'une construction try-catch, comme illustr sur la
diapositive. Si l'une des instructions de la partie try de l'application provoque une exception,
l'excution est transfre au bloc catch.

Vous pouvez rechercher des informations sur l'exception l'aide des proprits StackTrace, Message
et Source de l'objet Exception. Vous en apprendrez davantage sur la gestion des exceptions dans un
module ultrieur.
ion, l'aide de la mthode Console.WriteLine par exemple, l'exception
est automatiquement formate et affiche les proprits StackTrace, Message et Source.

Si vous imprimez une except
usi ng Syst em;

{
publ i c st at i c voi d Mai n( st r i ng[ ] ar gs)
{
t r y {
}
cat ch ( Except i on e) {
Consol e.Wr i t eLi ne( " Except i on ! {0}" , e. St ackTr ace) ;
}
}
}
2.4. Compilation, excution et dbogage
Dans cette leon, vous allez apprendre compiler et dboguer les programmes C#. Vous dcouvrirez
l'excution du compilateur partir de la ligne de commande et depuis l'environnement Visual Studio.
Vous apprendrez les principales options du compilateur. Le dbogueur Visual Studio vous sera
prsent. Enfin, vous apprendrez utiliser une partie des autres outils fournis avec le Kit de
dveloppement Microsoft .NET Framework SDK.

2.4.1. Appel au compilateur
Avant d'excuter une application C#, vous devez la compiler. Le compilateur convertit le code source
que vous crivez en un code machine compris par l'ordinateur. Vous pouvez appeler le compilateur C#
partir de la ligne de commande ou depuis Visual Studio.

Plus prcisment, les applications C#sont compiles en langage MSIL (Microsoft Intermediate
Language) plutt qu'en code machine natif.
Le code MSIL est lui-mme compil en code machine par le compilateur juste--temps (J IT) lors de
l'excution de l'application. Toutefois, il est galement possible de compiler directement en code
machine et d'ignorer le compilateur juste--temps en utilisant l'utilitaire Native Image Generator
(Ngen.exe).
Cet utilitaire cre une image native partir d'un assembly manag et l'installe dans le cache d'images
natives sur l'ordinateur local. L'excution de Ngen.exe sur un assembly permet de charger celui-ci plus
rapidement, car ce programme restaure les structures de code et de donnes partir du cache d'images
natives au lieu de les gnrer de manire dynamique.

Compilation partir de la ligne de commande
Pour compiler une application C# p commande, utilisez la commande csc. Par
exemple, pour compiler l'application Hello, World (Hello.cs) partir de la ligne de commande,
gnrer les informations de dbogage et crer un fichier excutable nomm Greet.exe, la commande
est :

artir de la ligne de
csc / debug+ / out : Gr eet . exe Hel l o. cs

Vrifiez que le fichier de sortie contenant le code compil est spcifi avec un suffixe .exe. Si ce
suffixe est omis, vous devez renommer le fichier avant de l'excuter.

Compilation partir de Visual Studio
Pour compiler une application C# l'aide de Visual Studio, ouvrez le projet contenant l'application C#,
puis cliquez sur Gnrer la solution dans le menu Gnrer.

Par dfaut, Visual Studio ouvre la configuration de dbogage des projets. Cela signifie qu'une version
dbogue de l'application est compile.
Pour compiler une version Release sans informations de dbogage, dfinissez la configuration de
solution sur Release.
2.4.2. Excution de lapplication
Vous pouvez excuter une application C# partir de la ligne de commande ou partir de Visual
Studio.

Excution partir de la ligne de commande
Si la compilation de l'application russit, un fichier excutable (un fichier avec un suffixe .exe) est
gnr. Pour excuter ce fichier depuis la ligne de commande, tapez le nom de l'application (avec ou
sans le suffixe .exe).

Excution partir de Visual Studio
Pour excuter l'application depuis Visual Studio, cliquez sur Excuter sans dbogage dans le menu
Dboguer, ou appuyez sur CTRL+F5. Si l'application est une application console, une fentre de
console s'affiche automatiquement, et l'application est excute. Une fois l'excution termine, le
programme vous demande d'appuyer sur n'importe quelle touche pour continuer, et la fentre de
console se ferme.
2.4.3. Dbogage
Exceptions et dbogage JIT

Si votre application renvoie une exception et que vous n'avez pas crit de code pouvant grer cette
exception, le Common Language Runtime dclenche le dbogage J IT ( ne pas confondre avec le
compilateur J IT.)

En supposant que vous avez install Visual Studio, une bote de dialogue s'affiche pour vous permettre
de dboguer l'application en utilisant le dbogueur Visual Studio (environnement de dveloppement
Microsoft) ou le dbogueur fourni avec le Kit de dveloppement .NET Framework SDK.

Si vous avez accs Visual Studio, il est recommand de slectionner le dbogueur de Microsoft
Development Environment.

Dfinition de points d'arrt et d'espions dans Visual Studio
Vous pouvez utiliser le dbogueur Visual Studio pour dfinir des points d'arrt dans le code et
examiner la valeur des variables.
Pour afficher un menu contenant de nombreuses options utiles, cliquez avec le bouton droit sur une
ligne de code. Cliquez sur Insrer un point d'arrt pour insrer un point d'arrt sur cette ligne. Vous
pouvez galement insrer un point d'arrt en cliquant dans la marge gauche. Cliquez une nouvelle fois
pour supprimer ce point d'arrt. Lorsque vous excutez l'application en mode dbogage, l'excution
s'arrte au niveau de cette ligne et vous pouvez examiner le contenu des variables.

La fentre Espion est utile pour contrler la valeur des variables slectionnes lors de l'excution de
l'application. Si vous saisissez le nom d'une variable dans la colonne Nom, la valeur correspondante
s'affiche dans la colonne Valeur.
Lors de l'excution de l'application, toutes les modifications de cette valeur s'affichent. Vous pouvez
galement modifier par crasement la valeur d'une variable surveille.

3. Utilisation des variables de type
valeur
3.1. Systme de types communs (CTS, Common System
Type)
Chaque variable dispose d'un type de donnes qui dtermine quelles valeurs quelle peut stocker. C#
est un langage scuris au niveau des types : le compilateur C#s'assure que les types des valeurs
stockes dans les variables sont toujours appropris.
Le Common Language Runtime comprend un systme de types communs qui dfinit un ensemble de
types de donnes intgrs que vous pouvez utiliser pour dfinir vos variables.
3.1.1. Vue densemble du systme de types communs
Lorsque vous dfinissez une variable, vous devez lui attribuer un type de donnes appropri. Ce type
de donnes dtermine les valeurs autorises pour cette variable, et ces valeurs autorises dterminent
les oprations possibles sur la variable.

Le systme de types communs (CTS) fait partie intgrante du Common Language Runtime. Les
compilateurs, les outils et le Runtime lui-mme se partagent ce systme. Il est le modle dfinissant les
rgles suivies par le Runtime pour dclarer, utiliser et grer les types. Il dfinit une structure qui
permet l'intgration entre les langages, la scurit des types et une excution trs performante du code.
3.1.2. Comparaison des types valeur et rfrence
Types valeur
Les variables de type valeur contiennent directement leurs donnes. Chaque variable de type valeur
dispose de son propre jeu de donnes ; les oprations sur une variable de ce type ne peuvent donc pas
affecter une autre variable.

Types rfrence
Les variables de type rfrence contiennent des rfrences aux donnes qu'elles possdent. Leurs
donnes sont stockes dans un objet. Deux variables de type rfrence peuvent rfrencer le mme
objet. Les oprations sur une variable de ce type peuvent affecter l'objet rfrenc par une autre
variable de type rfrence.
3.1.3. Comparaison des types valeur dfinis par lutilisateur et des types
valeur intgrs
Il existe diffrents types valeur : les types dfinis par l'utilisateur et les types intgrs. En C#, leur
diffrence est minime, car les types dfinis par l'utilisateur peuvent tre utiliss de la mme faon que
les types intgrs. La seule vraie diffrence entre les types de donnes intgrs et les types de donnes
dfinis par l'utilisateur rside dans la possibilit d'utiliser des valeurs littrales pour les types intgrs.
Tous les types valeur contiennent des donnes, et celles-ci ne peuvent pas tre null.
3.1.4. Types simples
Les types valeur intgrs sont galement appels types de donnes de base, ou types simples. Des mots
cls rservs permettent d'identifier les types simples. Ces mots cls rservs sont des alias des types
struct prdfinis.

Il est impossible de distinguer un type simple du type struct dont il est l'alias. Dans votre code, vous
pouvez utiliser le mot cl rserv ou le type struct. Les exemples suivants illustrent les deux
possibilits :


byt e / / mot cl r eser v

/ / ou

Syst em. Byt e / / t ype st r uct

i nt / / mot cl r eser v

/ / ou

Syst em. I nt 32 / / t ype st r uct

Le tableau ci-dessus rpertorie les mots cls rservs les plus courants et leur type struct quivalent.

Mots cls rservs Alias du type struct
sbyt e Syst em. SByt e
byt e Syst em. Byt e
Shor t Syst em. I nt 16
ushor t Syst em. UI nt 16
i nt Syst em. I nt 32
ui nt Syst em. I nt 32
Long Syst em. I nt 64
ul ong Syst em. UI nt 16
Char Syst em. Char
f l oat Syst em. Si ngl e
doubl e Syst em. Doubl e
bool Syst em. Bool ean
deci mal Syst em. Deci mal
Tableau 4 - Mots clefs et leur quivalent en struct
3.2. Attribution de noms aux variables
Pour utiliser une variable, vous devez d'abord lui attribuer un nom appropri et significatif. Chaque
variable possde un nom, galement appel identificateur de variable.

Respectez les conventions d'affectation de noms standard recommandes pour C#. Mmorisez les
mots cls rservs en C#que vous ne pouvez pas utiliser comme noms de variables.
3.2.1. Rgles et recommandations pour laffectation de noms aux
variables
Lorsque vous attribuez un nom une variable, respectez les points suivants.

Rgles
Les points suivants correspondent aux rgles d'affectation de noms pour les variables C#:
- un nom de variable doit commencer par une lettre ou un trait de soulignement
- le premier caractre doit tre suivi par des lettres, des chiffres ou un trait de soulignement
- les mots cls rservs sont proscrits
- l'utilisation d'un nom de variable non autoris entranera une erreur de compilation

Recommandations
Voici les recommandations suivre pour l'affectation de noms de variables :
- viter d'utiliser uniquement de lettres majuscules
- viter les noms de variables commenant par un trait de soulignement
- viter d'utiliser des abrviations

- utiliser la convention de nom pe casse Pascal
Convention d'affectation de noms de type casse Pascal (PascalCasing)
Pour utiliser la convention ectation de noms de type casse Pascal, mettez en majuscules le premier
caractre de ch te convention pour les classes, les mthodes, les proprits, les
, les interfaces, les champs en lecture seule et les champs constants, les espaces de noms
proprits, comme illustr dans l'exemple suivant :

s de ty

d'aff
aque mot. Utilisez cet
numrations
et les
voi d I ni t i al i zeDat a( ) ;

Convention d'affectation de noms de type casse mixte (camelCasing)
Pour utiliser la convention d'affectation de noms de type casse mixte, mettez en majuscules le premier
caractre de chaque mot sauf pour le premier mot. Utilisez cette convention pour les variables qui
dfinissent les champs et les paramtres, comme illustr dans l'exemple suivant :

i nt l oopCount Max;
3.2.2. Mots cls en C#
Les mots cls sont rservs, ce qui signifie que vous ne pouvez pas les utiliser comme noms de
variables en C#. L'utilisation d'un mot cl comme nom de variable entranera une erreur de
compilation.

Vous trouverez ci-dessous la liste des mots cls de C#. Rappelez-vous que vous ne pouvez pas les
utiliser comme noms de variables.

abst r act as base bool br eak
byt e case cat ch char checked
cl ass const cont i nue deci mal def aul t
del egat e do doubl e el se enum
event expl i ci t ext er n f al se f i nal l y
f i xed f l oat f or f or each got o
i f i mpl i ci t i n i nt i nt er f ace
i nt er nal i s l ock l ong namespace
new nul l obj ect oper at or out
over r i de par ams pr i vat e pr ot ect ed publ i c
r eadonl y r ef r et ur n sbyt e seal ed
shor t si zeof st ackal l oc st at i c st r i ng
st r uct swi t ch t hi s t hr ow t r ue
t r y t ypeof ui nt ul ong unchecked
unsaf e ushor t usi ng vi r t ual voi d
vol at i l e
while

Tableau 5 - Mots cls de C#
3.3. Utilisation de types de donnes intgrs
Pour crer une variable, vous devez lui attribuer un nom, la dclarer et lui affecter une valeur, sauf si
C#lui a dj affect une valeur automatiquement.
3.3.1. Dclaration de variables locales
Les variables qui sont dclares dans les mthodes, les proprits ou les indexeurs sont appeles
variables locales. Gnralement, vous dclarez une variable locale en spcifiant le type de donnes
suivi du nom de la variable, comme illustr dans l'exemple suivant :

i nt i t emCount ;


Vous pouvez dclarer plusieurs variables dans une seule dclaration en utilisant un sparateur de type
virgule, comme illustr dans l'exemple suivant :

i nt i t emCount , employeeNumber;

En C#, vous ne pouvez pas utiliser de variables non initialises. Le code suivant entranera une erreur
de compilation, car aucune valeur initiale n'a t attribue la variable loopCount :

i nt l oopCount ;
Consol e. Wr i t eLi ne( " {0}" , l oopCount ) ; / / er r eur
3.3.2. Attribution de valeurs aux variables
Les oprateurs d'assignation sont utiliss pour attribuer une nouvelle valeur une variable. Pour
attribuer une valeur une variable dj dclare, utilisez l'oprateur d'assignation (=), comme illustr
dans l'exemple suivant :

i nt empl oyeeNumber ;
empl oyeeNumber = 23;

Vous pouvez aussi initialiser une variable lorsque vous la dclarez, comme illustr dans l'exemple
suivant :

i nt empl oyeeNumber = 23;

Vous pouvez utiliser l'oprateur d'assignation pour attribuer des valeurs aux variables de type
caractre, comme illustr dans l'exemple suivant :

char mi ddl eI ni t i al = ' J ' ;
3.3.3. Assignation compos
Ajouter une valeur une variable est une opration trs courante

i nt i t emCount ; / / dcl ar at i on de l a var i abl e
i t emCount = 2; / / af f ect at i on de l a val eur 2
i t emCount = i t emCount + 40; / / i ncr ment at i on de 40

La syntaxe abrge est pratique
Le code permettant d'incrmenter une variable fonctionne, mais il est quelque peu fastidieux. Vous
devez crire deux fois l'identificateur incrment. Pour les identificateurs simples, c'est rarement un
problme, sauf si vous disposez de plusieurs identificateurs avec des noms trs similaires. Toutefois,
vous pouvez utiliser des expressions de complexit arbitraire pour dsigner la valeur incrmente,
comme illustr dans l'exemple suivant :

i t ems[ ( i ndex + 1) %32] = i t ems[ ( i ndex + 1) %32] + 40;

Dans ces cas-l, si vous devez crire la mme expression deux fois, vous pouvez introduire facilement
un bogue subtil. Heureusement, il existe une syntaxe abrge qui permet d'viter la duplication :

i t emCount += 40;
i t ems[ ( i ndex + 1) %32] += 40;


Cette syntaxe abrge fonctionne pour tous les oprateurs arithmtiques

var += expr essi on; / / var = var + expr essi on
var - = expr essi on; / / var = var - expr essi on
var *= expr essi on; / / var = var * expr essi on
var / = expr essi on; / / var = var / expr essi on
var %= expr essi on; / / var = var %expr essi on
3.3.4. Oprateurs courants
Les expressions sont cres partir des oprandes et des oprateurs. Les oprateurs d'une expression
indiquent les oprations appliquer aux oprandes.

Certains des oprateurs les plus courants utiliss en C#sont dcrits dans le tableau ci-dessous.

Type Description Exemple
Oprateurs d'assignation
Attribuent des valeurs aux variables en utilisant une
simple assignation. Pour que l'assignation russisse, la
valeur situe droite de l'assignation doit tre d'un
type pouvant tre converti implicitement dans le type
de la variable situe gauche de l'assignation
=
*= / = %= += - =
<<= >>=
&= ^= | =
Oprateurs logiques relationnels Comparent deux valeurs. < > <= >= i s
Oprateurs logiques Excutent des oprations de bits sur les valeurs
Oprateur conditionnel
e && | | ?: Choisit entre deux expressions, selon un
expression boolenne
Oprateur d'incrment le d'une unit ++ Augmente la valeur de la variab
Oprateur de dcrment Diminue la valeur de la variable d'une unit - -
Oprateurs arithmtiques Excutent des oprations arithmtiques standard + - * / %
Tableau 6 - Oprateurs les plus couramment utiliss en C#
3.4. Cration de types de donnes dfinis par lutilisateur
3.4.1. Types numration (enum)
Les numrateurs sont utiles lorsqu'une variable ne peut avoir qu'un ensemble spcifique de valeurs.

Dfinition d'un type numration
Pour dclarer une numration, utilisez le mot cl enum suivi du nom de la variable d'numration et
des valeurs initiales. Par exemple, l'numration suivante dfinit trois constantes entires, appeles
valeurs de l'numrateur.

enumCol or { Red, Gr een, Bl ue };

Par dfaut, les valeu ent 0. Dans l'exemple prcdent, Red a la valeur 0,
Green la valeur 1 et

Utilisation d'un type numration
Vous pouvez dclarer une variable colorPalette de type Color en utilisant la syntaxe suivante :

rs de l'numrateur commenc
Blue, la valeur 2.
Col or col or Pal et t e ; / / Dcl ar e l a var i abl e
col or Pal et t e = Col or . Red ; / / Df i ni t une val eur
- ou -
col or Pal et t e = ( Col or ) 0 ; / / Cast i ng d un t ype i nt en Col or


Affichage d'une valeur numration
Pour afficher une valeur numration dans un format lisible, utilisez l'instruction suivante :

Consol e. Wr i t eLi ne( " {0}" , col or Pal et t e) ;
3.4.2. Types Structure (struct)
Vous pouvez utiliser des structures pour crer des objets qui se comportent comme des types valeur
intgrs. Comme les structures sont stockes en ligne et ne sont pas alloues un tas, la pression du
garbage collection sur le systme est moindre qu'avec les classes.

Dans le .NET Framework, tous les types de donnes simples tels que int, float et double sont des
structures intgres.

Dfinition d'un type structure
Vous pouvez utiliser une structure pour regrouper plusieurs types arbitraires, comme illustr dans
l'exemple suivant :

publ i c st r uct Empl oyee
{
publ i c st r i ng f i r st Name;
publ i c i nt age;
}

Ce code dfinit un nouveau type appel Employee qui se compose de deux lments :
first name et age.

Utilisation d'un type structure
Pour accder aux lments de la structure, vous devez utiliser la syntaxe suivante :

Empl oyee companyEmpl oyee; / / Dcl ar e une var i abl e
companyEmpl oyee. f i r st Name = " J ean" ; / / Df i ni t sa val eur
companyEmpl oyee. age = 23;
3.5. Conversion de types de donnes
3.5.1. Conversion
La conversion d'un type de donnes int en un type de donnes long est implicite. Cette conversion
russit toujours et n'entrane jamais de perte d'informations. L'exemple suivant illustre comment
convertir la variable intValue d'un type int en un type long :

implicite de types de donnes
usi ng Syst em;

cl ass Test
{
st at i c voi d Mai n( )
{
i nt i nt Val ue = 123;
l ong l ongVal ue = i nt Val ue;
Consol e. Wr i t eLi ne( " ( l ong) {0} = {1}" , i nt Val ue, l ongVal ue) ;
}
}

3.5.2. Conversion explicite de types de donnes
La conversion explicite de donnes peut s'effectuer l'aide d'une expression cast. L'exemple suivant
illustre comment convertir la variable longValue d'un type de donnes long en un type de donnes int
l'aide d'une expression cast :

usi ng Syst em;

cl ass Test
{
{
l ong l ongVal ue = I nt 64. MaxVal ue;
i nt i nt Val ue = ( i nt ) l ongVal ue;
Consol e. Wr i t eLi ne( " ( i nt ) {0} = {1}" , l ongVal ue, i nt Val ue) ;
}
}

Un dpassement s'tant produit dans cet e ant :

exemple, le rsultat est l suiv
( i nt ) 9223372036854775807 = - 1

Pour viter une telle situation, vous pouvez utiliser l'instruction checked pour lever une exception
lorsqu'une conversion choue, comme suit :

usi ng Syst em;

cl ass Test
{
{
checked
{
l ong l ongVal ue = I nt 64. MaxVal ue;
i nt i nt Val ue = ( i nt ) l ongVal ue;
Consol e. Wr i t eLi ne( " ( i nt ) {0} = {1}" , l ongVal ue, i nt Val ue) ;
}
}
}

4. Instructions et exceptions
4.1. Introduction aux instructions
Un programme se compose d'une suite d'instructions. Au moment de l'excution, ces instructions sont
excutes les unes aprs les autres, dans l'ordre dans lequel elles figurent dans le programme, de
gauche droite et de haut en bas.
4.1.1. Blocs d'instructions
Lorsque vous dveloppez des applications en C#, vous devez regrouper des instructions, tout comme
vous le faites dans d'autres langages de programmation. Vous utilisez pour cela la mme syntaxe qu'en
C, C++et J ava, c'est--dire que vous placez les groupes d'instructions entre accolades : {et}.

Groupement d'instructions dans des blocs
Un groupe d'instructions dlimit par une accolade ouvrante et une accolade fermante constitue un
bloc. Un bloc peut contenir une seule instruction ou un autre bloc imbriqu.

Chaque bloc dfinit une porte. Une variable dclare dans un bloc est qualifie de variable locale. La
porte d'une variable locale s'tend de sa dclaration jusqu' l'accolade fermante qui dlimite la fin de
son bloc. Le bon usage veut qu'une variable soit dclare dans le bloc le plus profondment imbriqu,
ainsi sa visibilit restreinte augmente la lisibilit du code.

Utilisation de variables dans des blocs d'instructions
Dans C#, vous ne pouvez pas dclarer un nom de variable identique dans un bloc interne et externe.
Par exemple, le code suivant n'est pas autoris :

i nt i ;
{
i nt i ; / / Er r eur : i dj dcl ar dans l e bl oc par ent
. . .
}

Vous pouvez toutefois dclarer des variables portant le mme nom dans des blocs frres. Les blocs
frres sont dlimits par le mme bloc parent et sont imbriqus au mme niveau.
En voici un exemple :

{
i nt i ;
. . .
}
. . .
{
i nt i ;
. . .
}

Les variables peuvent tre dclares n'importe o dans un bloc d'instructions, mais il est toutefois
recommand d'initialiser une variable au moment de sa dclaration.
4.1.2. Types d'instructions
La complexit de la logique d'un programme est proportionnelle la complexit du problme qu'il doit
rsoudre. Pour rsoudre des problmes complexes, le contrle du flux du programme doit tre

structur, ce qui peut tre obtenu l'aide de constructions ou d'instructions de haut niveau. Ces
instructions peuvent tre classes en trois catgories.

Les instructions conditionnelles
Les instructions if et switch sont des instructions conditionnelles (galement appeles instructions de
slection). Ces instructions prennent des dcisions en fonction de la valeur des expressions et
excutent des instructions de manire slective en fonction de ces dcisions.

Les instructions d'itration
Les instructions while, do, for et foreach s'excutent tant qu'une condition particulire est vraie. Elles
sont galement qualifies d'instructions de bouclage, du fait de leur caractre rptitif. Chacune de ces
instructions correspond un style particulier d'itration.

Les instructions de saut
Les instructions goto, break et continue permettent de passer de faon inconditionnelle le contrle
une autre instruction.
4.2. Utilisation des instructions conditionnelles
4.2.1. L'instruction if
La premire instruction dcisionnelle est l'instruction if. Elle peut tre associe une clause else
facultative, comme illustr ci-dessous :

i f ( mi nut e == 60 )
mi nut e = 0 ;
el se
mi nut e++ ;

L'instruction if value une expression boolenne afin de dterminer la marche suivre. Si l'expression
boolenne a la valeur true, la premire instruction incorpore est excute. Si l'expression boolenne a
la valeur false et qu'il y a une clause else, le contrle est pass la seconde instruction incorpore.

L'instruction else if permet de traiter les instructions if en cascade.

i f ( mi nut e == 60 )
mi nut e = 0 ;
el se i f ( mi nut e == - 1 )
mi nut e- - ;
el se
mi nut e++ ;

La construction else if permet un nombre indfini de branchements. Cependant, les instructions
contrles par une instruction if en cascade tant mutuellement exclusives, une seule instruction de
l'ensemble de constructions else if sera excute.
4.2.2. L'instruction switch
L'instruction switch offre une mthode de traitement des conditions complexes plus lgante que les
instructions if imbriques. Elle se compose de plusieurs blocs de case, chaque bloc spcifiant une
constante unique et une tiquette case associe.

Un bloc switch peut contenir des dclarations. La porte d'une variable locale ou d'une constante
dclare dans un bloc switch s'tend depuis sa dclaration jusqu' la fin du bloc switch, comme
l'illustre l'exemple reproduit sur la diapositive.


Excution des instructions switch
Une instruction switch s'excute comme suit :

1 - Si l'une des constantes spcifies dans une tiquette case est gale la valeur de l'expression
switch, la liste des instructions qui suit l'tiquette case correspondante est excute.

2 - Si aucune constante case n'est gale la valeur de l'expression switch et si l'instruction switch
contient une tiquette default, la liste des instructions qui suit l'tiquette default est excute.

3 - Si aucune constante case n'est gale la valeur de l'expression switch et si l'instruction switch ne
contient pas d'tiquette default, le contrle est transfr la fin de l'instruction switch.

swi t ch ( at out )
{
case Sui t e. Pi que :
coul eur = " Noi r " ;
br eak;
case Sui t e. Car r eau :
coul eur = " Rouge" ;
br eak;
def aul t :
coul eur = " ERREUR" ;
br eak;
}

L'instruction switch value uniquement les types d'expressions suivants : tous les entiers, char, enum
et string. Vous pouvez toutefois valuer d'autres types d'expressions l'aide de l'instruction switch du
moment qu'il existe prcisment une conversion implicite dfinie par l'utilisateur du type non autoris
vers les types autoriss.

Utilisation de l'instruction break dans les instructions switch
Contrairement ce qui se passe dans les langages J ava, C ou C++, les instructions C#associes une
ou plusieurs tiquettes case ne doivent pas passer silencieusement ou se brancher sur l'tiquette case
suivante. Un passage silencieux se produit lorsque l'excution se poursuit sans gnrer d'erreur.
Autrement dit, vous devez vous assurer que la dernire instruction associe un groupe d'tiquettes
case ne permet pas au flux de contrle d'atteindre le groupe suivant d'tiquettes case.

Pour respecter cette rgle, appele rgle de non-passage, vous pouvez recourir l'une des instructions
suivantes : break (probablement la plus courante), goto (trs rare), return, throw ou une boucle
infinie.
4.3. Utilisation des instructions d'itration
4.3.1. L'instruction while
Parmi les instructions d'itration, while est la plus simple utiliser. Elle excute une instruction
incorpore tant que l'expression boolenne est vraie.

Une instruction while s'excute comme suit :

1 - L'expression boolenne qui contrle l'instruction while est value.
2 - Si l'expression boolenne a la valeur true, l'instruction incorpore est excute. la fin de cette
excution, le contrle repasse implicitement au dbut de l'instruction while et l'expression boolenne
est de nouveau analyse.

3 - Si l'expression boolenne a la valeur false, le contrle est transfr la fin de l'instruction while.
Par consquent, le programme rexcute l'instruction incorpore tant que l'expression boolenne a la
valeur true.

L'expression boolenne tant teste au dbut de la boucle while, il est possible que l'instruction
incorpore ne soit jamais excute.

i nt i = 0;
whi l e ( i < 10)
{
Consol e. Wr i t eLi ne( i ) ;
i ++;
}

/ / af f i che : 0 1 2 3 4 5 6 7 8 9
4.3.2. L'instruction do
L'instruction do est toujours accompagne d'une instruction while. Elle est similaire l'instruction
while, cette diffrence prs que l'analyse de l'expression boolenne qui dtermine la poursuite ou la
sortie de la boucle s'effectue en fin de boucle, et non pas au dbut. Cela signifie que, contrairement
une instruction while qui est excute zro ou plusieurs fois, une instruction do est excute une au
moins fois.

Une instruction do s'excute comme suit :

1 - L'instruction incorpore est excute.
2 - Cela fait, l'expression boolenne est value.
3 - Si l'expression boolenne a la valeur true, le contrle est transfr au dbut de l'instruction do.
4 - Si l'expression boolenne a la valeur false, le contrle est transfr la fin de l'instruction do.

i nt i = 0;
do
{
i ++;
}
whi l e ( i < 10)

/ / af f i che : 0 1 2 3 4 5 6 7 8 9
4.3.3. L'instruction for
Dans L'instruction for, le code d'actualisation se trouve au dbut de la boucle o il est plus
difficilement oubli. La syntaxe de l'instruction for est la suivante :

f or ( initialiseur ; condition ; actualisation )
i nst r uct i on- i ncor por e

La syntaxe de l'instruction for est pratiquement identique celle de l'instruction while, comme
l'illustre l'exemple suivant :

initialiseur
whi l e ( condition )
{
i nst r uct i on- i ncor por e
actualisation
}


Comme dans toutes les instructions de rptition, la condition d'un bloc for doit tre une expression
boolenne qui tient lieu de condition de poursuite de la boucle et non pas de condition de fin.
Exemple
Comme pour les instructions while et do, vous pouvez utiliser une seule instruction incorpore ou un
bloc d'instructions, comme dans les exemples suivants :

f or ( i nt i = 0 ; i < 10 ; i ++ )

/ / af f i che : 0 1 2 3 4 5 6 7 8 9

f or ( i nt i = 0 ; i < 10 ; i ++ ) {
Consol e. Wr i t eLi ne( i - 9) ;
}

/ / af f i che : 0 - 9 1 - 8 2 - 7 3 - 6 4 - 5 5 - 4 6 - 3 7 - 2 8 - 1 9 0

Dclaration de variables
Il existe une petite diffrence entre les instructions while et for : la porte d'une variable dclare dans
le code d'initialisation d'une instruction for est limite au bloc for. Ainsi, l'exemple suivant gnre une
erreur de compilation :

f or ( i nt i = 0; i < 10; i ++ )

Consol e. Wr i t eLi ne( i ) ; / / Er r eur : i n' est pl us dans l a por t e

Notez, par ailleurs, que vous ne pouvez pas dclarer dans un bloc for une variable portant le mme
nom qu'une autre variable place dans un bloc externe. Ainsi, l'exemple suivant gnre une erreur de
compilation :

i nt i ;
f or ( i nt i = 0; i < 10; i ++) / / Er r eur : i est dj dans l a por t e

En outre, vous pouvez initialiser deux variables ou plus dans le code d'initialisation d'une instruction
for de la manire suivante :

f or ( i nt i = 0, j = 0; i < 10; i ++)

Les variables doivent toutefois tre du mme type. Par consquent, l'exemple suivant n'est pas autoris :

f or ( i nt i = 0, l ong j = 0; i < 10; i ++)

Pour mettre plusieurs instructions dans le code d'actualisation d'une instruction for, il faut les sparer
par une virgule ou plusieurs virgules, comme suit :

f or ( i nt i = 0, j = 0; i < 10 ; i ++, j ++)

L'instruction for est adapte aux situations dans lesquelles le nombre d'itrations est connu. Elle est
galement particulirement approprie pour modifier chaque lment d'un tableau.

4.3.4. L'instruction foreach
Les collections sont des entits logicielles qui servent collecter d'autres entits logicielles. Nous
pouvons faire une analogie avec un grand livre qui forme une collection de comptes, ou avec une
maison qui est une collection de pices.

Microsoft .NET Framework offre une classe de collection simple nomme ArrayList. Elle permet de
crer une variable de collection et d'ajouter des lments la collection. Considrons une collection
comme une liste.

C#fournit l'instruction foreach, qui permet de parcourir chaque lment d'une collection sans recourir
une longue liste d'instructions. Plutt que d'extraire explicitement chaque lment d'une collection
collection, l'instruction foreach permet d'aborder le problme
it la collection de prsenter ses lments, les uns la suite des
autres. Ce n'est plus l'instruction incorpore qui est apporte la collection, c'est la collection qui est
apporte l'instruction incorpore.

Examinons par exemple le code suivant :
avec une syntaxe spcifique la
diffremment. Vous demandez en fa

usi ng Syst em. Col l ect i ons;

Ar r ayLi st number s = new Ar r ayLi st ( ) ; / / number s est une col l ect i on

f or ( i nt i = 0; i < number s. Count ; i ++) {
i nt number = ( i nt ) number s[ i ] ;
Consol e. Wr i t eLi ne( number ) ;
}

/ / L' i nst r uct i on f or pr cdent e peut t r e r cr i t e
/ / comme sui t avec une i nst r uct i on f or each

f or each ( i nt number i n number s)
Consol e. Wr i t eLi ne( number ) ;
4.4. Utilisation des instructions de saut
4.4.1. L'instruction goto
L'instruction goto est l'instruction de saut la plus primitive du langage C#. Elle permet de passer le
contrle d'excution une instruction marque par une tiquette. L'tiquette doit exister et sa porte
doit s'tendre l'instruction goto. Plusieurs instructions goto peuvent transfrer le contrle d'excution
vers la mme tiquette.

L'instruction goto peut transfrer le contrle l'extrieur d'un bloc, mais ne peut jamais le transfrer
dans un bloc. Le but de cette restriction est d'viter de sauter une initialisation. Cette mme rgle est
applique en C++et dans d'autres langages
.
L'instruction goto et l'tiquette cible peuvent tre trs loignes l'une de l'autre dans le code. Cette
distance pouvant obscurcir la logique du flux de contrle, la plupart des guides de programmation
recommandent de ne pas utiliser les instructions goto.


i f ( number %2 == 0) got o Even;
Consol e. Wr i t eLi ne( " odd" ) ;
got o End;

Even:
Consol e. Wr i t eLi ne( " even" ) ;
End: ;

/ / af f i che : even

Les instructions goto sont recommandes dans les deux cas suivants : dans les instructions switch et
pour sortir d'une boucle imbrique.
4.4.2. Les instructions break et continue
Une instruction break permet de sortir de la plus proche instruction switch, while, do, for ou foreach
qui l'entoure. Une instruction continue provoque une nouvelle itration de la plus proche instruction
switch, while, do, for ou foreach qui l'entoure.

Les instructions break et continue ne sont pas trs diffrentes d'une instruction goto, qui elle peut
aisment obscurcir la logique du flux de contrle.

i nt i = 0;
whi l e ( t r ue)
{
i ++;
i f ( i < 10)
cont i nue;
el se
br eak;
}

/ / af f i che : 0 1 2 3 4 5 6 7 8 9
4.5. Gestion des exceptions fondamentales
4.5.1. Objets exception
Voici un code d'erreur de programmation utilis dans du code de gestion des erreurs de type procdure

enumEr r or Code { Secur i t yEr r or =- 1, I OEr r or =- 2, Out Of Memor yEr r or =- 3, . . . }

Ce type de code d'erreur ne permet pas de fournir aisment les informations qui aideront la rparer.
Ainsi, la gnration de IOError ne vous renseigne pas sur le type prcis de l'erreur.
S'agit-il d'une tentative d'criture sur un fichier en lecture seule ou sur un fichier inexistant, ou d'un
disque corrompu ? Sur quel fichier a lieu la tentative de lecture ou d'criture ?

Pour remdier ce manque d'information sur l'erreur gnre, .NET Framework a dfini un ensemble
de classes d'exceptions.

Toutes les exceptions sont hrites de la classe nomme Exception, qui fait partie du Common
Language Runtime. Limage ci-dessus prsente la hirarchie de ces exceptions.



Figure 4 - Hirarchie des exceptions

Les classes d'exceptions offrent les avantages suivants :
- Les messages d'erreur ne sont plus reprsents par des valeurs d'entier ou des numrations
Les valeurs d'entier de programmation, telles que -3 ont t supprimes. Elles ont t remplaces par
les classes d'exceptions, telle que OutOfMemoryException. Chaque classe d'exceptions peut rsider
dans son propre fichier source, et tre dissocie de toutes les autres classes d'exceptions.

- Des messages d'erreur significatifs sont gnrs.
Chaque classe d'exceptions dcrit clairement l'erreur qu'elle reprsente. Une classe nomme
OutOfMemoryException remplace efficacement un 3. Chaque classe d'exceptions peut galement
sont propres. Ainsi, une classe FileNotFoundException peut
e.
4.5.2. Utilisation des blocs try et catch
La programmation oriente objet offre une solution structure de gestion des erreurs, sous la forme de
blocs try et catch. L'ide est de sparer physiquement les instructions essentielles du programme qui
grent son droulement normal, des instructions de gestion des erreurs. Par consquent, les parties de
code susceptibles de lever des exceptions sont places dans un bloc try, et le code de traitement de ces
exceptions est plac dans un bloc catch distinct.

La syntaxe d'un bloc catch est la suivante :

contenir des informations qui lui
contenir le nom du fichier introuvabl
cat ch ( identificateur-de-type-de-classe ) { . . . }

Le type de classe doit tre soit System.Exception, soit un type driv de System.Exception.

L'identificateur, qui est facultatif, est une variable locale en lecture seule dans la porte du bloc catch.

cat ch ( Except i on caught ) {
. . .
}
Consol e. Wr i t eLi ne( caught ) ; / / Er r eur de compi l at i on
/ / caught n' est pl us dans l a por t e

t r y {
Consol e. Wr i t eLi ne( " Ent r ez un nombr e" ) ;
i nt i = i nt . Par se( Consol e. ReadLi ne( ) ) ;
}
cat ch ( Over f l owExcept i on caught )
{
Consol e. Wr i t eLi ne( caught ) ;
}


L'exemple de code ci-dessus illustre l'utilisation des instructions try et catch. Le bloc try entoure une
expression susceptible de gnrer une exception. Si l'exception est leve, le Runtime interrompt
l'excution et cherche un bloc catch pouvant intercepter cette exception (en fonction de son type). Si le
Runtime ne trouve pas de bloc catch appropri dans la fonction la plus proche, il droule la pile des
appels pour trouver l'appel de fonction. Si le bloc catch appropri ne s'y trouve pas, il recherche la
fonction qui a mis l'appel, et ainsi de suite jusqu' ce qu'il trouve un bloc catch appropri (Ou jusqu'
ce qu'il atteigne la fin de Main, auquel cas le programme s'arrte). Si le Runtime trouve un bloc catch,
il considre que l'exception est intercepte, et il reprend l'excution du code partir du corps du bloc
catch.
4.5.3. Blocs catch multiples
Un bloc de code l'intrieur d'une construction try peut comporter plusieurs instructions. Chaque
instruction peut lever une ou plusieurs classes d'exceptions. Comme il existe un grand nombre de
classes d'exceptions, vous pouvez utiliser plusieurs blocs catch, qui interceptent chacun un type
d'exception particulier.

Une exception est intercepte uniquement sur la base de son type. Le runtime intercepte
automatiquement les objets exception d'un type particulier dans un bloc catch du type correspondant.

Considrons le code suivant pour mieux apprhender le fonctionnement d'un bloc try-catch multiple :

1. t r y {
2. Consol e. Wr i t eLi ne( " Ent r ez l e pr emi er nombr e" ) ;
3. i nt i = i nt . Par se( Consol e. ReadLi ne( ) ) ;
4. Consol e. Wr i t eLi ne( " Ent r ez l e second nombr e" ) ;
5. i nt j = i nt . Par se( Consol e. ReadLi ne( ) ) ;
6. i nt k = i / j ;
7. }
8. cat ch ( Over f l owExcept i on caught )
9. {
10. Consol e. Wr i t eLi ne( caught ) ;
11. }
12. cat ch( Di vi deByZer oExcept i on caught )
13. {
14. Consol e. Wr i t eLi ne( caught ) ;
15. }

La ligne 3 initialise int i avec une valeur lue partir de la console. Cette opration est susceptible de
lever un objet exception de la classe OverflowException. Si c'est le cas, les lignes 4, 5 et 6 ne sont pas
exc es. xcu on s enti d'excution est transfr sur
le premier bloc catch cap le d' le, il s'agit du bloc catch de
la ligne 8.

En revanche, si les lignes 3 5 ne lvent aucune exception, l'excution squentielle se poursuit
normalement jusqu' la ligne 6. Cette ligne est susceptible de lever un objet exception de la classe
DivideByZeroException. Si c'est le cas, le flux de contrle passe au bloc catch la ligne 12, excute
ce bloc.

Si aucune des instructions du bloc try ne lve d'exception, le flux de contrle atteint la fin de ce bloc.
Remarquez que le flux de contrle n'entre dans un bloc catch que si une exception a t leve.

Vous pouvez crire les instructions dans un bloc try sans vous inquiter de savoir si une instruction
antrieure dans ce bloc risque d'chouer. Si une instruction antrieure lve une exception, le flux de
contrle n'atteindra pas physiquement les instructions qui la suivent dans le bloc try.
ut L'e ti qu elle normale est interrompue et le contrle
ab intercepter cette exception. Dans cet exemp

4.6. Leve d'exceptions
4.6.1. L'instruction throw
Exceptions dfinies par le systme
Pour lever une exception, le Runtime excute une instruction throw et lve une exception dfinie par
le systme. L'excution squentielle normale du programme est interrompue immdiatement et le
contrle d'excution est transfr sur le premier bloc catch capable de grer l'exception, en fonction de
sa classe.

Comment lever vos propres exceptions
Vous pouvez recourir l'instruction throw pour lever vos propres exceptions :

i f ( mi nut e < 1 | | mi nut e >= 60) {
st r i ng f aul t = mi nut e + " n' est pas une mi nut e val i de" ;
t hr ow new I nval i dTi meExcept i on( f aul t ) ;
/ / ! ! Pas at t ei nt ! !
}

Dans cet exemple, l'instruction throw lve une exception dfinie par l'utilisateur,
InvalidTimeException, si le temps analys ne correspond pas une valeur de temps correcte.
En rgle gnrale, les exceptions sont cres avec une chane de message significatif en paramtre. Ce
message est affich ou enregistr au moment o l'exception est dtecte. Il est galement recommand
de lever une classe d'exceptions approprie.
4.6.2. La clause finally
C#fournit la clause finally pour entourer les instructions qui doivent tre excutes, quoi qu'il arrive.
Autrement dit, si le contrle sort normalement d'un bloc try parce que le flux de contrle a atteint la fin
de ce bloc, les instructions du bloc finally sont excutes. De mme, si le contrle d'excution sort
d'un bloc try en raison d'une instruction throw ou d'une instruction de saut, telle que break, continue
ou goto, les instructions de la clause finally sont excutes.

Le bloc finally est utile dans deux circonstances : pour viter la duplication d'instructions et pour
librer des ressources aprs la leve d'une exception.

t r y {
. . .
}
cat ch {
. . .
}
f i nal l y {
instructions
}

5. Mthodes et paramtres
5.1. Utilisation des mthodes
5.1.1. Dfinition des mthodes
Une mthode est un groupe d'instructions C#qui ont t rassembles et auxquelles un nom a t
attribu. La plupart des langages de programmation modernes partagent un concept similaire ; vous
pouvez vous reprsenter une mthode comme une fonction, une sous-routine, une procdure ou un
sous-programme.

Syntaxe pour la dfinition des mthodes
Pour crer une mthode, utilisez la syntaxe suivante :

st a e( ) t i c voi d NomMthod
{
/ / cor ps de l a mt hode
}

Exemples de mthodes
L'exemple suivant montre comment crer une mthode appele ExampleMethod dans la classe
ExampleClass :

usi ng Syst em;
cl ass Exampl eCl ass
{
st at i c voi d Exampl eMet hod( )
{
Consol e. Wr i t eLi ne( " Mt hode Exampl eMet hod" ) ;
}

{
Consol e. Wr i t eLi ne( " Mt hode Mai n" ) ;
}
}

Le code contient trois mthodes :
- Main
- WriteLine
- ExampleMethod

La mthode Main est le point d'entre de l'application. La mthode WriteLine fait partie intgrante de
Microsoft.NET Framework. Cest une mthode statique de la classe System.Console. La mthode
ExampleMethod appartient la classe ExampleClass.

Dans le langage C#, toutes les mthodes appartiennent une classe. Ce n'est pas le cas des langages de
programmation tels que C, C++et Microsoft Visual Basic, qui autorisent l'utilisation de fonctions et
de sous-routines globales.

Cration de mthodes
Lorsque vous crez une mthode, vous devez spcifier les lments suivants :

- Nom :

Vous ne pouvez pas attribuer une mthode un nom identique celui d'une variable, d'une constante
ou de tout lment qui n'est pas une mthode dclare dans la classe. Il est possible d'utiliser comme
nom de mthode tout identificateur C#autoris. Ce nom respecte la casse.

- Liste des paramtres :
Le nom de la mthode est suivi par la liste des paramtres de la mthode.
Cette liste figure entre parenthses. Ces parenthses doivent tre utilises mme si la liste ne contient
aucun paramtre, comme le montrent les exemples du dessus.

- Corps de la mthode :
la suite des parenthses, se trouve le corps de la mthode. Vous devez placer le corps de la mthode
entre accolades ({ et }), mme si une seule instruction est utilise.
5.1.2. Appel de mthodes
Lo ie, vous pouvez l'appeler partir de la classe dans laquelle elle a t
dfinie et partir d'autres classes.

Pour appeler une mthode, utilisez le nom de la mthode suivi de la liste des paramtres entre
parenthses. Les parenthses sont requises mme si la mthode que vous appelez ne contient aucun
paramtre, comme le montre l'exemple suivant.

rsqu'une mthode est dfin
Met hodName( ) ;

Dans l'exemple suivant, le programme commence au dbut de la mthode Main de la classe
ExampleClass. La premire instruction affiche Le programme dmarre . La deuxime instruction
de la mthode Main est l'appel de la mthode ExampleMethod. Le flux de contrle passe la
premire instruction de la mthode ExampleMethod et le message Hello, world s'affiche. la fin
de la mthode, le contrle passe l'instruction qui suit immdiatement l'appel de la mthode, c'est--
dire l'instruction qui affiche le message Le programme prend fin .

usi ng Syst em;
cl ass Exampl eCl ass
{
{
Consol e. Wr i t eLi ne( " Hel l o, wor l d" ) ;
}

{
Consol e. Wr i t eLi ne( " Le pr ogr amme dmar r e" ) ;
Exampl eMet hod( ) ;
Consol e. Wr i t eLi ne( " Le pr ogr amme pr end f i n" ) ;
}
}
5.1.3. Utilisation de l'instruction return
Vous pouvez utiliser l'instruction return pour qu'une mthode retourne immdiatement l'appelant.
Sans instruction return, l'excution retourne l'appelant lorsque la dernire instruction de la mthode
est atteinte.

Par dfaut, une mthode retourne son appelant lorsque la fin de la dernire instruction du bloc de
code est atteinte. Si vous souhaitez qu'elle retourne immdiatement l'appelant, utilisez l'instruction
return.


Dans l'exemple suivant, la mthode affiche Hello et retourne immdiatement son appelant :

{
Consol e. Wr i t eLi ne( " Hel l o" ) ;
r et ur n;
Consol e. Wr i t eLi ne( " Wor l d" ) ;
}

Il n'est pas trs utile d'utiliser l'instruction return de cette faon, car l'appel final de la mthode
Console.WriteLine n'est jamais excut.
5.1.4. Retour de valeurs
Dclaration de mthodes avec un type de retour non void
Pour dclarer une mthode de faon ce qu'elle retourne une valeur l'appelant, remplacez le mot cl
void par le type de la valeur retourner.

Ajout d'instructions return
Le mot cl return suivi d'une expression termine la mthode immdiatement et retourne l'expression
comme valeur de retour de la mthode.

L'exemple suivant montre comment dclarer une mthode nomme TwoPlusTwo qui retourne la
valeur 4 la mthode Main lorsque la mthode TwoPlusTwo est appele :

cl ass Exampl eRet ur ni ngVal ue
{
st at i c i nt TwoPl usTwo( )
{
i nt a, b;
a = 2;
b = 2;
r et ur n a + b;
}
}

Notez que la valeur retourne est un entier (int). int est en effet le type de retour de la mthode.
Lorsque la mthode est appele, la valeur 4 est retourne.

Si vous dclarez une mthode avec un type non void, vous devez ajouter au moins une instruction
return. Le compilateur vrifie que chaque mthode non void retourne dans tous les cas une valeur la
mthode appelante.
5.2. Utilisation des paramtres
5.2.1. Dclaration et appel de paramtres
Les paramtres permettent aux informations d'tre passes l'intrieur et l'extrieur d'une mthode.
Lorsque vous dfinissez une mthode, vous pouvez inclure une liste de paramtres entre parenthses,
prcde du nom de la mthode.

Dclaration des paramtres
Chaque paramtre se caractrise par un type et un nom. Pour dclarer des paramtres, vous devez
placer les dclarations de paramtres l'intrieur des parenthses qui suivent le nom de la mthode. La
syntaxe utilise pour dclarer les paramtres est similaire celle utilise pour dclarer des variables
locales, sauf que vous sparez chaque dclaration de paramtre par une virgule au lieu d'un point-
virgule.


L'exemple suivant montre comment dclarer une mthode avec des paramtres.

st at i c voi d Met hodWi t hPar amet er s( i nt n, st r i ng y)
{
/ / . . .
}

Cet exemple montre comment dclarer la mthode MethodWithParameters avec deux paramtres : n
et y. Le premier paramtre est du type int (entier) et le second du type string (chane). Notez que des
virgules sparent chaque paramtre dans la liste des paramtres.

Appel de mthodes avec des paramtres
Le code appelant doit fournir les valeurs des paramtres lorsque la mthode est appele.

Le code suivant illustre une faon d'appeler une mthode avec des paramtres. Les valeurs des
paramtres sont trouves et places dans les paramtres n et y au dbut de l'excution de la mthode
MethodWithParameters.

Met hodWi t hPar amet er s( 2, " Hel l o, Wor l d" ) ;
5.2.2. Mcanismes de passage de paramtres
Il existe trois faons de passer des paramtres :

- Par valeur (in) :
Les paramtres par valeur sont parfois appels paramtres d'entre parce que les donnes peuvent tre
transfres l'intrieur de la mthode mais non l'extrieur.

- Par rfrence (in out) :
Les paramtres par rfrence sont parfois appels paramtres d'entre/sortie parce que les donnes
peuvent tre transfres l'intrieur de la mthode puis nouveau l'extrieur.

- Par sortie (out) :
Les paramtres de sortie sont appels ainsi parce que les donnes peuvent tre transfres l'extrieur
de la mthode, mais non l'intrieur.
5.2.3. Passage par valeur
Dfinition des paramtres par valeur
La dfinition la plus simple d'un paramtre est un nom de type suivi d'un nom de variable. On parle de
paramtre par valeur. Lorsque la mthode est appele, un nouvel emplacement de stockage est cr
pour chaque paramtre par valeur, et les valeurs des expressions correspondantes y sont copies.

l'intrieur de la mthode, vous pouvez crire du code qui modifie la valeur du paramtre. Ceci n'aura
aucun effet sur les variables situes en dehors de l'appel de la mthode.

Dans l'exemple suivant, la variable x l'intrieur de la mthode AddOne et peut tre modifie dans la
mthode AddOne, mais cette modification n'a pas d'effet sur la variable k.


st at i c voi d AddOne( i nt x)
{
x++;
}

{
i nt k = 6;
AddOne( k) ;
Consol e. Wr i t eLi ne( k) ; / / Af f i che l a val eur 6, mai s pas 7
}
5.2.4. Passage par rfrence
Dfinition des paramtres par rfrence
Un paramtre par rfrence fait rfrence un emplacement dans la mmoire. Contrairement un
paramtre par valeur, un paramtre par rfrence ne cre pas de nouveaux emplacements de stockage.
Au lieu de cela, il reprsente le mme emplacement dans la mmoire que la variable qui est fournie
dans l'appel de la mthode.

Modification des valeurs des paramtres par rfrence
Si vous modifiez la valeur d'un paramtre par rfrence, la variable fournie par l'appelant est
galement modifie, car elles font toutes deux rfrence au mme emplacement dans la mmoire.
L'exemple suivant montre comment la modification du paramtre par rfrence entrane galement
celle de la variable :

st at i c voi d AddOne( r ef i nt x)
{
x++;
}

{
i nt k = 6;
AddOne( r ef k) ;
Consol e. Wr i t eLi ne( k) ; / / Af f i che l a val eur 7
}

Affectation des paramtres avant l'appel de la mthode
Un paramtre ref doit tre dfinitivement assign au point de l'appel ; en d'autres termes, le
compilateur doit pouvoir s'assurer qu'une valeur a bien t assigne avant que l'appel ne soit effectu.
L'exemple prcdent montre comment vous pouvez initialiser des paramtres par rfrence avant
d'appeler une mthode.

L'exemple suivant montre ce qui se produit si un paramtre par rfrence k n'est pas initialis avant
que sa mthode AddOne ne soit appele :

i nt k;
AddOne( r ef k) ;
Consol e. Wr i t eLi ne( x) ;

Le compilateur C#rejette ce code et affiche le message d'erreur suivant :
Utilisation d'une variable locale non assigne 'k' .
5.2.5. Paramtres de sortie
Dfinition des paramtres de sortie

Les paramtres de sortie sont identiques aux paramtres par rfrence, sauf qu'ils transfrent des
donnes l'extrieur de la mthode et non pas l'intrieur. Tout comme un paramtre par rfrence,
un paramtre de sortie e e stockage fourni par l'appelant.
Toutefois, il n'est pas ncessaire d'assigner une va le paramtre out avant
que l'appel ne soit effectu ; la mthode suppose que le paramtre n'a pas t initialis l'entre.

Les paramtres de sortie sont utiles lorsque vous voulez retourner des valeurs partir d'une mthode
au moyen d'un paramtre sans assigner de valeur initiale ce dernier.

Utilisation des paramtres de sortie
Pour dclarer un paramtre de sortie, utilisez le mot cl out avant le type et le nom, comme le montre
l'exemple suivant :

st une rfrence un emplacement d
leur la variable fournie pour
st at i c voi d Out Demo( out i nt p)
{
/ / . . .
}

Tout comme c'est le cas avec le mot cl ref, le mot cl out assigne un seul paramtre, et chaque
paramtre out doit tre marqu sparment.
Lorsque vous appelez une mthode avec un paramtre out, placez le mot cl out avant la variable
passer, comme dans l'exemple suivant :

i nt n;
Out Demo( out n) ;

Dans le corps de la mthode appele, aucune supposition de dpart n'est faite sur le contenu du
paramtre de sortie. Il est trait comme une variable locale non assigne. Une valeur doit tre assigne
au paramtre out l'intrieur de la mthode.

6. Tableaux
6.1. Vue d'ensemble des tableaux
1.1. Qu'est ce qu'un tableau ?
Les tableaux sont des squences de donnes de mme type. Vous pouvez accder un lment
individuel d'un tableau en utilisant sa position d'entier, qui s'appelle un index.
Les tableaux autorisent l'accs alatoire. Les lments d'un tableau sont situs dans la mmoire
contigu. Cela signifie qu'un programme peut accder aussi rapidement tous les lments d'un
tableau.
6.1.2. Notation de tableau en C#
Vous utilisez la mme notation pour dclarer un tableau ou une simple variable. Spcifiez d'abord le
type, puis le nom de la variable suivi d'un point-virgule. Vous dclarez le type de la variable comme
un tableau l'aide de crochets. De nombreux autres langages de programmation, comme C et C++,
utilisent galement les crochets pour dclarer un tableau.

En C#, la notation de tableau est identique celle employe par C et C++, ces diffrences prs :

- Vous ne pouvez pas crire de crochets droite du nom de la variable.
- Vous ne spcifiez pas la taille du tableau lorsque vous dclarez une variable tableau.

Les exemples suivants illustrent des notations autorises et interdites en C#:

6.
t ype[ ] name; / / Aut or i s
t ype name[ ] ; / / I nt er di t en C#
t ype[ 4] name; / / gal ement i nt er di t en C#
6.1.3. Rang de tableau
Pour dclarer une variable tableau une dimension, vous utilisez des crochets simples comme illustr
dans lexemple prcdent. Un tableau de ce type s'appelle galement tableau de rang 1, car un index
entier est associ chaque lment du tableau.

Pour dclarer un tableau deux dimensions, vous utilisez une virgule l'intrieur des crochets, comme
illustr sur la diapositive. Un tableau de ce type s'appelle galement tableau de rang 2, car deux index
entiers sont associs chaque lment du tableau. Cette notation s'tend simplement comme suit :
chaque virgule supplmentaire spcifie entre les crochets incrmente d'une unit le rang du tableau.

Vous n'incluez pas la longueur des dimensions dans la dclaration d'une variable tableau.

Figure 5 - Rangs de tableaux
6.1.4. Accs aux lments d'un tableau
Pour accder un lment l'intrieur d'un tableau de rang 1, utilisez un index entier. Pour accder
un lment l'intrieur d'un tableau de rang 2, utilisez deux index entiers spars par une virgule. Pour

accder un lment l'intrieur d'un tableau de rang n, utilisez n index entiers spars par des
virgules.

Les index de tableau (de tout rang) dmarrent zro. Pour accder au premier lment l'intrieur
d'une ligne, utilisez l'expression :

r ow[ 0]

Plutt que l'expression :

r ow[ 1]

Figure 6 - Accs des lments de tableau plusieurs dimensions
6.1.5. Vrification des limites de tableau
En C#, une expression d'accs un lment de tableau est automatiquement vrifie pour garantir que
l'index est valide. Ce contrle de limites implicite ne peut pas tre dsactiv. Le contrle de limites est
l'un des moyens la scurit du langage C#.

Pour vrifiez que les index entiers sont toujours l'intrieur des limites, vrifiez manuellement les
limites d'index, l'aide d'une condition de fin d'instruction for, comme suit :

permettant de garantir
f or ( i nt i = 0; i < r ow. Lengt h; i ++) {
Consol e. Wr i t eLi ne( r ow[ i ] ) ;
}

La proprit Length est gale la longueur totale du tableau, quel que soit le rang du tableau. Pour
dterminer la longueur d'une dimension spcifique, vous pouvez utiliser la mthode GetLength,
comme suit :

f or ( i nt r = 0; r < gr i d. Get Lengt h( 0) ; r ++) {
f or ( i nt c = 0; c < gr i d. Get Lengt h( 1) ; c++) {
Consol e. Wr i t eLi ne( gr i d[ r , c] ) ;
}
}

Figure 7 - Proprits Length et GetLength

6.2. Cration de tableaux
6.2.1. Cration d'instances de tableau
Vous utilisez le mot cl new pour crer une instance de tableau, galement appele expression de
cration de tableau. Vous devez spcifier la taille de toutes les longueurs de rang lorsque vous crez
une instance de tableau.
Le compilateur C#initialise implicitement chaque lment du tableau une valeur par dfaut qui varie
en fonction du type de l'lment : les entiers sont implicitement initialiss 0, les lments virgule
flottante 0.0 et les lments boolens false.

l ong[ ] r ow = new l ong[ 4] ;
6.2.2. Initialisation d'lments de tableau
Vous pouvez utiliser un initialiseur de tableau pour initialiser les valeurs des lments de l'instance du
tableau. Un initialiseur de tableau est une squence d'expressions entre accolades et spares par des
virgules. Les initialiseurs de tableau sont excuts de gauche droite et peuvent comprendre des
appels de mthode et des expressions complexes, comme dans l'exemple ci-dessous :

i nt [ ] dat a = new i nt [ 4] {1, 2, 3, 4};
6.2.3. Initialisation d'lments de tableaux multidimensionnels
Vous devez initialiser explicitement tous les lments du tableau, quelle que soit la dimension du
tableau :

i nt [ , ] dat a = new i nt [ 2, 3] { {42, 42, 42},
{42, 42, 42} };


7. Notions fondamentales de la
programmation oriente objet
C#est un langage oriente objet. Tout dveloppeur C#(et tout dveloppeur .NET) se doit de matriser
les termes et les principes de base de la programmation objet. Aprs avoir abord les termes et les
concepts gnraux de la programmation objet, nous verrons son implmentation avec C#.
7.1. Classes et objets
La programmation orient objet possde son propre vocabulaire et ses propres concepts que nous
devons dfinir et assimiler avant de prsenter plus concrtement son implmentation dans C#.
7.2. Quest-ce quune classe ?
Une classe est la dfinition dun ensemble dentits qui partagent les mmes attributs, les mmes
oprations et la mme smantique.
Du point de vue du dveloppeur, une classe est une construction syntaxique nomme qui dcrit un
comportement et des attributs communs

Exemple :
Toutes les voitures ont un comportement commun (elles tournent, s'arrtent, etc.) et des attributs
communs (quatre roues, un moteur, etc.). Vous employez le mot voiture pour faire rfrence ces
proprits et ces comportements communs. Imaginez que l'on ne puisse pas les classer en concepts
nomms : au lieu de dire voiture, il faudrait numrer toutes les significations du mot voiture.
7.3. Quest quun objet ?
Un objet est une instance dune classe et est caractris par une identit, un tat et un comportement.
Identit : les objets sont reconnaissables les uns des autres.
Lidentit permet de distinguer un objet parmi tous les autres au sein dune mme classe. Si nous
dfinissons une classe voiture, votre voiture personnelle possdant un numro de srie particulier est
un objet de la classe voiture.
Etat : les objets stockent des informations.
Ltat dun objet est une image des valeurs des attributs de lobjet un instant donn. Il est possible
que deux objets possdent le mme tat, il nen perde pas moins leur identit. Nous verrons plus tard
que ltat dun objet ne doit pas tre accessible (principe dencapsulation).
Comportement : les objets ralisent des tches
Le comportement dun objet est sa finalit. Il peut effectuer des actions sur ses propres attributs ou sur
ceux dun tiers objet afin de basculer dun tat A un tat B.

Exemple :
Une personne a un nom, une date de naissance, une adresse et peut marcher, courir, sauter etc....
J ean Martin, n le 23 dcembre 1984 est une instance de la classe personne.
7.4. Comparaison entre une classe et une structure
Une structure est un modle de valeur alors quune classe est un modle dobjets.

Une structure na pas didentit et deux structures ayant le mme tat fonctionneront de la mme
manire que vous utilisiez lune ou lautre. Ltat dune structure est directement accessible et ne
possde pas forcment de comportement.
Les structures peuvent effectuer des oprations, mais cela n'est pas recommand. Il est prfrable
qu'elles ne contiennent que des donnes.


Comme nous lavons vu prcdemment, une classe possde une identit, un tat inaccessible et un
comportement. Les types reprsents par des classes sont appels des types rfrence en C#. Par
rapport aux structures, rien l'exception des mthodes ne doit tre visible dans une classe bien conue.

Types valeur et Types rfrence : Une valeur de type valeur est prsente dans la pile de lapplication
en tant que variable locale ou en tant quattribut de lobjet auquel elle appartient.
Une valeur de type rfrence ne contient quun pointeur vers ses donnes prsentes dans le tas
manag.
7.5. Utilisation de lencapsulation
Lencapsulation est le mcanisme permettant de rassembler les attributs et mthodes propres un type
donn afin den restreindre laccs et/ou den faciliter lutilisation et la maintenance.

Lencapsulation permet de masquer lutilisateur dune classe son implmentation, c'est--dire les
donnes quelle possde et les oprations quelle effectue afin de ne dvoiler que ce qui lui est
rellement utile.

Exemple :
Lorsque vous effectuez un virement bancaire, un certain nombre de transactions et vrifications sont
effectues par votre banque. Ces oprations ne vous sont pas dvoiles (imaginez que vous puissez
directement modifier le solde de votre compte). Vous ne pouvez et navez pas effectuer vous-
mmes ces oprations. De plus, si ces oprations sont mises jour ou quune nouvelle vrification est
effectue, vous ne modifierez pas votre manire deffectuer le virement.

De manire gnrale, les donnes sont prives et les mthodes sont publiques. Cependant certaines
mthodes peuvent tre prives et ne servir quau fonctionnement interne de la classe.
7.6. Donnes de lobjet, donnes statiques et mthodes
statiques
Chaque objet possde ses propres donnes. Il est possible que deux objets distincts aient des valeurs
semblables pour un mme attribut mais il ne sagt alors que dune concidence.

On peut toutefois avoir besoin de dfinir une valeur commune pour lattribut dun type. Lutilisation
de donnes statiques permet de partager une mme valeur dun attribut dune classe avec tous les
objets de cette classe.

Exemple :
Lors de la dfinition dun compte pargne, le taux dintrt de ce type de compte sera commun tous
les comptes ouverts.

Ces donnes statiques peuvent tre amene tre modifi. On utilise alors des mthodes statiques
appeles directement sur la classe. Les mthodes statiques ne peuvent agir que sur les donnes
statiques.
7.7. C# et lorientation objet
Voyons ds prsent comment C#utilise ses concepts.
7.7.1. Dfinition de classes simples
class BankAccount
{

Une classe est dfinie laide du mot cl class
qui prcde le nom de la classe.


private decimal balance;
private string name;

public void Withdraw(decimal amount))
{ . . . }
public void Deposit(decimal amount)
{ . . . }
}
Les donnes sont dfinies lintrieur de la
classe comme nous le ferions avec une
structure en veillant tout de mme rajouter le
mot cl private afin de rendre celles-ci prives.

Les oprations que peut raliser la classe sont
reprsents par des mthodes que nous ferons
prcder par le mot cl public sil sagt dun
comportement que nous voulons rendre
accessible ou par private si lopration nest
destine qu tre effectue par lobjet lui-
mme.

Si laccs un attribut de classe nest pas dfini, le compilateur C#le considrera par dfaut comme
priv.
7.7.2. Instanciation de nouveaux objets
La cration dune classe constitue la dfinition dun type particulier. La cration dun objet
appartenant ce type se nomme linstanciation.

Chaque objet doit tre dclar.
Afin dinstancier un nouvel objet dclar, nous utiliserons le mot-cl new.

cl ass Pr ogr am
{
{
BankAccount your s = new BankAccount ( ) ;
your s. Deposi t ( 999999M) ;
}
}
7.7.3. Utilisation du mot cl this
Le mot cl this fait rfrence (peut tre considr comme le seul pointeur utilis en C#) lobjet
partir duquel il est appel.

Ainsi, dans la classe ci-dessous les deux lignes de code sont quivalentes.

cl ass BankAccount
{
t hi s. name = name;
name = name;
}

Le mot cl this est trs utilis lorsque un conflit de nom apparat.

cl ass BankAccount
{
publ i c voi d Set Name( st r i ng name)
{
t hi s. name = name;
}
}


Lutilisation du mot cl this permet ici dassigner la valeur du paramtre name passe la mthode
SetName lattribut name de lobjet.

Attention : en cas de conflit de nom, aucun avertissement nest indiqu par compilateur C#et lattribut
name de lobjet ne sera pas modifi.

Le mot cl this, faisant appel lobjet et non la classe elle-mme, vous ne pouvez pas lutiliser afin
daccder aux donnes et aux mthodes statiques.
7.7.4. Classes imbriques
Il est possible de crer des classes lintrieur dune autre classe, on parle alors de classes imbriques.

Une classe imbrique se dclare au sein mme de la classe et peut tre publique ou prive.

cl ass Bank
{
publ i c cl ass Account { . . . . }
pr i vat e cl ass Account Number Gener at or { . . . . }
}
7.8. Dfinition de systmes orients objet
Dans cette partie, nous traiterons de certains mcanismes propres la programmation oriente objet tel
que lhritage ou le polymorphisme.
7.8.1. Hritage
Lhritage est le mcanisme au moyen duquel les lments les plus spcifiques incorporent la structure
et le comportement dlments plus gnraux.
Une classe qui hrite dun type devient en quelque sorte, une prcision ou une spcialisation de ce
type.
La classe la plus gnrale est appel classe de base ou classe parente, la plus spcifique, la classe
drive.

Exemple :
Un violoniste est un type, un musicien en est un autre. Cependant, un violoniste est galement et avant
tout un musicien. On peut donc faire hriter le type violoniste des caractristiques de tout musicien.
Toute modification apporte au type musicien sera ainsi directement reporte au type violoniste.
7.8.2. Hirarchie des classes
Un type driv peut tre driv son tour.
Lensemble de ces classes forme alors une hirarchie des classes dont on peut numrer les niveaux.

Lorsque lon remonte dans la hirarchie, nous parlons de gnralisation, linverse, la descente niveau
par niveau de la hirarchie des classes reprsente une spcialisation.

Il est essentiel de limiter le nombre de niveaux dune hirarchie de classes afin den garder le contrle.
Une hirarchie des classes doit normalement se limiter 6 ou 7 niveaux.
7.8.3. Hritage simple et multiple
Lorsquune classe drive dune seule et mme classe, on parle dhritage simple. Lhritage multiple
consiste faire driver une classe de plusieurs classes.

Exemple :

Une voiture est un vhicule et peut donc hriter des caractristiques communes tout vhicule (rouler,
tracter etc.).
Une voiture peut galement tre un objet de collection et hriter caractristiques communes des objets
de collections (cte, nombre dexemplaires etc.).
De ce point de vue, il vous incombe de choisir ce que vous souhaitez faire de votre voiture. Si vous
souhaitez voyager avec votre voiture, vous lutiliserez comme un objet de type vhicule. Si vous
voulez la revendre, vous lutiliserez peut tre comme un objet de collection.

Lhritage multiple vous amne faire un trs mauvais usage de celui-ci. Cest pourquoi C#nautorise
pas ce procd. Vous pouvez nhriter que dun seul type. Pour palier labsence dhritage multiple,
nous verrons dans la prsentation des interfaces que nous pourrons implmenter plusieurs interfaces
dans une mme classe.
7.8.4. Polymorphisme
Le polymorphisme est le mcanisme permettant un objet de prendre la forme de plusieurs types en
fonction des types de bases desquels ils hritent ou des interfaces quil implmente.

Lexemple ci-dessus illustrant lhritage multiple peut tre repris pour illustrer le polymorphisme. En
effet, une voiture peut un instant t est utilis comme
7.8.5. Classes de base abstraites
Certaines classes existent dans le seul but dtre drive, on parle de classe abstraite.
Les classes abstraites ne peuvent tre instancies.

Les classes abstraites contiennent trs souvent des mthodes statiques afin de pouvoir agir sur des
objets de type driv de la classe abstraite.
7.8.6. Interfaces
Une interface reprsente un contrat que la classe qui limplmente se doit de remplir.
Une interface ne contient que des oprations (mthodes non implmentes) et ne peut donc pas tre
instancie.

Exemple :
Un ordinateur et un tlviseur sont deux types qui peuvent tre allums. Cependant, il est difficilement
concevable de faire hriter lun de lautre. Cest pourquoi, il conviendra ici de dclarer une interface
contenant lopration allumer et de limplmenter dans les classes ordinateur et tlviseur.
7.8.7. Liaison anticipe et tardive
La liaison anticipe (ou liaison statique) est le fait deffectuer un appel de mthode directement sur
lobjet.

La liaison tardive (ou liaison dynamique) se prsente lorsque que lon effectue lappel de mthode non
plus sur lobjet lui-mme mais via une opration de classe de base.


8. Utilisation de variables de type
rfrence
Cette partie concerne ltude des variables de types rfrences en C#, de la hirarchie des classes et
plus particulirement de la classe de base System.Object, des diffrentes conversions entre ces types et
des conversions boxing/unboxing.
8.1. Comparaison entre les types valeur et les types
rfrence
Les variables de type valeur, les plus simples, (int, long ou char), contiennent leur valeur directement
dans la mmoire (pile).

Les donnes de type rfrence contiennent une rfrence aux donnes stockes dans une zone spare
de la mmoire (tas manag).

On peut comparer les variables de type rfrence aux pointeurs en C et C++sans ne jamais omettre
quen C#, une variable de type rfrence ne peut jamais dsigner un objet invalide. De plus, aucune
gestion de la mmoire nest ncessaire puisque cela est strictement rserv au Garbage Collector.
8.2. Dclaration et libration des variables rfrence
La dclaration dune variable de type rfrence ne diffre pas de la dclaration de variable de type
valeur.

Prenons pour exemple la classe Coordinate reprsentant les coordonnes dun point.

cl ass coor di nat e
{
publ i c i nt x;
publ i c i nt y;
}

On pourra dclarer des coordonnes de la faon suivante :

coor di nat e c1;

Cependant, je nai ici fait que dclarer la rfrence vers un Coordinate et il mest donc impossible
dassigner des valeurs mon objet.
Pour cela, je dois dsormais utiliser loprateur new afin de crer les donnes que rfrencera c1 :

c1 = new coor di nat e( ) ;

Lors de linstanciation, un appel vers le constructeur de lobjet est effectu. Cependant, ma classe
Coordinate nimplmente aucun constructeur. Le compilateur C#appelle donc un constructeur
implicite (constructeur par dfaut) qui va initialiser les attributs de type simple (type valeur) leur
valeur dorigine. Actuellement, nous aurons donc :

c1. x = 0;
c1. y = 0;

Cependant, si aucun constructeur nest implment, les objets de type rfrence dclar dans la classe
ne peuvent tre instancis.

En C#, vous ne pouvez accder des rfrences invalides. Lors de la compilation, une erreur empche
la compilation si une rfrence nest pas initialise et une exception est leve lors dune tentative
daccs une rfrence non valide pendant lexcution.

Ainsi, si nous dclarons un objet de type System.Random, qui permet de gnrer des nombres
alatoires dans notre classe Coordinate, nous ne pourrons pas lutiliser et lexcution, une exception
de type System.NullReferenceException sera leve.

cl ass Coor di nat e
{
publ i c Syst em. Randomr nd;
publ i c i nt x;
publ i c i nt y;
}

c1. r nd. Next ( ) ; / / except i on l eve! ! !

Afin daccder aux variables membres, C#utilise la notation pointe

c1. x = 6. 12;
c1. y = 4. 2;

c1 fait dsormais rfrence un objet de type Coordinate dont les attributs x et y ont t
respectivement assignes 6,12 et 4,2.

Pour librer c1, on utilise le mot cl null.

c1. x = nul l ;
8.3. Comparaison de valeurs et comparaison de rfrences
Un autre exemple montre comment c1 est une rfrence et non pas lobjet lui-mme. Crons
dsormais deux objets Coordinate dont les valeurs x et y sont assignes aux mmes valeurs et
comparons les.

cl ass Pr ogr am
{
st at i c voi d Mai n( st r i ng[ ] ar gs)
{
Coor di nat e c1 = new Coor di nat e( ) ;

c1. x = 1. 0;
c1. y = 2. 0;

c2. x = 1. 0;
c2. y = 2. 0;

i f ( c1 == c2)
Consol e. Wr i t eLi ne( " Mme chose! ! ! " ) ;
el se
Consol e. Wr i t eLi ne( " Pas l a mme chose! ! ! " ) ;
Consol e. Read( ) ;
}
}


La sortie est la suivante :

Pas l a mme chose! ! !

En effet mme si c1 et c2 ont les mmes valeurs, ils font rfrence deux objets diffrents.

Pour que deux variables de type rfrence soient gales, il faut quil fasse rfrence au mme objet.

cl ass Pr ogr am
{
{
Coor di nat e( ) ; Coor di nat e c1 = new
Coor di nat e c2;

c2 = c1; / / c2 r f r ence l e mme obj et que c1

i f ( c1 == c2)
Consol e. Wr i t eLi ne( " Mme chose! ! ! " ) ;
el se
Consol e. Wr i t eLi ne( " Pas l a mme chose! ! ! " ) ;
Consol e. Read( ) ;
}
}

Mme chose! ! !

Les deux variables sont dsormais quivalentes puisque faisant rfrence au mme objet.
8.4. Utilisation de rfrences comme paramtres de
mthode
Les variables de type rfrence peuvent tre utilises comme paramtres de mthodes. Nous allons ici
prsenter la diffrence entre lutilisation de type rfrence et de type valeur comme paramtre de
mthodes.

Nous avons vu auparavant que les structures taient des variables de type valeur. Transformons donc
la classe Coordinate en une structure StructCoordinate.

st r uct St r uct Coor di nat e
{
publ i c i nt x;
publ i c i nt y;
}

Ecrivons maintenant une classe Program implmentant une mthode incrmentant les coordonnes.
Cette mthode sera surcharge afin de pouvoir accueillir une rfrence ou une valeur comme
paramtre.


cl ass Pr ogr am
{
{
St r uct Coor di nat e c2 = new St r uct Coor di nat e( ) ;

/ / Modi f i cat i on des coor donnes
ChangeCoor di nat e( c1) ;
ChangeCoor di nat e( c2) ;

Consol e. Wr i t eLi ne( st r i ng. For mat ( " c1: {0}; {1}" , c1. x, c1. y) ) ;
Consol e. Wr i t eLi ne( st r i ng. For mat ( " c2: {0}; {1}" , c2. x, c2. y) ) ;

Consol e. Read( ) ;
}

/ / Mt hode accept ant une r f r ence comme par amt r e
st at i c voi d ChangeCoor di nat e( Coor di nat e coor )
{
coor . x++;
coor . y++;
}

/ / Mt hode accept ant une val eur comme par amt r e
st at i c voi d ChangeCoor di nat e( St r uct Coor di nat e coor )
{
coor . x++;
coor . y++;
}
}

Sortie console :

C1 : 1 ;1
C2 : 0 ;0

Laction de la mthode ChangeCoordinate est diffrente suivant le type de variable transmise comme
paramtre.
Lorsque vous fournissez des variables de type valeur, la mthode agt sur une copie de la structure de
donnes. Dans le cas prsent, cest une copie de la structure c2 qui est transmise la mthode. Cette
copie est une variable locale et sera dtruite la fin de la mthode.

Lutilisation dune rfrence comme paramtre fournit la mthode lemplacement des donnes dans
le tas manag. Ainsi, les modifications apportes aux donnes seffectuent sur les donnes rfrences
par c1 et sont donc conserves aprs lexcution de la mthode.

On peut outrepasser le fait que le paramtre utilis dans une mthode soit une copie de la variable
passe en paramtre laide de lutilisation du mot cl ref.

On peut modifier le code prcdent pour passer la structure en ajoutant le mot cl ref.


{
St r uct Coor di nat e c1 = new St r uct Coor di nat e( ) ;

ChangeCoor di nat e( r ef c1) ;

Consol e. Wr i t eLi ne( st r i ng. For mat ( " c1 : {0}; {1}" , c1. x, c1. y) ) ;
Consol e. Read( ) ;
}

st at i c voi d ChangeCoor di nat e( r ef St r uct Coor di nat e coor )
{
coor . x++;
coor . y++;
}

Sortie console :

C1 : 1 ;1

Les modifications apportes ont cette fois-ci tait conserves aprs lexcution de la mthode.

Pour utiliser le mot cl ref, nous devons instancier lobjet avant de le passer en paramtre la
mthode. Le mot cl out permet dinstancier lobjet pass en paramtre seulement au niveau de la
mthode appele.

{
St r uct Coor di nat e c1; / / / / l ' obj et peut ne pas t r e i nst anci

ChangeCoor di nat e( out c1) ;

Consol e. Wr i t eLi ne( st r i ng. For mat ( " c1 : {0}; {1}" , c1. x, c1. y) ) ;
Consol e. Read( ) ;
}

st at i c voi d ChangeCoor di nat e( out St r uct Coor di nat e coor )
{
/ / l ' obj et peut et doi t t r e i nst anci dans l a mt hode
c1 = new St r uct Coor di nat e( ) ;

coor . x++;
coor . y++;
}

On obtient alors le mme rsultat quavec lutilisation de ref. Seul lendroit dinstanciation diffre.
8.5. Utilisation de type rfrence courants
Cette partie a pour objectif de vous familiariser avec certains types rfrences faisant partie intgrante
du langage C#.
8.5.1. System.Exception
La classe System.Exception dont nous avons dj abord lutilisation est un type rfrence. Cette
classe reprsente une erreur gnrique dans une application. Les erreurs peuvent tre dclenches
laide de loprateur throw.
De nombreuses classes drives de System.Exception afin de mieux cibler lorigine de lerreur :


System.NullReferenceException
System.IO.FileNotFoundExecption
System.NET.ProtocolViolationException

Vous pouvez de plus crer vos propres exceptions en crant une classe hritant de System.Exception.
8.5.2. System.String
8.6. Hirarchie des objets
Toutes les classes en C#hritent directement ou indirectement du type System.Object. Lorsque vous
crez une classe sans prciser dhritage, celle-ci hrite directement de System.Object. Cette partie
dcrira donc quelques mthod z retrouver dans toutes les
classes.
8.6.1. Mthode ToString
La mthode ToString retourne une chane reprsentant lobjet en cours. Par dfaut, son
implmentation retourne le nom de la classe.

es essentielles de cette classe que vous pourre
Consol e. Wr i t eLi ne( new obj ect ( ) . ToSt r i ng( ) ) ;

Cette ligne affichera : System.Object

Cependant, cette mthode peut tre redfinie selon lusage quon fait de la classe.
Ainsi, pour un int il est plus efficace de retourner la valeur contenu dans la variable sous forme de
chane.

i nt i = 3;
Consol e. Wr i t eLi ne( i . ToSt r i ng( ) ) ;

La dernire ligne affichera: 3
8.6.2. Mthode Equals
La mthode Equals permet de comparer deux objets.

Coor di nat e a = new Coor di nat e( ) ;

Coor di nat e b = new Coor di nat e( ) ;

a. Equal s( b) ; / / r envoi t Fal se

a = b;

a. Equal s( b) ; / / r envoi t Tr ue

Cependant certains types redfinissent cette mthode afin de comparer les valeurs contenues comme
cest le cas pour la classe string.


st r i ng a = " sal ut " ;
st r i ng b = " sal ut " ;

a. Equal s( b) ; / / r envoi t Tr ue
8.6.3. Mthode GetType
La mthode GetType retourne des informations dexcution de lobjet, nous traiterons plus amplement
de cette mthode lors de ltude de la rflexion.
8.6.4. Mthode Finalize
La mthode Finalize est appele automatiquement par le runtime lorsque lobjet devient inaccessible
(si celui-ci nest plus rfrenc).
8.6.5. Mthode GetType
La mthode GetType, retourne un objet de type System.Type incluant de mthodes permettant
dobtenir des informations sur les constructeurs, mthodes, les champs et les proprits implments
dans la classe.
8.6.6. Oprateur TypeOf
Loprateur TypeOf permet de rcuprer lobjet System.Type de lobjet pass en paramtre.
Loprateur TypeOf ne fonctionne quavec des types connus au moment de la compilation.
8.6.7. Rflexion
La rflexion vous permet de rcuprer dynamiquement ( lexcution), des informations sur les types
utiliss. Les classes utiles la rflexion sont regroupes dans lespace de noms System.Reflexion. Ces
classes sont nombreuses et une tude exhaustive de la rflexion sort du cadre de ce cours.
8.7. Espace de noms du Framework.NET
Les espaces de noms (namespaces) permettent dorganiser le code et de dfinir des portes de noms.

Les noms globaux sont composs des noms des diffrents espaces de noms suivis du nom de type.
Le type System.Web.Mail.MailMessage par exemple est contenu dans le namespace
System.Web.Mail.
Si vous souhaitez crire votre propre classe MailMessage, vous pouvez inclure celle-ci dans votre
propre espace de noms laide de linstruction namespace{ }.

namespace LaboDot Net . Cour s. Met hodes
{
cl ass Read
{
. . .
}

cl ass Wr i t e
{
. . .
}
}

En gnral, on utilise le prototype suivant :

<nom de lentreprise>.<nom de lapplication>.<nom de la bibliothque>.<>.<nom du type>


Tous les types en C#sont inclus dans un espace de noms, mme si vous nen prcisez pas (par dfaut
les types sont contenus dans un espace de noms portant le nom de lapplication).

Les espaces de noms permettent donc de conserver des noms de type explicites en vitant les conflits
de noms tout en organisant le code.

Cependant, les noms globaux ne sont pas pratiques manipuler et lon prfrerait sen tenir au nom de
type dans le code.
La directive using permet de spcifier les diffrents espaces de noms avec lesquels on souhaite
travailler dans le fichier en cours.
usi ng Syst em;
usi ng Syst em. I O;
usi ng SQL = Syst em. Dat a. Sql Cl i ent ;

namespace Met hodes_Obj ect

Dans lexemple ci-dessus, un alias a t dfini pour lespace de noms System.Data.SqlClient.

Passons dsormais la prsentation de quelques espaces de noms utiles laide de C#.
8.7.1. Espace de noms System.IO
Lespace de noms System.IO contient entre autre lensemble des classes du Framework.NET destines
grer les entres-sorties vers le systme de fichiers.

Classes File et Directory
File et Directory sont des classes abstraites implmentant des mthodes statiques vous permettant de
crer, supprimer et manipuler les rpertoires et les fichiers.

Classes StreamReader et StreamWriter
StreamReader et StreamWriter permettent respectivemet daccder et dcrire le contenu d'un fichier
sous forme de flux d'octets ou de caractres.

Classes FileStream
La classe FileStream peut tre utilise pour permettre l'accs alatoire aux fichiers.

Classes BinaryReader et BinaryWriter
BianryWriter et BinaryReader permettent de lire et d'crire des types de donnes primitifs en tant que
valeurs binaires.
8.7.2. Espace de noms System.Xml
System.Xml contient les classes vous permettant dcrire des applications pouvant interagir avec des
fichiers et flux au format XML.

Ltude du support dXML dans .NET fait lobjet dun cours complet.
8.7.3. Espace de noms System.Data
System.Data est lespace de noms regroupant les classes ncessaires la gestion des donnes. Cet
espace de noms contient entre autre chose les espaces de noms et les classes permettant la connexion
diffrents SGBD.

System.Data est plus amplement tudi dans le cours dADO.NET.

8.8. Conversion de donnes
.NET est fortement typ et il est souvent ncessaire de convertir les donnes afin de remplir
deffectuer certaines oprations.
Cette section traitera donc de la conversion des types valeurs et rfrences ainsi que du mcanisme de
boxing/unboxing.
8.8.1. Conversions implicites
De nombreuses conversions se produites sans lajout dinstruction supplmentaires. Le compilateur
effectue seul ces conversions car celles-ci ne peuvent entrane de pertes dinformations.

i nt a = 6;
l ong b = a; / / conver si on i mpl i ci t e de a en ' l ong'
8.8.2. Conversions explicites
Certaines conversions peuvent ne pas tre sure et il incombera alors au dveloppeur deffectuer lui-
mme sa conversion. Par exemple la conversion dun long en int.

l ong a = 6;
i nt b = a;

/ / Er r eur : I mpossi bl e de conver t i r i mpl i ci t ement l e t ype l ong en i nt

Nous pouvons donc forcer le compilateur excuter la conversion :

l ong a = 6;
i nt b = ( i nt ) a;

Cependant si a est incrment et que sa longueur dpasse la capacit dun int (4 octets), la conversion
sera refuse et une exception de type System. OverflowException sera leve.
8.8.3. Conversions de types rfrence
On peut distinguer deux types de conversions de types rfrences, les conversions dun type enfant
vers un type parent et inversement dun type parent vers un type enfant.

La conversion dun type enfant vers un type parent peut tre implicite, est sre et toujours autoris.

obj ect o = a;

La conversion dun type parent vers un type enfant doit tre explicitement effectue. Aucune
vrification nest effectue avant lexcution de lapplication. Lors de la conversion, les types sont
vrifis. Si une perte de donnes peut tre causes par lopration, elle sera annule et une exception
de type System.InvalidCastException sera leve.

Loprateur is permet de vrifier le type dun objet et renvoie True si les deux oprandes sont de
mmes types.

Bi r d b;
i f ( a i s Bi r d)
{
b = ( Bi r d) a;
}


Loprateur as permet deffectuer une opration de conversion sans gnrer derreur en cas de cast
invalide. Si la conversion nest pas sre, as renvoie null.
8.8.4. Boxing/Unboxing
C#inclut un syst r les types valeur en rfrences de type
System.Object, ainsi que de convertir des rfrences d'objets en types valeur. Les types valeur peuvent
tre convertis en rfrences de type System.Object, et vice-versa.

Le Boxing consiste donc convertir une variable de type valeur en un objet de type rfrence
System.Object.

me de types unifis qui permet de converti
i nt i = 123;
obj ect box;

box = p; / / boxi ng i mpl i ci t e
box = ( obj ect ) p; / / boxi ng expl i ci t e

LUnboxing consiste convertir un type System.Object en un type valeur. Cette conversion ne peut
tre quexplicite.

i = ( i nt ) box;


9. Cration et destruction dobjets
Cette partie traite des de destruction des objets. Nous aborderons
lutilisation des construct et dcrirons la dure de vie dun objet.
9.1. Utilisation de constructeurs
En C#, la seule manire de crer un objet consiste utiliser le mot cl new pour allouer la mmoire.

Il nexiste aucune exception cette rgle bien que le compilateur le fasse implicitement votre place.
Les deux lignes ci-dessous sont par exemple identiques :

mcanismes de cration et
eurs et des destructeurs
st r i ng b = new st r i ng( new char [ ] {' s' , ' a' , ' l ' , ' u' , ' t ' }) ;

La deuxime tape de cration des objets consiste appeler un constructeur. Lappel du constructeur
cre lobjet dans lespace mmoire allou. On peut diffrencier deux types de constructeurs diffrents,
les constructeurs dinstances ou dobjets et les constructeurs statiques ou constructeurs de classes.
9.1.1. Constructeurs dinstances
Aprs avoir fait usage du mot cl new, un espace mmoire suffisant a t allou, lappel du
constructeur va terminer la construction de lobjet en initialisant cet espace mmoire.

En C#, vous ne pouvez pas distinguer lallocation de linitialisation de la mmoire.
Si vous nimplmentez pas de constructeur dans votre classe, le compilateur fera appel un
constructeur par dfaut. Celui-ci initialisera les variables de type valeur membres leur valeur par
dfaut (ex : int =0) mais ne construira pas les variables de type rfrence membres.

Un constructeur par dfaut doit porter le mme nom que la classe, tre publique, ne prendre aucun
argument et ne renvoyait aucune valeur (pas mme void).

Vous pouvez rcrire votre propre constructeur par dfaut en suivant les rgles prsentes ci-dessus.
La rcriture peut trouver son utilit si vous ntes pas satisfait des valeurs par dfaut que prennent les
membres de votre classe.

Dans lexemple ci-dessous, le constructeur de la classe MyDate a tait modifi afin que le membre
DateTime dt soit initialis aux dates et heures actuelles plutt quau 01/01/01.

cl ass MyDat e
{
publ i c Dat eTi me dt ;

publ i c MyDat e( )
{
dt = Dat eTi me. Now;
}
}

Le constructeur peut tre surcharg afin de passer des arguments diffrents et de pouvoir modifier
linitialisation des membres selon le type de donnes lors de la construction de lobjet.


cl ass MyDat e
{

publ i c MyDat e( Dat eTi me dt )
{
t hi s. dt = dt ;
}

publ i c MyDat e( i nt year , i nt mont h, i nt day)
{
dt = new Dat eTi me( year , mont h, day) ;
}

}

Attention : si vous surchargez le constructeur dune classe, lappel au constructeur par dfaut implicite
est impossible. Il vous faudra alors crire votre propre constructeur par dfaut.

Une liste d'initialiseurs peut vous permettre d'crire un constructeur appelant un autre constructeur
dans la mme classe. Une liste d'initialiseurs commence par le signe deux-points, est suivie du mot cl
this, puis d'arguments entre parenthses.

cl ass MyDat e
{
publ i c MyDat e( Dat eTi me dt ) : t hi s( 2004, 01, 01)
{
t hi s. dt = dt ;
}

publ i c MyDat e( i nt year , i nt mont h, i nt day)
{
dt = new Dat eTi me( year , mont h, day) ;
}
}
9.1.2. Constructeurs statiques
Les constructeurs statiques ont pour rle de permettre linitialisation des membres statiques de la
classe.

cl ass Tai l or
{
publ i c st at i c st r i ng hel pMsg;
st at i c Tai l or ( )
{
def = " My t ai l or i s r i ch! ! ! " ;
}
}

Vous ne pouvez appeler vous-mmes un constructeur statique. Il est donc impossible de prciser
laccs au constructeur de classe ou dajouter des arguments.
Les constructeurs statiques sont aussi appels constructeurs de classe car ils nont accs quaux
membres statiques de classe. Ainsi, lutilisation de this (rfrenant un objet) dans un constructeur
statique entrane une erreur de compilation.

9.1.3. Constructeurs de structures
Les membres dune structure peuvent tre initialiss laide dun constructeur de structure.

st r uct MaSt r uct
{
publ i c i nt x;
publ i c i nt y;

publ i c MaSt r uct ( i nt a, i nt b)
{
x = a;
y = b;
}
}

Cependant, limplmentation dun constructeur de structures est soumise certaines rgles.

Tous les membres de la structure doivent tre explicitement initialiss dans le constructeur.

publ i c MaSt r uct ( i nt a, i nt b)
{
x = a; / / Er r eur : Le champ y doi t t r e t ot al ement assi gn
/ / avant que l e cont r l e qui t t e l e const r uct eur .
}

Vous ne pouvez pas dclarer de constructeur par dfaut

publ i c MaSt r uct ( )
{
x = 0; / / Er r eur : Les st r uct ur es ne peuvent pas cont eni r de
y = 1; / / const r uct eur s exempt s de par amt r es expl i ci t es
}
9.2. Objets et mmoire
En C#et en .NET, la gestion de la mmoire incombe entirement et perptuellement la CLR. Nous
allons dcrire cette gestion et le fonctionnement du garbage collector.

Nous avons vu comment initialiser des variables de type rfrence. Ce processus est compos des deux
tapes que sont la rservation de lespace mmoire et linitialisation des variables. La destruction de
lobjet est le processus exactement inverse, consistant dinitialiser lobjet et librer la mmoire.

Cependant, le contrle de ce processus ne nous vous est pas attribu. En effet, cette tche est alloue
au garbage collector.
Lopration de destruction et son mauvais usage tant den dautres langages une source importante
derreurs grave, .NET automatise la tche.
Le garbage collector a pour but de :
Dterminer les objets inaccessibles (non rfrencs).
Libration de la mmoire.

Cette tche saccomplit lorsque la mmoire devient insuffisante. Vous ne pouvez dterminer le
moment de cette libration et donc de la destruction de vos objets.
9.3. Gestion des ressources
Si lon ne peut dterminer linstant o lobjet sera dtruit, on peut implmenter certaines actions
effectuer lors de sa destruction.

9.3.1. Finalize
Les objets .NET hritent de System.Object de la mthode Finalize. Finalize est excute lors de la
libration de lobjet mais ne peut tre ni appele ni substitue.
9.3.2. Destructeurs
Un destructeur est linverse dun constructeur destin dinitialiser les membres dun objet.

Un destructeur est une sorte de mthode de la classe, portant le mme nom que celle-ci, ne possdant
pas de modificateur daccs, de type de retour (pas mme void), de paramtres. De plus, un
constructeur est prcd par ~.

cl ass Sour ceFi l e( )
{
~Sour ceFi l e( )
{
. . .
}
}

Vous devez limiter lutilisation des destructeurs car vous ne pouvez contrler leur moment
dexcution. Cela ation de la mmoire
et ainsi gnrer de
9.3.3. IDisposable et Dispose
Vos propres classes peuvent tre amener utiliser des ressources dont vous souhaitez contrler la
libration. Le processus de libration des objets ne vous permettant pas librer ces ressources un
instant donn, limplmentation dune mthode Dispose vous permet daccomplir cette tche.
pourrait entraner des ralentissements dans le processus de libr
s pertes de performances.

10. Hritage dans C#
Lhritage en C#comme dans tout langage orient objet, est la capacit qu une classe hriter des
donnes et des fonctionnalits dun autre type.
Cette partie traite de lhritage en C#, de la faon de driver des classes partir de classes existantes et
des types de mthodes virtual, override et new.
10.1. Drivation de classe
10.1.1. Syntaxe
La syntaxe pour faire hriter dune classe de base est la suivante :

cl ass Der i ved : Base
{
. . .
}

Une classe drive ne peut pas tre plus accessible que sa classe de base. Par exemple, il n'est pas
possible de driver une classe publique d'une classe prive. La syntaxe C#pour driver une classe
d'une autre classe est galement autorise en C++o elle spcifie implicitement une relation d'hritage
priv entre les classes drives et les classes de base. C#n'autorise pas l'hritage priv ; tous les
hritages sont publics.
10.1.2. Utilisation du mot cl protected
Le mot cl protected permet de restreindre laccs dun membre dune classe de base uniquement ses
classes drives. Le membre protg hrit devient automatiquement protg.
Pour les autres types (ne drivant pas de la classe), un membre protg dune classe se comporte
comme un membre priv
10.1.3. Appel de constructeurs de classe de base
Vous avez la possibilit de dfinir des constructeurs faisant appel un constructeur de la classe de
base afin dinitialiser les membres hrits de cette classe.

cl ass Vehi cul e
{
pr ot ect ed st r i ng i mmat r i cul at i on;

publ i c Vehi cul e( st r i ng i mmat r i cul at i on)
{
t hi s. i mmat r i cul at i on = i mmat r i cul at i on;
}
}

cl ass Voi t ur e : Vehi cul e
{
publ i c Voi t ur e( st r i ng i mmat r i cul at i on) : base( i mmat r i cul at i on)
{
. . .
}
}

10.2. Implmentation de mthodes
Lhritage offre des mcanismes de rutilisation du code et de redfinition des mthodes. Ce
mcanisme est appel polymorphisme.
10.2.1. Utilisation de virtual et override
Une mthode virtuelle de la classe de base peut tre redfinie dans une classe drive.
Une classe virtuelle signifie que la mthode est une implmentation possible mais que lon autorise sa
redfinition dans les classes drives.
Seuls les mthodes virtuelles non statiques et/ou prives peuvent tre redfinies dans une classe
drive. Les deux mthodes doivent avoir la mme signature, c'est--dire le mme nom, le mme
modificateur daccs, le mme type de retour et les mmes paramtres.
Pour dclarer une mthode virtuelle dans la classe de base, on utilise le mot cl virtual. Dans la classe
drive, on utilise le mot cl override pour redfinir une mthode virtuelle de la classe de base.

cl ass Vehi cul e
{
publ i c vi r t ual voi d Depl acer ( )
{
. . .
}

}

cl ass Voi t ur e : Vehi cul e
{
publ i c over r i de voi d Depl acer ( )
{
. . .
}
}
10.2.2. Utilisation de new
Plutt que de redfinir une mthode, vous pouvez avoir besoin de spcifier quune mthode dune
classe drive est une nouvelle implmentation de la mthode.
On utilise new pour spcifier une mthode dont la signature est quivalente une mthode de la classe
de base mais que nous souhaitons masquer. Le fait de masquer la mthode virtuelle de la classe de
base permet galement de rsoudre des conflits de noms au sein des classes drives.

cl ass Bat eau : Vehi cul e
{
. . .
publ i c new voi d Depl acer ( )
{
. . .
}
}
10.3. Utilisation dinterfaces
Une interface est une dfinition syntaxique dun ensemble doprations que les classes limplmentant
se doivent de respecter.
Ainsi, si vous connaissez les interfaces implmentes dans une classe, vous pouvez tre certain que
certaines mthodes de lobjet pourront tre appeles.
Si une classe ne peut drive que dune seule classe de base, les classes C#peuvent implmenter
divers interfaces.


La dfinition dune interface est similaire la dfinition dune classe sans implmentation. On utilise
donc le mot cl interface et les mthodes dclares dans linterface ne doivent pas contenir de code.

i nt er f ace I Depl acabl e
{
voi d Depl acer ( ) ;
}

Une interface ne comprend que des mthodes. Les membres sont interdits dans une interface et les
mthodes de linterface ne peuvent possder de modificateurs daccs.

La classe implmentant linterface doit obligatoirement implmenter lensemble des mthodes de
linterface.

cl ass Voi t ur e : Vehi cul e, I Depl acabl e
{
publ i c voi d Depl acer ( )
{

}
}

Si la classe Voiture nimplmentait pas la mthode Deplacer, une erreur serait survenue la
compilation.
Une utilisation possible des interfaces consiste itrer les lments dune collection, dont on ignore le
type exact.

Ar r ayLi st mesVehi cul es = new Ar r ayLi st ( ) ;
mesVehi cul es. Add( new Voi t ur e( ) ) ;
mesVehi cul es. Add( new Bat eau( ) ) ;

f or each( I Depl acabl e i i n mesVehi cul es)
{
i . Depl acer ( ) ;
}

Comme mes vhicules implmentent linterface IDeplacable, je suis certain que chaque vhicule
implmente la mthode Deplacer.

Exemple :

/ / i nt er f ace. cs

usi ng Syst em;

i nt er f ace I Di mensi ons
{
f l oat Lengt h( ) ;
f l oat Wi dt h( ) ;
}

cl ass Box : I Di mensi ons
{
f l oat l engt hI nches;
f l oat wi dt hI nches;

publ i c Box( f l oat l engt h, f l oat wi dt h)
{

l engt hI nches = l engt h;
wi dt hI nches = wi dt h;
}
f l oat I Di mensi ons. Lengt h( )
{
r et ur n l engt hI nches;
}
f l oat I Di mensi ons. Wi dt h( )
{
r et ur n wi dt hI nches;
}

{
Box myBox = new Box( 30. 0f , 20. 0f ) ;
I Di mensi ons myDi mensi ons = ( I Di mensi ons) myBox;
Syst em. Consol e. Wr i t eLi ne( " Lengt h: {0}" , myDi mensi ons. Lengt h( ) ) ;
Syst em. Consol e. Wr i t eLi ne( " Wi dt h: {0}" , myDi mensi ons. Wi dt h( ) ) ;

Consol e. ReadLi ne( ) ;
}
}

Sortie console :

Lengt h: 30
Wi dt h: 20

Explications :
Nous dclarons tout dabord linterface en prcisant quels seront les membres et mthodes
implmenter. En effet, utiliser les interfaces permet de forcer le dveloppeur dvelopper un
certain nombre de mthode. Dans notre exemple, nous dclarons deux mthodes (Length() et
Width()). Notre classe Box implmentant cette interface, le dveloppeur doit alors dvelopper
ces mthodes. Box implmente ces interfaces en mettant en nom de mthode
IDimensions.Length() par exemple, ce qui indique que cest limplmentation de Length de
linterface IDimensions.
alors appeler la mthode dune interface depuis un objet, et ce quel que soit son type,
tant que lobjet implmente linterface.
Si besoin, le dveloppeur peut implmenter autant dinterface quil le souhaite
Commencez obligatoirement le nom de votre interface par un I.
Le Framework .NET comprend un grand nombre dinterface que vous pouvez utiliser. Par
exemple, linterface ICollection vous permet de crer des collections personnalises.
10.4. Utilisation des classes abstraites et scelles
Certaines classes nexistent que dans le but dtre drives.
On utilise le mot abstract dans la dclaration de la classe afin de la dclarer abstraite.

On peux
abst r act cl ass Vehi cul e
{
publ i c vi r t ual voi d Depl acer ( )
{
. . .
}
}

Une classe abstraite ne peut tre instancie.


Au contraire des classes abstraites, certaines classes peuvent tre scelles. Les classes scelles ne
peuvent tre drives. Pour dclarer une classe scelle, on utilise le mot clef sealed.


11. Oprateurs, dlgus et
vnements
11.1. Surcharge doprateurs
La surcharge doprateur permet de contrler le comportement dun objet face un oprateur.

Saisissez et excutez le programme suivant :

/ / Oper at or Over l oad. cs

usi ng Syst em;

publ i c cl ass Compl ex
{
publ i c i nt Real ;
publ i c i nt I magi nar y;

publ i c Compl ex( i nt Real , i nt I magi nar y)
{
t hi s.Real = Real ;
t hi s.I magi nar y = I magi nar y;
}

publ i c st at i c Compl ex oper at or +( Compl ex c1, Compl ex c2)
{
r et ur n new Compl ex( c1.Real + c2.Real ,
c1.I magi nar y + c2.I magi nar y) ;
}

publ i c over r i de st r i ng ToSt r i ng( )
{
r et ur n( St r i ng.For mat ( " {0} + {1}i " , Real , I magi nar y) ) ;
}
}

publ i c cl ass Oper at or Over l oad
{
{
Compl ex num1 = new Compl ex( 2, 3) ;
Compl ex num2 = new Compl ex( 3, 4) ;
Compl ex sum= num1 + num2;

Consol e.Wr i t eLi ne( " Fi r st compl ex number : {0}" , num1) ;
Consol e.Wr i t eLi ne( " Second compl ex number : {0}" , num2) ;
Consol e.Wr i t eLi ne( " The sumof t he t wo number s: {0}" , sum) ;

Consol e.ReadLi ne( ) ;
}
}

Explications :
Nous avons tout dabord cr une classe Complex contenant deux membres publics.
Nous ne pouvons additionner deux objets directement. Il faut donc surcharger loprateur +.
Remarquez que la mthode est statique.

Cette mthode retourne un Complex et prends deux arguments de type Complex, mais nous
pouvons trs bien crer autant de mthode que ncessaire pour les autres types (avec des int en
paramtres par exemple).
Les oprateurs du c#sont : +, -, !, ~, ++, --, true, false, *, /, %, &, |, ^, <<, >>, ==, !=, <, >,
<=, >=.
11.2. Dlgations
ype un peu particulier. Elles permettent de fournir une fonction en paramtre
pour dlguer lexcution dun morceau de programme. Cest lquivalent des pointeurs de fonctions
en C/C++.

Excutez ce code :
Les dlgations sont un t

/ / Del egat i ng. cs

usi ng Syst em;

publ i c del egat e voi d Del egat eType( i nt i ) ;

publ i c cl ass Del egat i ng
{
{
Del egat eType del =new Del egat eType( MyFunct i on) ;
del ( 10) ;
del = new Del egat eType( MyFunct i on2) ;
del ( 25) ;
}

publ i c st at i c voi d MyFunct i on( i nt i )
{
Consol e.Wr i t eLi ne( " I ' mi n MyFunct i on and i ={0}" , i ) ;
}

publ i c st at i c voi d MyFunct i on2( i nt i )
{
Consol e.Wr i t and i ={0}" , i ) ; eLi ne( " I ' mi n MyFunct i on2
}
}

Explications :
On dclare tout dabord un delegate via le mot clef homonyme. On lui prcise les arguments
que la fonction dlgue devra accepter (ici un int).
On cre ensuite un objet de ce type en lui prcisant quelle est la fonction appele. On peut
alors appeler la fonction dsigne par lintermdiaire de lobjet dlgu.
11.3. Evnements
Les vnements permettent de capturer une action du programme. Ainsi, lorsque lon clique sur un
bouton, lvnement Click du bouton est lev. On peut capturer les vnements mis par les classes du
Framework mais aussi crer ses propres vnements.

Observons ce code :

/ / Event s1. cs
usi ng Syst em;


publ i c cl ass Test
{
publ i c event Event Handl er Changed;

pr i vat e st r i ng _msg;
publ i c st r i ng Msg
{
get
{
r et ur n _msg;
}
set
{
_msg=val ue;
i f ( Changed != nul l ) Changed( t hi s, Event Ar gs.Empt y) ;
}
}
}
publ i c cl ass Test Hooki ng
{
Test _ st ; t e
publ i c est Hooki ng( ) T
{
_t est = new Test ( ) ;
St ar t Hooki ng( ) ;
}
publ i c voi d Test _OnChanged( obj ect sender , Event Ar gs e)
{
Consol e.Wr i t event f r om_t est " ) ; eLi ne( " I hook t he Changed
}
publ i c voi d ChangeSt r i ng( st r i ng Msg)
{
Consol e.Wr i t o {0}" , Msg) ; eLi ne( " Changi ng _t est . Msg t
_t est .Msg=Msg;
}
publ i c voi d St ar t Hooki ng( )
{
Consol e.Wr i t eLi ne( " St ar t i ng Hooki ng" ) ;
_t est .Changed += new Event Handl er ( Test _OnChanged) ;
}
publ i c voi d St opHooki ng( )
{
Consol e.Wr i t eLi ne( " St opi ng Hooki ng" ) ;
_t est .Changed -= new Event Handl er ( Test _OnChanged) ;
}
}
publ i c cl ass Event s1
{
{
Test Hooki ng t h=new Test Hooki ng( ) ;

t h.ChangeSt r i ng( " hel l o" ) ;
t h.St opHooki ng( ) ;
t h.ChangeSt r i ng( " Ti t i " ) ;
t h.St ar t Hooki ng( ) ;
t h.ChangeSt r i ng( " Koal a" ) ;
}
}


Rsultat :

St ar t i ng Hooki ng
Changi ng _t est . Msg t o hel l o
I hook t he Changed event f r om_t est
St opi ng Hooki ng
Changi ng _t est . Msg t o Ti t i
St ar t i ng Hooki ng
Changi ng _t est . Msg t o Koal a
I hook t he Changed event f r om_t est

Explications :
Un vnement se dclare en plusieurs tapes. La premire est de dclarer lvnement dans la
classe en lassociant un gestionnaire dvnement (EventHandler). Ce gestionnaire est de
type delegate auquel nous pourrons associer une mthode qui sera donc le traitement de notre
vnement.
Ainsi dans notre exemple, dans la classe TestHooking, lvnement test.Changed est captur
via la ligne : test.Changed +=new EventHandler(Test_OnChanged);
En ralit, comme EventHandler est un type par dlgation, la classe Test dlgue une
mthode. Cest pourquoi, pour lever lvnement Changed de la classe Test, on teste dabord
si Changed est null (donc la dlgation nest pas effectue) avec dappeler la fonction
dlgue.

Saisissez, compilez et excutez le code suivant :

/ / Event s2. cs

usi ng Syst em;

publ i c del egat e voi d Fi ni shedCar Event Handl er (
obj ect sender , Fi ni shedCar Event Ar gs e) ;

publ i c cl ass Fi ni shedCar Event Ar gs : Event Ar gs
{
pr i vat e st r i ng _model ;
publ i c st r i ng Model
{
get { r et ur n _model ; }
}
publ i c Fi ni shedCar Event Ar gs( st r i ng Model )
{
_model =Model ;
}
}

publ i c cl ass Car Fact or y
{
publ i c event Fi ni shedCar Event Handl er Fi ni shedCar ;

publ i c voi d Bui l dCar ( st r i ng Model )
{
Consol e.Wr i t eLi ne( " I bui l t a {0}" , Model ) ;
i f ( Fi ni shedCar != nul l )
{
Fi ni shedCar ( t hi s, new Fi ni shedCar Event Ar gs( Model ) ) ;
}
}

}

publ i c cl ass Event s2
{
{
Car Fact or y cf =new Car Fact or y( ) ;

cf .Fi ni shedCar += new Fi ni shedCar Event Handl er ( OnFi ni shedCar ) ;
cf .Bui l dCar ( " R5" ) ;
cf .Bui l dCar ( " F350" ) ;
cf .Bui l dCar ( " Laguna" ) ;

}

publ i c st at i c voi d OnFi ni shedCar (
obj ect sender , Fi ni shedCar Event Ar gs e)
{
Consol e.Wr i t eLi ne(
" The f act or y has f i ni shed bui l di ng a {0}" , e.Model ) ;
}
}

Sortie cran :

I bui l t a R5
The f act or y has f i ni shed bui l di ng a R5
I bui l t a F350
The f act or y has f i ni shed bui l di ng a F350
I bui l t a Laguna
The f act or y has f i ni shed bui l di ng a Laguna

Explications :
Le principe est le mme que lexemple prcdent, mais nous avons dvelopp notre propre
type dvnement.
Nous avons pour cela cr un type par dlgation pour capturer notre vnement personnalis.
Chaque vnement possde deux arguments : sender (object) qui est la source de lvnement,
et e (EventArgs) qui sont les arguments de lvnement.
Nous avons alors justement hrit la classe EventArgs pour crer nos propres arguments
dvnement en rajoutant ici une chane de caractres Model.


12. Proprits et indexeurs
12.1. Proprits
Qu'est ce qu'une proprit ?
Les proprits s'utilisent comme une variable. La diffrence se situe au niveau de l'implmentation. En
effet, plutt que d'attribuer un espace mmoire et de le remplir avec une valeur, on va soi-mme
dfinir son comportement en lecture et/ou en criture. On peut ainsi, pour chaque proprit dfinir une
mthode get et une mtho r respectivement rcuprer une valeur ou l'affecter.
Pour implmenter une proprit en lecture seule, on nimplmente que la mthode get, et de mme
pour implmenter une proprit en criture seule, on nimplmente que la proprit get.
Afin de dfinir la valeur dune variable, on utilise le paramtre value qui doit tre du mme type que la
proprit.

Observons le cod
de set pou
e suivant :

/ / Pr oper t ySi mpl e. cs

usi ng Syst em;

publ i c cl ass Test Pr op
{
pr i vat e i nt _updat eCount ;
pr i vat e i nt _accessCount ;
pr i vat e i nt _val ue;

publ i c i nt Val ue
{
get
{
_accessCount ++;
r et ur n _val ue;
}
set
{
_updat eCount ++;
_val ue=val ue;
}
}
publ i c over r i de st r i ng ToSt r i ng( )
{
r et ur n st r i ng.For mat (
" My val ue i s {0}, i ' ve been accessed {1} t i mes and updat ed {2} t i mes. " ,
_val ue,
_accessCount ,
_updat eCount
) ;
}
publ i c Test Pr op( i nt Val ue)
{
_accessCount =0;
_updat eCount =0;
t hi s.Val ue=Val ue;
}
}
publ i c cl ass Pr oper t ySi mpl e
{

{
Test Pr op t p=new Test Pr op( 3) ;

Consol e.Wr i t eLi ne( t p.Val ue) ;
t p.Val ue=4;
t p.Val ue=6;
t p.Val ue=-12;
t p.Val ue=806;
t p.Val ue=32;
t p.Val ue=1;

Consol e.Wr i t eLi ne( t p.ToSt r i ng( ) ) ;

}
}

Sortie cran :

3
4
6
- 12
1
My val ue i s 1, i ' ve been accessed 5 t i mes and updat ed 7 t i mes.

Explications :
Faire Console.WriteLine(tp.Value)revient appeler la mthode get de la proprit Value.
Dans cette proprit on a simplement retourn une valeur (qui doit dailleurs tre du mme
type que la proprit).
A loppos, faire tp.Value=32 reviens appeler la mthode set de la proprit Value en lui
donnant comme argument 32 (que lon rcupre alors via le mot clef value).

Modifions la classe Personne vu iez le code pour
obtenir :

e lors lexemple sur les classes. Pour cela modif
/ / Per sonApp2. cs
usi ng Syst em;

/ / not r e cl asse exempl e
publ i c cl ass Per sonne
{
/ / L' ge
pr i vat e i nt _age;
publ i c i nt Age
{
get
{
r et ur n _age;
}
set

{
_age=val ue;
Eval uat eThi nki ng( ) ;
}
}
/ / Le nom
pr i vat e st r i ng _name;
publ i c st r i ng Name
{
get
{
r et ur n _name;
}
set
{
_name=val ue;
Eval uat eThi nki ng( ) ;
}
}

/ / Membr e pr i v
pr i vat e st r i ng _t hi nki ngs;

/ / Const r uct eur s
publ i c Per sonne( i nt Age, st r i ng Name)
{
t hi s. Age=Age;
t hi s. Name=Name;
}
publ i c Per sonne( ) : t hi s( 0, " Unknown" )
{
}

/ / mt hode pr i ve
pr i vat e voi d Eval uat eThi nki ng( )
{
t hi s. _t hi nki ngs=st r i ng. For mat (
" My name i s {0} and I ' m{1} ol d" ,
Name, Age) ;
}

/ / mt hode publ i que
i d publ i c vo SayMyThi nki ngs( )
{
Consol e. Wr i t eLi ne( _t hi nki ngs) ;
}
}

/ / l a cl asse cont enant l e poi nt d' ent r e Mai n
publ i c cl ass Per sonApp
{
{
/ / Cr at i on de quel ques per sonnes :
Per sonne Char l es=new Per sonne( 25, " Char l es" ) ;
Per sonne Edwar d=new Per sonne( 60, " Edwar d" ) ;

Per sonne I nconnue=new Per sonne( ) ;

/ / Fai sons par l er nos chr es per sonnes.
Char l es. SayMyThi nki ngs( ) ;
Edwar d. SayMyThi nki ngs( ) ;
I nconnue. SayMyThi nki ngs( ) ;

/ / on f ai t pl us appel i ci aux membr es publ i cs
/ / mai s aux pr opr i t s publ i ques
Char l es. Age++;
I nconnue. Name=" Rober t " ;
I nconnue. Age=10;

/ / On l eur r edemande de di r e l eur pense :
Char l es. SayMyThi nki ngs( ) ;
Edwar d. SayMyThi nki ngs( ) ;
I nconnue. SayMyThi nki ngs( ) ;

Consol e. ReadLi ne( ) ;
}
}

Le rsultat est identique la version prcdente, pourtant il y a une diffrence.

Explications :
Comme je l'expliquais plus haut, on matrise l'affection ou la rcupration des proprits. Dans
cette exemple, le but est de grer deux membres privs de la classe Personne _age et _name.
La diffrence se situe lors de l'appel la fonction EvaluateThinkings. Elle ne se fait plus
ue l'on a besoin de _thinkings, mais automatiquement ds que l'on met
jour le nom
Comment se droule le programme ? La ligne Inconnue.Name="Robert" fait appel la
fonction set de la proprit Name. Cette dernire a alors deux instructions, d'une part, l'appel
la fonction EvaluateThinkings qui est ncessaire pour la mise jour de _thinkings, et d'autre
part l'affectation de _name. Remarquez le mot clef value qui indique la valeur appele par le
programmeur. J e vous conseille d'excuter ce programme pas pas pour bien visualiser l'ordre
12.2. Indexeurs
Les indexeurs sont comparables aux proprits. Cependant un indexeur permet daccder, non pas
une seule variable comme laide des proprits mais une collection de variables. Ainsi, la
odifie laide de loprateur [].

manuellement ds q
ou l'age.
d'excution.
collection dfinie par la classe pourra tre consulte ou m
cl ass Appl i cat i on
{
{
El eve mar t i n = new El eve( " Mar t i n" , 14) ;
El eve mar c = new El eve( " Mar c" , 13) ;

Cl asse macl asse = new Cl asse( ) ;
macl asse. Add( mar t i n) ;
macl asse. Add( mar c) ;

Consol e. Wr i t eLi ne( macl asse[ 0] . Nom+ " \ t " + macl asse[ 0] . Age) ;
Consol e. Wr i t eLi ne( macl asse[ 1] . Nom+ " \ t " + macl asse[ 1] . Age) ;
Consol e. Read( ) ;

}
}

publ i c cl ass El eve
{
pr i vat e st r i ng _nom;
pr i vat e i nt _age;

publ i c El eve( st r i ng nom, i nt age)
{
_nom = nom;
_age = age;
}

publ i c st r i ng Nom
{
get {r et ur n _nom; }
set {_nom= val ue; }
}
publ i c i nt Age
{
get {r et ur n _age; }
set {_age = val ue; }
}
}

publ i c cl ass Cl asse
{
pr i vat e Ar r ayLi st _el eves;

publ i c Cl asse ( )
{
_el eves = new Ar r ayLi st ( ) ;
}

publ i c El eve t hi s[ i nt i ndex]
{
get {r et ur n ( El eve) _el eves[ i ndex] ; }
set {_el eves[ i ndex] = val ue; }
}

publ i c voi d Add( El eve el eve)
{
_el eves. Add( el eve) ;
}
}

Sortie cran :

Martin 14
Marc 13

Explications :
Une classe reprsentant une classe dlves est dfinie. Cette classe contient donc une
collection (ArrayList) dlves dont le type a t dfinie.
Lindexeur permet daccder directement aux lves de la classe.

13. Attributs
Un attribut permet de spcifier des paramtres supplmentaires une mthode, une classe, une
proprit. Ces paramtres peuvent servir donner encore plus de dtails dans les spcificits dun
objet, dune classe, etc. que les simples public, private, etc. On peut par exemple, spcifier quune
classe est visible depuis un WebService avec lattribut [WebMethod], ou encore indiquer quune
mthode sexcute dans un mme espace mmoire en cas dutilisations de threads avec [StaThread].
Remarquez que les attributs se dclarent en prcdent la mthode ou la classe rattach par un
[nomattribut1,nomattribut2,etc].
On peut galement spcifier des paramtres un attribut. En effet, chaque attribut est hrit de la
classe System.Attribut et on peut donc crer des constructeurs spcialiss.

Exemple : utilisation dun attribut existent

/ / at t r i but es1. cs

usi ng Syst em;
usi ng Syst em.Di agnost i cs;

[ Fl ags]
publ i c enumSt at eFl ags
{
Wi t hWheel s= 0x0001,
Wi t hEngi ne= 0x0002,
Wi t hLi ght s= 0x0004,
Wi t hBr eaks= 0x0008
}

publ i c cl ass At t r i but es1
{
{
St at eFl ags St at e;

St at e = St at eFl ags.Wi t hBr eaks;

St at e |= St at eFl ags.Wi t hEngi ne;

i f ( ( St at e & St at eFl ags.Wi t hLi ght s) != 0)
Consol e.Wr i t eLi ne( " Yes, t her e ar e l i ght s i nst al l ed" ) ;
el se
Consol e.Wr i t eLi ne( " No, t her e i s no l i ght i nst al l ed" ) ;

Consol e.Wr i t eLi ne( " Cur r ent Fl ags ar e {0}" , St at e) ;

}
}

Sortie cran :

No, there is no light installed
CurrentFlags are WithEngine, WithBreaks


Explications :
Ici nous avons via lattribut [Flags] (dont lapplicabilit est sur les numrations
exclusivement) indiqu au compilateur quil doit traiter notre numration comme un champ
de bit, et non une valeur entire.
Le fonctionnement de la fonction diffre sans cet attribut. Essayez de supprimer lattribut, et
vous verrez. Mme si le programme fonctionne, il sera incapable dafficher correctement
State. Si le flag est mis, il reconnatra la combinaison des deux valeurs.
On voit donc comment avec les attributs on peut influencer le droulement du programme.

Tlangcdiez

Transféré par

Informations du document

Titre original

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

Tlangcdiez

Transféré par

Droits d'auteur :

Formats disponibles

http://www.labo-dotnet.

c1. r nd. Next ( ) ; / / except i on l eve! ! !

Coor di nat e a = new Coor di nat e( ) ;

Vous aimerez peut-être aussi