1

+. * (essentiel en

C# : Lessentiel en concentr
Sommaire
1 Introduction.................................................................................................................................. ... 3 1.1 1.2 1.3 1. 1." " Quest-ce quun langage de programmation .......................................................................... 3 Pourquoi lorient objet .......................................................................................................... 3 Un peu dhistoire ..................................................................................................................... 3 Un e!emple ............................................................................................................................. #estion de la mmoire $i$e en .%&' ....................................................................................... 2 2.1 2.1.1 1 2.1.2 2 2.1.3 2.1. 4 2.1." 6 2.1.1 6 2.2 2.3 12 2.3.1 2.3.2 2.3.3 13 2.3. 13 (a s)nta!e procdurale * logique +,+-- applique en +. ............................................................... "

/ariables0 oprateurs numrique et t)pes.............................................................................. 1 (es t)pes .......................................................................................................................... (es oprateurs ................................................................................................................. &!emple de calculs et de dclaration de $ariable ........................................................... 2 (es chaines de caract3res * quelques dtails................................................................... (es $aleurs cle5s et les t)pes nullable .............................................................................. (e +ast ............................................................................................................................. (a condition* i5 7 else 7 s8itch,case 7 oprateur ternaire .................................................... 19 (es boucles* 8hile 7 do 7 5or 7 goto ...................................................................................... :hile.............................................................................................................................. 12 ;o 8hile......................................................................................................................... 13 <or.................................................................................................................................. #oto ...............................................................................................................................

1er a$ril

+. * (essentiel en 2.3." =ortie de boucles * >rea?-+ontinue ............................................................................... 1 2. 2. .1 2." 2.1 14 2.2 14 @rra) 7 enum 7 struct............................................................................................................ 1" 5oreach........................................................................................................................... 11 #estion des erreurs * tr)-catch 7 5inall) ................................................................................ 11 Instructions prprocesseurs .................................................................................................. (e code A unsa5e B et A chec?ed , unchec?ed B.................................................................... 3 (orient Cbjet en +...................................................................................................................... 29 3.1 3.2 29 Introduction........................................................................................................................... 29 Using ......................................................................................................................................

3.3

Instanciation .......................................................................................................................... 29

1er a$ril

3.3.1 3. 22 3." 23 3.1 2 3.1.1 3.1.2 3.1.3 22 3.1. 3.1." 26 3.1.1 3.1.2 3.1.4 3.2 3.2.1 3.2.2 3.2.3 3.2. 34 3.2." 9 1

(attribut et le modi5icateur dacc3s ............................................................................. 21 (a proprit ........................................................................................................................... =tatic ...................................................................................................................................... (es mthodes ........................................................................................................................ Detour sur Eain............................................................................................................. 2 +onstructeur , destructeur ........................................................................................... 2" (a surcharge .................................................................................................................. ;elegate......................................................................................................................... 24 (es $nements ............................................................................................................. Ethodes anon)mes et &!pressions lambda................................................................ 31 Ethode de!tension. ................................................................................................... 33 Itrateurs ....................................................................................................................... 3 (hritage0 le pol)morphisme et les inter5aces ..................................................................... 3" Introduction................................................................................................................... 3" &!emples dhritage * les e!ceptions et thro8 ............................................................. 31 Ded5inition de mthodes et dattributs ....................................................................... 32 (es inter5aces ................................................................................................................. (es attributs ...................................................................................................................

+onclusion .....................................................................................................................................

Introduction

+omme ce chapitre rsume de mani3re s)nthtique le langage de programmation0 si $ous na$eF aucune connaissance en orient objet0 ja$a ou programmation je $ous recommande de lire au moins deu! 5ois ce cours pour donner une meilleure cohsion G lensemble des connaissances qui en ressortent. /ous $erreF quil ) a beaucoup de r5rences G des sous-parties qui seront traites en a$al. Il marri$era sou$ent de coder plusieurs 5ois des e!emples identiques ou tr3s proche a$ec des mots cle5s di55rents pour $ous permettre de comprendre par analogie et $ous $iter de relire lensemble de la source a$ec attention pour comprendre. ;ans les premi3res parties il marri$era de dire A 5onction B G la place de A mthode B0 cest parce que cest plus parlant pour beaucoup0 cet abus de langage $olontaire sera clairci dans la partie rser$e au! mthodes.

1.1 Quest-ce quun langage de programmation

+.0 je ne pense pas $ous lapprendre est un langage de programmation. +es langages ne sont pas le mode de pens de la machine qui elle ne comprend que des instructions binaires dpendantes du processeur. +es langages ont pour but dHtre plus lisible et plus pratique que lassembleur pour simpli5ier la $ie des d$eloppeurs. (e + et le +-- sont des langages compils qui sont donc trans5orms directement en instructions processeur. &n .%&'0 ce nest pas le cas la compilation donne un code IE=I(,Eicroso5t Intermediate (anguageJ qui est interprt par un logiciel IinterprteurJ. Il 5aut donc retenir que les langages sont des normes de d$eloppement qui cherchent sou$ent un compromis entre le con5ort0 la rapidit de d$eloppement et la per5ormance. +es normes sont accompagnes doutils tel un compilateur. ;u 5ait que le code compil E=I( soit commun au langage .%&' utilis0 on peu dire que le +. et le />.%&' sont deu! langages de programmation a)ant un con5ort di55rent mais des per5ormances tr3s similaires.

1.2 Pourquoi lorient o !et

(orient objet G t introduit par le langage =mall'al? Id$elopp par la socit Kero!J en 1622. (orient objet est un ensemble de r3gles0 de concepts0 doutils du langage de programmation pour rendre le d$eloppement plus ais grLce au groupement dlments. (es objets sont donc des entits qui permettent de grouper ensemble des 5onctions et des $ariables en 5acilitant leurs gestions par groupe et en ou$rant de multiples possibilits. ;5inir un objet peut paraitre comme ajouter un outil0 (e 5rame8or? .%&' apporte lui un set imposant dobjets e!istants. Un langage Crient objet nest pas les objets0 mais une s)nta!e et des mots cle5s pour les manipuler et les crer. >ien que nous allons utiliser des objets du 5rame8or? ce cour $isera G $ous apprendre le langage. (orient objet permet la gestion densemble0 le groupement0 lisolation des donnes et des 5onctions. +et ensemble de concepts et doutils permet par e!emple de grouper dans un coin les objets pour accder au! donnes distinctement des objets qui ser$ent a 5aire linter5ace a$ec lutilisateur et des objets qui ser$ent G appliquer les calculs et procdure logiques de 5ond. ;e ce 5ait nous pourrons disposer dun code simple et lisible.

(e +. est un langage rcent apparu en 29910 il est principalement inspir par le Ma$a I166"J mais aussi par le +-. +e langage dont le nom se prononce A +-=harp B G t cr par Eicroso5t G t normalis par l&+E@ lanne de sa sortie Ipuis par lI=C deu! ans plus tardJ. Il ) a eu trois $ersion du +. implmentant toujours quelques 5onctionnalits supplmentaires. (e +. tant un produit du

1." #n peu d$istoire

5rame8or? .%&' leurs $olutions sont tr3s lies. (e +. 2.9 est sorti a$ec le 5rame8or? 1er a$ril2.90

bien quutilisable sur le 5rame8or?2.9 arri$e nati$ement et prend $raiment tout son intrHt dans le 5rame8or? 3." a$ec le (I%Q. Pour utiliser la s)nta!e du +.3.9 il 5aut utiliser le compilateur adapt dans un en$ironnement cible 2.9 ou suprieur. +e compilateur est notamment disponible et implment a$ec /isual=tudio 2994.

1.% #n e&emple
+e tutorial est a! sur le langage et la s)nta!e du +.0 dans le cas ou $ous serieF sous :indo8s0 $ous pou$eF essa)er /isual =tudio &!press ou =harp;e$elop I$oire le mode +. de &clipseJ. ;ans le cas ou $ous serieF sous (inu! ou Eac0 je $ous encourage G lire d3s G prsent les deu! premiers tutoriels sur Eono. Il est important de connaitre ses outils et de les a$oir 5onctionnels pour pou$oir se concentrer sur la logique de programmation. Remarque : Pour les inconditionnels de la ligne de commande, ajoutez votre variable denvironnement Path : C:\WIN !W"\#icroso$t%N&'\(rame)or*\v+%, -, vous .ourrez com.iler les e/em.les 0ue vous aurez enregistr1 dans des $ichiers te/te en $aisant csc%e/e mon.remiercode%cs - .uis e/1cuter le .rogramme mon.remiercode%e/e -, vous .ourrez aussi ajouter des o.tions de com.ilation, .our voir celles dis.onible e/1cutez : csc%e/e 23 - % /oici un code a55ichant dans un terminal A >onjour N B. (e code propos est rduit G sa plus simple e!pression. EHme les projets console par d5aut des en$ironnements de d$eloppement intgrs sont plus consquent. Pour linstant nous nous concentrerons sur le contenu des accolades qui sui$ent A EainI J B. (es accolades sont prcdes de mots cle5s et noms qui ser$ent G 5ormer une structure de!cution. +ette structure rele$ant de lorient objet est ncessaire G le!cution mais elle ne sera e!plique seulement quapr3s a$oir acquis les bases de la logique procdurale.
C#

static class Program { static void Main() {

// Dans les exemples qui suivent nous placerons notre code ici
System.Console.Write ine(!"on#our $!)% & &

/ous a$eF remarqu que sur la premi3re ligne de la Fone tudie Ila ligne $erteJ jai crit un te!te libre en 5ranOais. +ette ligne commence par A ,, B. +e s)mbole est un s)mbole de commentaire qui dit au compilateur de ne pas interprter la 5in de la ligne. Il marri$era sou$ent de $ous 5aire des remarques dans ces commentaires qui sont partie intgrante du tutoriel. Il e!iste aussi une autre con$ention de commentaire qui au lieu dchapper la 5in de la ligne0 chappe jusquG un s)mbole de 5ermeture. +es commentaires lG sou$rent a$ec A ,P B et se 5erment a$ec A P, B I$ous aureF un e!emple dans le prochain e!trait de codeJ. Il ) a une s)nta!e qui permet de gnrer de la documentation G partir des commentaires0 si $ous de$eF tra$ailler en quipe ou pour une entreprise0 gnrer une documentation qui permettra G $otre successeur de prendre la rel3$e sa$3re important Ipage sur la documentation du code en +.J. =i $ous $ous intresseF G cette s)nta!e0 cette page $ous e!pliquera lessentiel. +ela dit le contenu de cette page contient des donnes asseF techniques de ce 5ait il pourrait Htre pertinent d) jeter un Qil seulement apr3s a$oir

5ini de lire ce

1er a$ril

=)stem.+onsole.:rite(ine est appel a$ec A >onjour N B en argument0 on ajoute G cela un A R B pour spci5ier A e!cute Oa puis on passe G la suite B. Cn appelle chaque lment qui sui$i dun A R B une instruction. Il peut Htres sur une ou plusieurs lignes. (orsque Eain a e!cut la derni3re instruction quil contient le programme prend 5in. =i $ous a$eF lanc graphiquement $otre application0 la 5enHtre console se 5ermera car la 5in du programme entraine la 5in de la console. Me sais que Oa ne!plique pas tout le!trait de code mais $enons ) progressi$ement a$ec cette architecture en tHte. DeteneF bien que chaque imbrication de commandes 5inissant par un A R B sappelle A instruction B. Notez bien que les prochains exemples seront souvent juste la procdure entre les accolades de la fonction Main

1.' (estion de la mmoire )i)e en .*+,

Pour comprendre un peu mieu! certains phnom3nes qui seront abords plus tard0 nous allons e!pliquer rapidement la gestion de la mmoire par le .%&' 5rame8or?. (a mmoire est un point essentiel pour pou$oir 5aire de la logique. Detenir des rsultats intermdiaire pour les rutiliser ou autres. Pour enregistrer temporairement une $aleur lui donne un nom. +e nom sera utilis comme un lien $ers un espace mmoire. +ette association nom0 espace mmoire et donne contenue est un tout que lon appelle $ariable. ;ans certains langages de programmation comme le +0 le +-- ou le +. nous a$ons des A $ariables liens B. +es $ariables contiennent ladresse dune donne qui $entuellement pourrait ne pas Htre nomme. +es $ariables liens sont en ralit appeles pointeurs0 elles sont sou$ent caches dans le .%&' bien quelles soient utilises au cQur du 5rame8or?. .%&' spare la mmoire en deu! parties isoles0 la pile et le tas. Quand on 5ait un programme en .%&'0 le 5rame8or? nous rser$e un espace mmoire. (es autres programmes ne peu$ent normalement pas ) accder. (es donnes dites A t)pe $aleur B sont celles qui ont leurs $aleurs dans la pile. (es $ariables de t)pe $aleur sont le plus sou$ent in5erieure G 32 octets. >ien que per5ormant pour les petites $ariables le t)pe $aleur est complt par un autre t)pe * le t)pe r5rence. (es $ariables de t)pe r5rence ont un pointeur enregistr dans la pile qui pointe $ers les donnes de la $ariable. +es donnes sont dans la Fone mmoire appele le tas. Un outil appel A #arbage +ollector B est charg de librer et d5ragmenter d)namiquement la mmoire du tas. @insi0 si des donnes nont plus de pointeurs associes0 la mmoire est libre. =i les donnes taient au milieu du tas0 lespace libr sera rutilis par les donnes du A 5ond du tas B. +e procd permet de redimensionner notre espace mmoire rser$ et donc de librer de la mmoire pour le s)st3me et les autres processus.

La s-nta&e procdurale : logique C.C// applique en C#

+omme nous le disions0 la s)nta!e du +. est tr3s inspire du +,+--0 on peut mHme 5aire de larithmtique de pointeurs pour peu que lon d5inisse notre code en tant que A Unsa5e B. (es personnes a)ant de bonnes bases en +,+-- ne $erront rien de!traordinaire dans cette partie qui risque de paraitre dense pour ceu! qui partent de Fro. Remarque : "i cest votre tout .remier cours de .rogrammation, ce cha.itre va vous .araitre dense, je vous encourage essa4er cha0ue e/em.le et essa4er de .rendre du recul avec cette .artie dans votre

bagage .our mieu/ revenir sur la .artie traitant de lorient1

1er a$ril

2.1 0aria les1 oprateurs numrique et t-pes.

(es oprateurs numriques sont la base des calculs et de la logique. (a mmoire est un point cle5 de la programmation. Pour interprter le code binaire dans une $ariable et donc la donne en mmoire il 5aut en connaitre le t)pe. (a dclaration des $ariables0 lattribution de leurs $aleurs et les oprateurs numriques de base sont similaire en +. et en +,+--0 $o)ons comment les utiliser. ;ans une quHte de s)nth3se0 jai 5ait peu de!emple dans cette partie0 si $ous trou$eF dur G comprendre les t)pes ou les oprateurs trop dtacheF de la pratique a$anceF a$ec en parall3le le!emple en 2.1.3. 'ous les oprateurs et tous les t)pes n) sont pas illustrs. ;urant lensemble du cours $ous $erreF lusage de chaque operateur au moins une 5ois0 mais pour ce qui est des t)pes jutiliserai principalement des entiers. 2.1.1 Les t-pes /oici quelques t)pes de base utilisable en +.. (es t)pes prsents dans ce tableau G le!ception de A string B et les structures sont les seuls t)pes G Htre stoc?es par $aleur. Classe =)stem.=>)te =)stem.>)te =)stem.Int11 =)stem.Int32 =)stem.Uint32 =)stem.Int1 =)stem.=ingle =)stem.;ouble =)stem.;ecimal =)stem.+har =)stem.>oolean =)stem.=tring Remarque : Ce tableau est ada.t1 dun tableau 0ue vous trouverez dans le cha.itre 5 des cours sur le (rame)or*, ce cha.itre .ourrait vous aider a..ro$ondir vos connaissances techni0ues des bases du t4.age, de lorient1 objet et vous 4 trouverez une e/.lication .lus d1taill1e et .lus imag1e de lusage de la m1moire vive en %N&'% +ontrairement G certains langages Icomme le p)thonJ tout objet doit Htre e!plicitement t)p. +haque $ariable a un t)pe d5ini et on est oblig de spci5ier un t)pe pour chaque argument de chaque mthode. Pour allouer de la mmoire G une $ariable0 on cre une instruction a$ec dune part le t)pe et dautre part le nom de la $ariable. =i $ous $ouleF trou$er 5acilement la $aleur ma!imale et la $aleur minimale dun t)pe numrique0 5aites A =)stem.Int32.Ea!/alue B pour retourner le plus grand des int ou Ein/alue pour trou$er le plus petit. /ous na$eF pas encore $u comment 5aire usage de ses $aleurs mais noteF que les $aleurs limites sont accessible dans le 5rame8or? et de ce 5ait $ous nHtes pas tenu de les retenir. =i on ajoute G une $ariables A .#et')peIJ B0 cela retournent le t)pe de la $ariable. /ous $erreF un contrSle de t)pe utilisant cette mthode dans la partie sur la gestion des erreurs.

1er a$ril

2.1.2

Les oprateurs Pour traiter la $ariable on utilise des oprateurs. /oici les oprateurs dans leur ordre de priorit Ion pourra utiliser des parenth3ses pour red5inir les priorits comme en mathmatique.J * Oprateur C# Calculs P , T Tests is U V UW0VW NW WW Logique XX YY ZZ cond ? $ar1 : $ar2 Attribution W -W0 -W0PW0,W0TW0XW0YW Incrmentation ** --* : Ces o.1rateurs dattributions ne servent 0u $aire une contraction .rati0ue% 6vec lo.1rateur 78 on ajoutera la valeur actuelle de la variable la valeur attribuer% 9ariable :o.1rateur;8 5< 10uivaut 9ariable 8 9ariable:o.1rateur;5<% 9ous aurez des e/em.les dans le/trait de code suivant% ** : =es o.1rateurs dincr1mentation se .lacent sur une variable dans une instruction seule ou dans un calcul% "i le signe est gauche de la variable ce sera e/1cut1 en .riorit1 absolue dans linstruction, sil est droite la variable on incr1mentera la toute $in de linstruction% Remarque : !n ne .eut .as avoir .lus dun o.1rateur dattribution .ar instruction% 2.1." +&emple de calculs et de dclaration de )aria le /oici un e!emple dutilisation *
C#

int a% // on d'clare a de type int int ( ) *% // on d'clare ( et y attri(u la valeur * a ) +% // on attri(u la valeur + dans a

System.Console.Write ine(!a),t!-a..oString()-!,n(),t! - (..oString() - !,n!)% //////////////////////////////////////////////////////////////////////////////

/ .outes les varia(les o(#ets ont la m't0ode !..oString()!. / 1ppliqu'e 2 un int3 !..oString()! retourne une c0aine de / texte contenant la valeur. / / 4op'rateur !-! entre des string les concat5nes c4est 2 dire les 6usione / en les mettant 2 la suite. / / !,n! et !,t! sont des caract5res sp'ciaux 7 voir partie 8.9.* ////////////////////////////////////////////////////////////////////////////// a -) a - --(% // ()(-9% a)a-a-(% System.Console.Write ine(!a),t!-a..oString()-!,n(),t! - (..oString() - !,n!)% a // a)a/( a /) :) (% 8/(--/a% // a)a:8/(/a% (-)9% System.Console.Write ine(!a),t!-a..oString()-!,n(),t! - (..oString() - !,n!)% System.Console.;ead<ey()% // attend que l4utilisateur appuie sur une touc0e
Retour Console:

aW 9 bW " aW 1 bW 1 aW -11 bW 2

+et e!emple peut paraitre court0 cest $rais mais ne bloqueF pas dessus0 si ce nest pas acquis maintenant0 $ous $erreF des e!emples partout dans ce court $u que cest $raiment la base. Il 5aut retenir pour la dclaration des $ariables * le nom du t)pe0 le nom de la $ariable et le caract3re de 5in dinstruction IA R BJ. (e!emple montre que lon peut attribuer une $aleur en mHme temps que lon dclare une $ariable Ideu!i3me ligneJ. 2.1.% Les c$aines de caract2res : quelques dtails ;ans le commentaire le plus imposant0 on $oit que pour les strings il e!iste des caract3res spciau! dont celui du retour G la ligne et de la tabulation. /oici quelques caract3res spciau! * [n0 [r * retour G la ligne [t * tabulation Ipratique pour les alignements $erticau!J [[ * permet da55icher un antislash [\ * permet da55icher un guillemet [!KK ou A KK Best une $aleur he!adcimale de deu! caract3res Ichacun entre 9 et <J * permet da55icher un caract3re par son code he!a. =i $ous ne $ouleF pas bn5icier du support de ces caract3res et a$oir une chaine non interprte0 il su55it de prcder la chaine par un ] Ipratique pour les adresses de 5ichier par e!empleJ. (es cha^nes prcde dun arobase peu$ent Htre appeles A cha^ne /erbatim B0 ces cha^nes peu$ent contenir de rels retours G la ligne. @u lieu de concatner les chaines a$ec le signe A - B on peut ajouter des $ariables dans les strings a$ec un mo)en simple de 5ormatage.
C#

int arg9 )98%

string arg8 ) !(on#our!%

ulong arg= ) 9*>?>@9*=>% Console.Write ine(!arg9){+&,narg8){9&,narg=){8&!3arg93arg83arg=)% arg8 ) string.Aormat(!{+&3 {9&3 {8&!3 arg93 arg83 arg=)% Console.Write ine(arg8)% Console.;ead<ey()%
Retour Console

arg9)98 arg8)(on#our arg=)9*>?>@9*=> 983(on#our39*>?>@9*=>

+ette mthode permet une $isibilit un peu plus claire et peut $iter un grand nombre de A .'o=tringIJ B. (es arguments nattendent pas de t)pe particulier. 2.1.' Les )aleurs cle3s et les t-pes nulla le Il e!iste des $aleurs qui sont reprsentes seulement par des mots cle5s. +es mots cle5s sont null0 true et 5alse. Pour pou$oir attribuer la $aleur null G une $ariable Ide t)pe $aleurJ on utilise une structure qui contient un boolen et la $aleur de t)pe d5iniIle mot structure est d5ini partie 2. J. +e boolen est appel _as/alue. (orsque sa $aleur est G A true B le nullable a une $aleur0 quand il est G 5alse la $ariable $aut null. +et e!emple $ous montre les deu! mthodes pour 5aire un nullable.
C#

uintB a ) 8% System.Culla(leDuintE ( ) 9*% ( ) null% a -) (% // a ) null - 8 cFest 2 dire a ) null ( ) 98% System.Console.Write ine((..oString()-!:/:!-a..oString()-!:/:!-(aBB()..oString())% System.Console.;ead<ey()%
Retour Console

98:/::/:98

=i lon su55i!e le t)pe $aleur dun A Z B on obtient ce t)pe mais nullable. Cn peut aussi mettre e!plicitement comme t)pe de la $ariable nullable comme 5ait pour la $ariable b IPour mieu! comprendre lutilit des che$rons qui dans se conte!te ne $eulent $idement pas dire A suprieur G B0 $ous pourreF $oir les classes gnriques dans le chapitre traitant de linstanciationJ. +es $ariables sont susceptibles de contenir null qui correspond G A nant B0 A rien B Idans certains cas dutilisation A non d5ini BJ. (intrHt da$oir une $aleur null est le plus sou$ent pour mentionner que ce nest pas d5ini. (autre utilisation de null est la des-allocation de mmoire. ;ans le cas ou la $ariable est de t)pe r5rence0 si lui attribue null Ie!emple * A $ariable W null R BJ ladresse stoc?e par le pointeur dans la pile sera mise G 9. (orsque le #arbage +ollector contrSlera dans le tas la $ariable0 $u que rien ne pointe dessus elle sera supprime. 2.1.4 Le Cast (e cast est un mo)en dutiliser une $ariable qui nest pas du t)pe G utiliser pour le calcul. +est G dire le cast permet de retourner une $aleur du t)pe attendu G partir de la $ariable. @insi on pourra par e!emple caster un int en long pour utiliser une $ariable na)ant pas les mHme limites de dpassement. Il ) a deu! mo)ens pour essa)er de changer le t)pe dun objet0 un $ite les erreurs quand on nest pas sur que lobjet puisse Htre cast et lautre ret)pe ou ren$oie une erreur ou une

$aleur aberrante Ipour comprendre quand on a une erreur ou une $aleur aberrante regardeF la partie sur chec?ed,unchec?edJ. (e mot cle5 A as B doit caster $ers un t)pe nullable ou r5rence I$oir partie 2.2J. =i la $ariable est du t)pe requis ou A compatible B0 as retourne la $aleur t)pe. @u cas contraire il retournera null. (e A as B est traduit a$ec dautres oprateurs dans le!emple. Pour rappel0 loprateur A ZZ B sert G retourner une autre $aleur si le premier lment est null0 il est par5ois utilis a$ec as pour a$oir un retour en cas dimpossibilit de cast di55rent de null. (e cast classique consiste G imposer G une $ariable de changer de t)pe0 si ce changement de t)pe ne 5onctionne pas une e!ception est le$e.
C#

int a ) int.MaxGalue% long ( ) long.MaxGalue% long c ) 9*% // cast implicite o(#ect o ) c% // explicite necessaire a )cast (int)(% //l5ve une over6loHexeption si les d'passements sont contrIl's // ( )cast a% implicite //6onctionne

// usage de as et de l4op'rateur BB ( ) (o as longB) BB + % // 'quivau 2 l4instruction7 ( ) ((o is longB) B ((longB) o) 7 ((longB)null) ) BB +% // ternaire d'taill' dans lapour partie // l4op'rateur ici3 seuls !long! et sera !longB! 6onctionnent le qui typesuit. de c Console.Write ine(()% System.Console.;ead<ey()%

2.2 La condition: i3 5 else 5 s6itc$.case 5 oprateur ternaire

(e mot cle5 i5 Ien 5ranOais A si BJ permet le!cution conditionnelle de code. (a condition soumise G i5 doit retourner un >ooleen I'rue ou <alseJ0 nous utiliserons sou$ent ici des oprateurs de test. &nsuite nous passons la procdure G e!cuter si la condition est $raie entre accolades. =ou$ent0 et cest $rai a$ec beaucoup de mots cle5s0 quand les accolades ne paraissent pas G la suite de la condition0 le mot cle5 sappliquera uniquement sur linstruction qui suit. (e mot cle5 else IsinonJ est toujours prcd dau moins un i5. else comme i5 est sui$i de code entre accolades. +e code sera utilis seulement si la derni3re instruction i5 na pas eu G e!cuter le bloc. =i lon doit procder G une srie de test ou un seul doit Htre e!cut0 $ous $erreF une suite du genre A i50 Pelse i50 else i5`-0 else B0 seule la procdure associe de la premi3re condition $raie sera e!cute. (e mot cle5 s8itch permet seulement de contrSler di55rentes $aleurs que peut prendre une $ariable ou e!pression et dagir en 5onction. (es propositions ne peu$ent pas Htre des $ariables0 il ne peut pas ) en $oir 2 identiques0 tous les t)pes de $aleurs ne peu$ent ) Htre utiliss et pour ce qui est des per5ormances le s8itch est la moins optimise des 3 solutions. %anmoins certains d$eloppeurs

trou$ent sa s)nta!e plus lisible et plus pratique que limbrication

1er a$ril

(a s)nta!e de loprateur ternaire est la sui$ante * A IboolenJ Z retour=i/rai * retour=i<au! B. Cn peut bien $idemment en imbriquer plusieurs pour cumuler plusieurs conditions. Eais il 5aut noter que loprateur ternaire permet un retour conditionnel et non pas une e!cution conditionnelle0 caest-G-dire quil ne peut rien e!cut et quil se place dans des e!pressions comme une $aleur.
C#

int a% string (% System.Console.Write ine(!JntreK 8!)% a ) int.Parse(System.Console.;ead ine())% // int.Parse prend le texte entr' par lFutilisateur (;eadline()) / //et en retourne la valeur indiqu'e si ce texte contien un nom(re. // M't0ode i6/else i6 { (a )) 8) & a ) a% ( ) !normal! % // a)a est une instruction inutile 2 titre dFexemple // on peut mLtre plusieurs instructions

else(i6 ))loin!% 9 MM a// ))on =)peut se passer dFacollade pour une instruction seule ) (a !Pas else { & ( ) !(iKarre!% // on aurai pu remplacer !else! par !i6(a D 9 MM a E = )! // une instruction seule passe mLme avec les acollades

// M't0ode sHitc0/case sHitc0 (a) { case 87 // le sHitc0 saute 2 cette condition si a vaut 8 ( ) !"ien Nou' $!% // puis ex'cute ses instruction (reaO% // e (reaO 6ait sortir du sHitc0 case 97 // en CP 7 pas de (reaO ) pas dFinstructions case =7 // le cas 9 vien ex'cuter les instructions du cas = ()!Pas loin!% (reaO% // donc on sort du sHitc0 de6ault7 // de6ault repr'sente tous les autres cas & ( ) !(iKarre!% (reaO%

// de7retour conditionel () M't0ode (a )) 8)op'rateur B !normal! (a )) 9 MM a )) =) B !Pas loin! 7!(iKarre! % System.Console.Write ine(()% System.Console.;ead<ey()%

+et e!trait de code montre trois mani3res de 5aire la mHme chose0 (e programme demande G lutilisateur dentrer une $aleur qui est a55ect dans A a B. @ la 5in on a55iche la chaine de caract3re A b B. &ntre trois 5aOons pour mettre dans A b B * la chaine A >ien jou N B si A a B est gal G 2 A Pas loin B si A a B est gal G 1 ou 3 A biFarre B si A a B ne rpond G aucun de ces crit3res. +omme e!pliqu antrieurement0 on constate que suite au A i5 B il ) a une condition ellemHme sui$ie dune ou plusieurs instructions. ;ans le cas de le!emple ci-dessus si A a B est gal G 2 A aWW2 B retourne $rai ce qui engendre le!cution de la55ectation de A >ien jou N B. (orsque lon

1er a$ril

utilise le mot cle5 i5 juste apr3s le A else B cest pour 5aire une liste de test0 le premier $rai sera le seul e!cut . (e s8itch permet donc ici de tester les cas qui nous intressent indi$iduellement caest-G-dire 10 2 et 3. /u que le cas 1 et le cas 3 ont le mHme traitement on peu les runir. (e mot cle5 brea? doit Htre mis en 5in de!cution a$ant la nou$elle $aleur du s8itch. =i $ous $ouleF plus de renseignement sur le s8itch ou en cas de probl3mes a$ec ce mot cle5 ou si $ous $ouleF $oir les di55rences entre le s8itch + et le s8itch +.0 je $ous recommande cet article 5rancophone. Imbriqu0 loprateur ternaire nest pas un cadeau pour ce qui est de la lisibilit. Pour rendre plus clair G lQil0 nous aurions pu mettre des parenth3ses autour de la sous e!pression ternaire ou la mettre G la ligne. /ous a$eF nanmoins pu constater laspect pratique de cet oprateur qui est celui qui a eu la s)nta!e la plus rapide0 Oa naurai pas t pour le!emple0 jaurai certainement mis le!pression directement en argument de la mthode :rite(ine sans passer par A b B. >ien quil puisse paraitre pratique et asseF optimis pour ce qui est des per5ormances0 loprateur ternaire $a par son manque de lisibilit G lencontre des principes des langages rcents qui $isent le con5ort de d$eloppement et la lisibilit. Il sera principalement utilis en argument de 5onction $u quon ne peut pas $raiment ) mettre des e!cutions conditionnelles.

2." Les oucles: 6$ile 5 do 5 3or 5 goto

(es boucles 5ont parti des 5ondamentau! de la logique de la programmation0 notre prochain e!emple ressemblera en5in G quelque chose $u que lon aura $u apr3s Oa lessentiel de la partie structure logique des instructions dans une procdure. 2.".1 7$ile :hile Ien 5ranOais A tant que BJ permet de 5aire une boucle conditionnelle0 probablement le t)pe de boucle que $ous croisereF le plus a$ec les boucles 5or. %i$eau structure il ressemble au i50 il a une condition entre parenth3ses et un bloc? de code ncessairement entre accolade pour peu quil ait plusieurs instructions. =i la condition du 8hile est $raie le bloc? de code est e!cut0 G la 5in de cette e!cution0 le bloc? est e!cut G nou$eau si la condition et $rai et ce jusquG ce que ce ne soit plus le cas.
C#

int a)8% int ()9*% int temp% H0ile (( E +) { i6 (a )) 9) a ) 8% else a ) 9% System.Console.Write ine(!.our du #oueur !-a..oString() -!,nil reste !-(..oString() -! allumettes,npreneK un nom(re d4allumettes entre 9 et = (de6aut =)!)% temp ) int.Parse(System.Console.;ead ine())% i6 (temp E + QQ temp D >) (:)temp% & else (:) =%

System.Console.Write ine(!#oueur !-a..oString()-! a perdu!)% System.Console.;ead<ey()%

Cn peut $oir dans cet e!emple que tant quil reste des allumettes0 les joueurs peu$ent en prendre jusquG ce quil ) en ait plus moment ou on sortira de la boucle pour a55icher le nom du

perdant. (e 5onctionnement est simple et commun au! autres. Il su55it de maitriser un t)pe de boucle pour 5acilement comprendre les autres. 2.".2 8o 6$ile 'r3s similaire au 8hile normal0 il impose un minimum dune e!cution a$ant de contrSler les conditions de maintien de la boucle.
C#

int a)+% do { System.Console.Write ine(a--..oString())% & H0ile (a E + QQ a D 98) % System.Console.;ead<ey()%

(e do-8hile est lqui$alent du 8hile mais la s)nta!e et di55rente et le contrSle de condition se 5ait G la 5in de la boucle. ;e ce 5ait le bloc? est e!cut au moins une 5ois mHme si la condition est 5ausse en premier lieu. ;ans ce cas A a B W 90 il e!cute le bloc une premi3re 5ois alors que la condition est 5ausse. &nsuite jusquG ce que A a B ne respecte plus la condition il lincrmente et la55iche. I@55iche les nombres de 9 G 11 inclusJ. 2."." 9or (a boucle 5or est sou$ent tr3s pratique mais nest pas toujours aime des dbutants0 cest un 8hile a$ec deu! champs supplmentaires * une $ariable locale et une e!cution. (e tout est dans les parenth3ses du 5or0 nous ) $errons ncessairement deu! A R B pour sparer les 3 champs. De5aisons le!emple du jeu des allumettes a$ec une boucle 5or *
C#

int a ) 8% int temp% 6or (int ( ) 9*% ( E +% (:)(tempE+ QQ tempD>)Btemp7= ) { i6 (a )) 9) a ) 8% else a ) 9% System.Console.Write ine(!.our du #oueur ! - a..oString() - !,nil reste ! - (..oString() - ! alumettes,npreneK un nom(re d4allumettes entre 9 et = (de6aut =)!)% temp ) int.Parse(System.Console.;ead ine())%

&

System.Console.Write ine(!#oueur ! - a..oString() - ! a perdu!)% System.Console.;ead<ey()%

(a boucle 5or comme $ous pou$eF le constater met en $aleur une $ariable locale qui sera le plus sou$ent utilise dans la condition de la boucle Idonc son instanciationJ0 la condition mHme puis une instruction qui met en $aleur le traitement 5ait G chaque itration Ia part la premi3reJ0 $ous $erreF sou$ent A 5orIint a W 1 R aUW19 Ra--Jb ,,instructions Rc B pour les boucles qui doi$ent se rpter 19 5ois. 2.".% (oto (e goto est une alternati$e bien quG $iter qui permet des choses asseF tonnantes. (e goto 5ait un saut jusquG un endroit nomm n importe od dans la procdure. Pour nommer un endroit on

parle de label ou dtiquette0 on met son nom sui$i de A * B. Mai mis la mthode Eain dans cet e!emple pour montrer que par con$ention0 ces labels sont indents en retrait sur la gauche. (a condition boucle ralis a$ec i5. ;ans ce conte!te le goto et le label sont G proscrire du 5ait quun do 8hile permet la mHme chose. Il est important de noter que le goto peut aussi 5aire un saut $ers un label qui est en a$al dans le code ce qui peut permettre de sortir par e!emple dune imbrication de boucles.
C#

static void Main() { int a ) 8% int temp)+% int ( ) 9*% nouveau.our7 i6 (a )) 9) a ) 8% else a ) 9% System.Console.Write ine(!.our du #oueur ! - a..oString() - !,nil reste ! - (..oString() - ! alumettes,npreneK un nom(re d4allumettes entre 9 et = (de6aut =)!)% temp ) int.Parse(System.Console.;ead ine())% i6 (temp E + QQ temp D >) ( :) temp% else ( :) =% i6 (( E +) goto nouveau.our% System.Console.Write ine(!#oueur ! - a..oString() - ! a perdu!)% System.Console.;ead<ey()%

&

Remarque : =e goto est mal aim1 de beaucou. de .rogrammeurs car goto ne res.ecte .as la structure logi0ue de la .ens1e de de lindentation et du cou. cest moins lisible 0ue les autres boucles% Certains .rogrameurs vont jus0u interdire lutilisation du goto ou d1velo..er des langages nim.l1mentant .as ce t4.e de boucle% e ce $ait dans la mesure du .ossible il $aut .rivil1gier lutil$isation dautres t4.es de boucles% 2.".' Sortie de oucles : :rea;-Continue Il peut arri$er dans le cas ou les boucles e55ectuent plusieurs oprations que lon $euille sortir directement de la boucle ou sauter le!cution de la 5in du bloc?0 pour Oa il e!iste les mots cle5s brea? et continue. (e mot cle5 brea? permet de sortir brutalement de la boucle tandis que continue ren$oie au test. Il $a sans dire que ces deu! instructions ne 5onctionnent pas dans le cas de boucle 5aites au goto.
C#

int a ) 8% int temp)+% int ( ) 9*% H0ile(true) { i6 (a )) 9) a ) 8% else a ) 9% System.Console.Write ine(!.our du #oueur ! - a..oString() - !,nil reste ! - (..oString() - ! alumettes,npreneK un nom(re d4allumettes entre 9 et = (de6aut =)!)% temp ) int.Parse(System.Console.;ead ine())%

&

i6 (temp E + QQ temp D >) ( :) temp% else ( :) =% i6 (( E +) continue% (reaO%

System.Console.Write ine(!#oueur ! - a..oString() - ! a perdu!)% System.Console.;ead<ey()%

&$idemment ce cas est plus un cas dtude quun cas pratique0 $ous aureF un autre e!emple aussi e!plicite mais montrant plus lintrHt de ces mots cle5s dans la partie sur la gestion des erreurs.

2.% <rra- 5 enum 5 struct

Pour grouper des $ariables ou des $aleurs il ) a plusieurs outils0 les trois outils que je $ous prsente ici sont tr3s di55rents. =truct * d5ini un t)pe de $ariable G plusieurs champs. &num * organise des $aleurs cle5s (es arra)s sont des $ariables dclares en tant que liste de $aleurs de t)pe commun. (e!emple propose un semblant dorganiseur de tLches et 5ait la somme de la dure des $nements de la semaine. enum et struct sont pour 5aire des dclarations qui seront en dehors de Eain. enum et struct 5orment des lments0 une 5ois d5inis on ne peut plus les modi5ier. ;ans la structure IstructJ on d5inie chacune de ses sous $ariables et leur t)pes comme si on dclarait des $ariables. /ous remarquereF le mot A public B. (a structure est en ralit tr3s proche de la classe I$oir chapitre 1 sur le 5rame8or?J mais nest en gnral utilis que pour ranger un petit nombre de $ariable.
C#

class truc { struct evenement { pu(lic intRS #ours% pu(lic string tac0e% pu(lic int duree%

&

enum semaine {lundi)93 mardi3 mercredi3 #eudi3 vendredi3 samedi3 dimanc0e& enum longueur.emps {tresCourt)9*3court)=+3moyen)?+3asseKlong)T+3deux0eures)98+3treslong)8>+& static void Main() { int temp)+% evenementRS cal ) neH evenementRS { // a syntaxe utilis'e ci:dessous pour remplir les 'v5nements ) CP=.+ neH evenement{ #ours) neH intRS {(int)semaine.dimanc0e3(int)semaine.mercredi&3 tac0e)!6aire la vaiselle!3 duree)(int)longueur.emps.court&3 neH evenement{ #ours)neH intR@S3 tac0e)!lire ses 6lux ;SS!3 duree)(int)longueur.emps.asseKlong&3 neH evenement{

&%

#ours ) neH intRS {(int)semaine.lundi3 (int)semaine.mercredi&3 tac0e ) !prendre un (ain!3 duree ) (int)longueur.emps.moyen&

calR9S.tac0e -) ! et suivre quelques liens!% 6or (int i)+% i D cal. engt0% i--) { temp -) calRiS.duree / calRiS.#ours. engt0% System.Console.Write ine(((dou(le)temp/?+)..oString()! 0eures de ta semaine occup'e (tUc0e a#out'7 ! - calRiS.tac0e-! )!)%

& & &

System.Console.;ead<ey()%

Retour Console:

9 0eures de ta 993* 0eures de quelques liens 9=3* 0eures de

semaine occup'e (tUc0e a#out'7 6aire la vaiselle ) ta semaine occup'e (tUc0e a#out'7 lire ses 6lux ;SS et suivre ) ta semaine occup'e (tUc0e a#out'7 prendre un (ain )

(es principau! points G retenir ici sont * (orsque lon appelle lenum il 5aut caster pour a$oir le t)pe dsir (es arra)s sont G taille statique0 $ous ne pourreF pas ajouter dlments0 pour 5aire des sortes dA arra)s d)namique B on utilisera une classe gnrique I$oqu dans le chapitre 3.2 sur linstanciationJ. 2.%.1 3oreac$ /ous a$eF constat que ma boucle 5or me permettait de parcourir la liste A cal B a$ec la $ariable i qui me sert dinde!. ;e ce 5ait je traite tour G tour chaque lment de larra). Pour 5aire cette dmarche plus lisiblement et gagner en taille de code jaurai pu re5aire ma boucle comme suit *
C#

6oreac0 (evenement e in cal) { temp -) e.duree / e.#ours. engt0% System.Console.Write ine(((dou(le)temp/?+)..oString()! 0eures de ta semaine occup'e (tUc0e a#out'7 ! - e.tac0e-! )!-semaine.lundi.Vet.ype())% & System.Console.;ead<ey()%

(a liste cal est la mHme que dans le!emple prcdent0 on 5ait passer tour G tour dans la $ariable locale chaque lment e. @u 5inal on e!cute les mHmes instructions qua$ec la boucle 5or dans le!emple antrieur. %oteF le mot cle5 A in B qui napparait que dans ce conte!te. Pour quun 5oreach soit utilisable sur un objet ce dernier doit a$oir un comportement adquat I$oir la partie sur les itrateursJ.

2.' (estion des erreurs : tr--catc$ 5 3inall+omme $ous la$eF peut Htre djG constat0 si $ous entreF une chose qui nest pas assimilable G du te!te dans le jeu qui nous sert de!emple0 nous a$ons une erreur. Pour grer les erreurs nous pou$ons isoler le code propice G lerreur et lisoler dans un bloc de code A tr) B. %ous pou$ons regarder la documentation de la mthode propice G lerreur pour $oir les di55rents t)pes derreurs

qui peu$ent ad$enir en ce conte!te. (a mthode propice G lerreur dans notre code est A Parse B0 la surcharge prenant en argument un string * les e!ceptions de ParseIstringJ sur E=;%. Pour pou$oir traiter lerreur0 on $a ranger le code en cas derreur dans un bloc A catch B. =i on met catch seul Isans arguments ni parenth3sesJ le traitement sera le mHme quelque soit lerreur et on ne pourra pas retourner din5ormations relati$es au! erreurs. &n mettant les parenth3ses et un argument gnral Icomme dans notre e!empleJ on a une $ariable interne au catch IA e BJ qui contiens les donnes de lerreur et qui permet de es a55icher et de ragir. (es e!ceptions sont des classes qui seront d5ini en e!emple sur lhritage. &!ception regroupe toutes les catgories caest-G-dire tous les t)pes de!ceptions. ;ans notre e!emple nous comparerons les t)pes de le!ception G ceu! que lon a trou$s sur E=;% pour $oir la comparaison des t)pes. %ous retraiterons les erreurs dans la partie A &!emple dhritage B. (e mot cle5 5inall) le plus sou$ent utilis pour librer la mmoire est G plac apr3s le tr) et le catch. +e bloc? sera e!cut quil ) ait erreur ou non. Remarque: voici 0uel0ues .rinci.au/ attributs communs toutes les &/ce.tions .ermettant dobtenir des in$ormations .our signaler, trouver et corriger les bugs : #essage est un "tring d1crivant la cause de lerreur de mani>re relativement e/.licite .our un utilisateur% ?el.=in* retourne ladresse @e/ :AB=C du $ichier daide associ1 au t4.e de le/ce.tion% "ource donne le nom de la r1$1rence, lassembl4 ou du $ichier source 0ui est lorigine% 'arget"ite .ermet davoir le t4.e de retour de la m1thode 0ui lev1 lerreur et le t4.e des arguments% "tac*'race donne la ligne de lerreur et remonte du #ain la m1thode 0ui l>ve le/ce.tion et $ourni la ligne%
C#

uint a ) 8% uint temp ) +% uint ( ) 9*% H0ile (( E +) { i6 (a )) 9) a ) 8% else a ) 9% System.Console.Write ine(!.our du #oueur ! - a..oString() - !,nil reste ! - (..oString() - ! alumettes,npreneK un nom(re d4allumettes entre 9 et =,n(de6aut =3 nom(re n'gati6 pour a(andoner)!)% try { & temp ) uint.Parse(System.Console.;ead ine())%

catc0 (System.Jxception e) { System.Console.Write ine(e.Message)% i6 (e.Vet.ype().Jquals(typeo6(System.1rgumentCullJxception))) System.Console.Write ine(!impossi(le7 retour minimal) ,!,! (non: null)!)% else i6 (e is System.Wver6loHJxception) else(reaO% System.Console.Write ine(!message non parsa(le!)%

i6 (a )) 9) a ) 8% else a ) 9% continue%

&

& i6 (temp D >) ( :) temp% else ( :) =%

System.Console.Write ine(!#oueur ! - a..oString() - ! a perdu!)% System.Console.;ead<ey() %

Remarque : t4.eo$ est un mot cle$ 0ui .rend en argument une classe et 0ui retourne un t4.e, ici il nous .ermet de savoir si le t4.e de lerreur e - rel>ve bien des classes en argument%

2.4 Instructions prprocesseurs

Me ne mettrai pas de!emple pour linstruction prprocesseur0 cest asseF peu utilis bien que ce soit la seule mani3re pour pou$oir d5inir des instructions G compilation conditionnelle. &n gnral ce ne sera pas utilis0 dautan que contrairement au +,+-classique0 A .de5ine B ne permet pas de 5aire de macros. Une liste des mots cle5s des instructions prprocesseurs est disponible G cette page * http*,,msdn.microso5t.com,5r-5r,librar),ed4)d1haI/=.49J.asp!

2.= Le code > unsa3e ? et > c$ec;ed . unc$ec;ed ?

+ette partie aura du sens particuli3rement pour ceu! qui ont djG manipul des pointeurs en +,+--0 bien que cela permettes des choses asseF puissante0 on peu par5aitement se passer de ce mode G part pour le hac?ing. (e mode unsa5e Ipourrait Htre traduit par non serJ permet de manipuler directement les adresses mmoire et donc les pointeurs. %ous allons $oquer ici quelques mots cle5s * unsa5e0 stac?alloc0 5i!ed. Pour pou$oir compiler du code unsa5e0 $ous de$eF le spci5ier0 depuis /isual =tudio slectionneF * projet V proprits du projet0 $ous de$reF cocher une chec?bo! dans longlet gnrer IprojetVoptionsVCptions du compilateur pour Eono;e$elop ou le param3tre de commande ,unsa5e dans le terminalJ pour spci5ier e!plicitement $otre autorisation. +es dplacements de donnes tant gHnants si lon utilise des adresses mmoire0 on a deu! mo)ens de solutionner le probl3me * stac?alloc? Irappelle un peu le mallocJ qui permet dallouer de la mmoire dans la pile et 5i!ed qui empHche au garbage collector de dplacer certaines donnes du tas. Illustrons par un e!emple utilisant les pointeurs *
C#

unsa6e static void Main() { int/ varia(le ) stacOalloc intR9++S% // stacOalloc ne s4utilise que pour des arrays types valeur 6or (int i ) +% i D 9++% i--) { & /varia(le-- ) i% Console.Write ine( (int)varia(le )%

varia(le:)9++% 6or (int i ) +% i D 9++% i--) System.Console.Write ine(/varia(le--)%

c0arRS texte ) neH c0arRS {4t434a434m434t434l434e434m434o434u434s434s434e4&% 6ixed (c0ar/ pointeur ) QtexteR+S) { pointeurR=S ) 4p4% /pointeur ) pointeurR=S% 6or (int i ) +% i D) texte. engt0% i--) System.Console.Write(pointeurRiS)%

& &

System.Console.;ead<ey()%

intP est un t)pe de donne pointeur. un pointeur $er un objet de t)pe int. parle. P$ariable correspond au contenu de +est la $ariable. +est la donne G proprement $ariable correspond G ladresse mmoire de la $ariable. X$ariable correspond G ladresse mmoire de la $ariable. =tac?alloc est lqui$alent de falloca de la biblioth3que runtime +0 il a allou 99 octets et retourn un pointeur. ;erri3re on peut manipuler le pointeur comme en +. 5i!ed permet de 5aire un pointeur 5i!e0 la $ariable A pointeur B ne peut Htre modi5i ni par notre code ni par le #arage +ollector. Unsa5e d5ini des bloc?s de code0 il peut Htre mis seul a$ant un bloc? comme tr) Iunsa5eb ,PinstructionsP, cJ ou il peut sajouter au! spci5ications dun bloc? e!istant comme dans le!emple. (e code mis en A unchec?ed B Iun calcul ou un bloc?J est un peut plus per5ormant mais les rsultats peu$ent changer0 unchec?ed consiste G ne plus contrSler les dpassements de $aleurs. ;e ce 5ait le comportement est de retourner G la $aleur minimale quand on est trop grand et in$ersement. I@pplication des oprations binaire a$ec mise G lcart des retenuesJ. Par d5aut a$ec /isual =tudio tous les codes sont en unchec?ed0 de ce 5ait0 pour que ces bloc?s aient $raiment un sens0 il 5aut a$oir le contrSle de dpassement Ichec?bo! dans A projetVproprit du projetVgnrerVoptions a$ances B dans /isual =tudio ou sous Eono;e$elop dans A projetVoptionsVcon5igurationVdebugVCptions du compilateur BJ.

C#

int var% unc0ecOed { var ) int.MaxGalue% var /) 8% System.Console.Write ine(!,n! -var..oString() - !,n! - ((int)(int.MaxGalue -9))..oString())% & System.Console.;ead<ey()%
Retour Console:

:8 :89>@>X=?>X

=i $ous na$eF pas dans les options du compilateur le contrSle de dpassement de coch par contre $ous pou$eF lacti$er sur un calcul ou un bloc? a$ec le mot cle5 A chec?ed B.
C#

int a ) int.MaxGalue% int ( ) 98% ()c0ecOed(a / ()% // ce code g'n5rera ici une erreur de type Wver6loHJxeption . Console.Write ine(()%

"

Lorient @ !et en C#

".1 Introduction
+omme nous le disions dans lintroduction0 lorient objet est un mo)en de regrouper des $ariable pour pou$oir traiter des ensemble comme des entits propres. +. est un langage 5ortement orient objet. (es objets correspondants G quelque chose0 il 5aut les d5inir a$ant den utiliser. Par chance le 5rame8or? .%&' propose djG une belle liste dobjets. (a A d5inition B est appele la classe et la $ariable contenant lobjet est appeles linstance. @$ant de samuser G instancier nimporte quoi nous allons $oir comment on cre des classes simples Iqui rangent des $ariablesJ0 nous $errons ensuite comment utiliser ces classes..

".2 #sing
;ans la partie 2 $ous a$eF certainement trou$ que lon utilisait beaucoup A =)stem. B. =)stem est un %ame=pace que lon peut aussi appeler A espace de nom B. (es %ame=paces ser$ent G ranger les classes un peu comme dans des dossiers. =i lon $eut sconomiser dcrire =)stem G chaque 5ois que lon $eut accder G un objet de ce %ame=pace0 il su55it de mettre au dbut du 5ichier A using =)stem R B. +es imports despaces de nom permettent daccder directement G tous les lments contenus Iappart les %ame=paces quil contientJ sans a$oir G mentionn ou il est rang. Plus $ous 5erreF de using plus $ous aureF de propositions G lauto compltion0 dod lintrHt de limiter lusage des using car cela permet une auto compltion plus rapide et plus pertinente.

"." Instanciation
%ous allons d5inir des classes mais pour sa$oir comment on les instancie nous allons dabord regarder cette classe intgre dans le <rame8or? que nous a$ons djG utilise a$ec une instanciation simple * le =tring
C#

System.String var) neH System.String(neH c0arRS {4l434e434t434t434r434e4&)%

;composons cette instruction. %ous a$ons dans un premier temps le t)pe et le nom de la $ariable pour la dclaration. &n suite nous a$ons le mot cle5 ne80 on utilise G nou$eau le t)pe que lon appelle comme une 5onction. +ette notion de 5onction et dargument G la dclaration seront e!pliqus dans la partie 3.4.2. %ous attendons aussi un argument. ;ans cet e!emple largument est un @rra) de char0 comme on compte en mettre un qui ne!iste pas0 qui nest pas dclar0 bre5 un nou$eau comme pour le =tring on met le mot cle5 ne8 et on met de la donne. Bemar0ue : les classes anon4mes sont une nouveaut1 de CD +%E, si vous d1velo..ez sur un logiciel e/istant, il vous $audra s.1ci$ier de com.iler avec la s4nta/e CD +%E .our .ouvoir $aire ce 0ui vas suivre% =e code CD<%E com.ilera normalement en CD+%E sans modi$ications% Par5ois on doit crer une classe pour ranger des $ariables0 mais pour une utilisation locale et qui ne sortira pas de la mthode en court. ;ans ce cas il e!iste une s)nta!e de dclaration de classe prcise qui gn3re des A +lasses anon)mes B. (es classes anon)mes ont un nom de classe gnr G la $ole sans in5ormer le d$eloppeur de ce 5ait on ne peut pas spci5ier e!plicitement le t)pe de la $ariable qui $as contenir cette classe. Pour dclarer une $ariable dont on ne connait pas le t)pe0 il e!iste un mot cle5 appropri * A $ar B. (e mot cle5 A $ar B permet de laisser le compilateur t)per la $ariable G notre place. Une classe anon)me se remplie un peu comme un arra)0 e!emple *

C#

var classeanonyme ) neH { a)93 ()983 c)!texte!3 d) !quelquec0ose!&% Console.Write ine(classeanonyme.(..oString()-classeanonyme.c)%

+omme dit prcdemment0 le 5rame8or? est un ensemble de classes organises dans des espaces de noms0 pour linstant nous a$ons uniquement utilis des lments de =)stem. Me $ais $ous prsenter des objets de =)stem.+ollection.#eneric. +e %ame=pace contient de quoi 5aire des listes d)namiques et de t)pe de $otre choi!0 ce t)pe doit Htre nomm. (e t)pe des lments contenus dans la liste doit correspondre au t)pe entre les che$rons.
C#

pu(lic istDintE liste ) neH liste.1dd(98)%

istDintE()%

+e t)pe de liste $ous permet de ranger0 ajouter0 enle$er0 modi5ier0 trier et chercher les lments. /ous pourreF utiliser ces listes pour ranger des objets de mHme t)pe ou de t)pe de mHme 5orme. ;e ce 5ait pour 5aire des listes de t)pes anon)me0 bien quil ) ait des astuces0 que ce soit dcompiler les assemblies pour connaitre le nom de la classe anon)me ou autre elles sa$3rent rele$er de la bidouille et ne sont pas e!plicites G la lecture du code. ".".1 Lattri ut et le modi3icateur dacc2s Cn a d5ini le mod3le objet comme un mo)en conceptuel pour organiser des $ariables et les traiter par groupe. +ertaine $ariables internes au! objets ne requi3rent pas dinteractions depuis dautres parties applicati$es. ;es acc3s plus restreints entrainent plus de 5acilit pour reprer les erreurs0 en rduire le nombre0 une auto compltion plus pertinente0 plus de 5acilit si quelquun doit utiliser la classe et de cibler la documentation sur les $ariables0 mthodes et proprits accessibles. (es attributs dans les classes comme dans les structures doi$ent a$oir de d5ini un degr dacc3s. +es ni$eau! dacc3s sont d5inis par un de ces quatre mots cle5s* Public * donne tout lacc3s G toutes les mthodes de toutes les classes. Pri$ate * Destreint lacc3s G la classe mHme0 il sera sou$ent pr5rable dutiliser Protected. Protected * +omme Pri$ate0 la di55rence tant mince elle sera e!plique dans la partie sur lhritage. Internal * internal retire lacc3s G toutes les mthodes et tous les lments qui ne partagent pas la mHme assembl) Iqui ne 5ont pas parti du mHme 5ichier compilJ. +es modi5icateurs sont communs pour les classes0 les mthodes0 les attributs0 les accesseurs0 cest donc important G connaitre et $ous aller les croiser sou$ent Isurtout les trois premiersJ. (attribut est donc la $ariable simple dans la classe0 $ous en a$eF djG $us dans la structure. De5aisons en Partial une petite dclaration dattribut que lon $a instancier.
C# : fichier 2

using System% namespace Console1pplication { partial class Class { pu(lic int a )98% pu(lic const ulong constante ) (ulong) 98X%

&

&

C# : fichier 1

using System% using System.Collections.Veneric% namespace Console1pplication { partial class Class { & pu(lic string ( ) constante..oString()% pu(lic istDintE liste ) neH istDintE()%

static class Program { static void Main() { Class var ) neH Class()% var.liste.1dd(var.a)% var.( -) ! ! - var.listeR+S..oString()% Console.Write ine(var.()% Console.;ead<ey()% & & &

(a $ariable dclare a$ec le mot cle5 A const B doit Htre attribue dans la mHme instruction et ne pourra plus Htre modi5ie. Cn $erra dautres mo)ens qui peu$ent paraitre plus pratique pour limiter en criture les $ariables.

".% La proprit
(orsque lon a des $ariables assimiles G des objets0 elles peu$ent a$oir des contraintes autres que les contraintes in5ormatiques0 pour $iter quune $ariable en5reigne ces contraintes0 on peut en d5inir G lattribution. ;e plus0 on peut $ouloir contrSler lacc3s en lecture de certaines $ariables ou mHme les mettre dans un 5ormat plus propice que celui du 5onctionnement interne G lobjet. /oici un e!emple de code0 noteF bien les mots cle5s A get B0 A set B et A $alue B.
C#

class Class { protected uint Yvar ) + % pu(lic uint a { get { return Yvar-9% & set { i6 (value D 9++) Yvar ) value% elseYvar ) 9++% & & &

class Program { static void Main() { Class o(#et ) neH Class()% 6or (int i)+% i D 98+% i--) { o(#et.a ) i%

& & &

Console.Write ine(o(#et.a)%

Console.;ead<ey()%

@insi0 quand on appelle lattribut A a B dun objet de classe A +lass B0 en ralit on acc3de G f$ar. +e procd scurise lapplication du 5ait que f$ar soit en A protected B et du coup inaccessible par du code ne $enant pas de la classe. ;ans notre e!emple0 on empHche G la $ariable de dpasser 199 en $aleur interne0 elle pourra retourner entre 1 et 191. Cn pourrait tout G 5ait mettre plusieurs instructions dans le get Iqui correspond G lacc3s en lecture de la $ariable spcialeJ. Cn peut 5aire un accesseur a$ec seulement get ou seulement set pour la$oir en lecture seule ou criture seule. (es attributs ne sont pas 5orcment lis G une $ariable interne0 elle peut tout a 5ait manipuler plusieurs ou aucune $ariable Idans ce dernier cas lintrHt sera limit par rapport G une mthodeJ. +omparati$ement au mot cle5 A const B qui empHche toute criture0 le couple $ariable pri$e,get Isans setJ permet de modi5ier en interne les $aleurs.

".' Static
%ormalement pour accder G un attribut0 une proprit ou une mthode0 on doit 5orcment crer un objet de la classe pour pou$oir lutiliser. (e mot cle5 A static B permet da$oir des $ariables et mthodes utilisable non pas dune instance mais de la classe ellemHme
C#

class Class { static protected int Yvar ) + % static pu(lic int attri(ut { get { return Yvar-9% & set { i6 (value D 9++) Yvar ) value% else Yvar ) 9++% & & &

class Program { static void Main() { 6or (int i)+% i D 98+% i--) { & & & Class.attri(ut ) i% Console.Write ine(Class.attri(ut)%

Console.;ead<ey()%

=i je $eu! une classe qui ser$e de A boite G outils B je peu! crer des mthodes statiques qui ne ncessitent pas que la classe soit instancie. =i on dclare la classe enti3re

en statique0 cela entraine quon ne pourra pas en 5aire dinstances et quil n) aura pas de constructeur. 'ous les lments dune classe statique doi$ent Htre spci5is en statique.

Bemar0ue : =es classes stati0ues sont un mo4en sim.le de $aire un "ingleton% An singleton est un objet 0ui ne .eut Ftre instenci1 0uune seule $ois, ici la classe stati0ue ne .eut avoir 0uune instance -% ;ans le cas dune classe statique0 il 5audra utiliser pri$ate au lieu de protected0 ce sera dtaill dans la partie sur lhritage.

".4 Les mt$odes

(e mot 5onction $ous paraitrait certainement plus clair et cest pour Oa que jusquG ce point du chapitre il marri$ait de lemplo)er0 mais les 5onctions qui sont lis G des objets ont une autre appellation * ce sont des mthodes. Pour linstant nous na$ons $u que la mthode Eain qui sera trait et e!plique en premier lieu. Pour comprendre les mthodes il 5aut sa$oir quelles sont d5inies par * un degr dacc3s0 un nom0 un t)pe de retour et des t)pes et un nombre Ipou$ant Htre nulJ darguments. +ette d5inition est appele A protot)pe B ou A signature B et a une s)nta!e particuli3re. ;ans cette partie essentielle sur les mthodes0 nous allons * commencer par e!pliquer la mthode Eain0 nous allons aussi $oir comment passer des param3tres G le!cution0 comment une mthode retourne une $aleur` >re5 lessentiel de ce que lon a G comprendre sur les mthodes sera e!pliqu sur la mthode Eain que lon a beaucoup utilise sans $raiment le!pliquer. %ous $errons ensuite comment crer une mthode qui permette de gnrer proprement le contenu de la classe a$ec des arguments Iles constructeursJ. Puis nous aborderons comment proposer plusieurs A signatures B a$ec la mHme mthode Ila surchargeJ. +omment entrer une mthode e!istante dans une $ariable +omment 5aire des A mini-mthodes B pratiques en argument &t en5in nous aborderons les Itrateurs. ".4.1 Aetour sur Bain (e +. est tr3s orient objet0 du coup mHme la mthode qui se!cute au dbut du programme est range dans une classe. +omme on a djG beaucoup utilis Eain regardons-le directement pour pou$oir e!pliquer clairement les choses.
C#

class Program { static int Main(stringRS args) { 6oreac0 (string s in args) Console.Write ine(s)% Console.;ead<ey()% return +% & &

Retour Console: excut manuellement : C:\adresse\application.exe avec des arguments

avec des arguments

+omme $ous laureF remarqu0 Eain est =tatique0 cest tout bonnement car lorsque le programme se!cute0 la classe contenant Eain nest pas instancie. @ntrieurement0 Eain na$ait

pas dargument et G la place de A int B il ) a$ait le mot $oid. (e t)pe spcial $oid que nous utilisions sert G dire que la mthode ne retourne rien. $oid est lallias de =)stem./oid0 il nest utilis que pour mentionner que la mthode ne retourne pas de $aleur et en unsa5e pour 5aire pointeur $ers donnes de t)pe inconnu. ;e ce 5ait0 dans cet e!emple0 Eain retourne une $aleur * 9. (e mot cle5 return met 5in G la mthode et lui 5ait retourner la $aleur qui suit. <aire retourner une $aleur de t)pe int G un programme sert G spci5ier un code derreur. Par con$ention0 le 9 signi5ie que tout cest bien drouler0 ensuite on peut crer plein de $aleur de retour pour signaler les di55rentes erreurs possibles. Usuellement0 il est publi a$ec le logiciel une correspondance entre la $aleur de retour en cas derreur et les erreurs elles mHmes. +ontrairement au +0 une mthode de$ant retourner une $aleur sans mot cle5 return ne passe pas la compilation0 de ce 5ait une mthode qui a un t)pe de retour autre que $oid 5inira s)stmatiquement par un return. Par5ois pour les procdures0 il peut Htre plus pratique de 5aire un return true quand il n) a pas de probl3me et 5alse G la place de le$er une e!ception0 on mettra bool pour le t)pe de retour. Eain a =ignatures possibles *
C#

pu(lic pu(lic pu(lic pu(lic

static static static static

int void int void

Main() Main() Main(stringRS Main(stringRS arg) arg)

(@rra) de string est compos de lensemble des chaines qui sui$ent la commande en sparant par des espaces. ".4.2 Constructeur . destructeur /ous trou$ereF sou$ent dans les classes non statiques des mthodes dites gconstructeursh. +e sont des mthodes qui ser$ent G mettre des $aleurs par d5aut0 G crer des lments` =i on $oulait par e!emple 5aire une classe qui range un jeu dallumette proche de celui que lon a 5ait antrieurement *
C#

using System% class Neu { readonly pu(lic int n(re"atonets%// readonly ) varia(le ne peut Ltre acc'd'e readonly pu(lic int n(reNoueurs%// en 'criture que dans le constructeur. protected int #oueur% protected int tour% protected int (atonets% pu(lic noms% pu(lic stringRS static uint n(reDZnstances% //////////////////////////////////////////////////// / Goici le Constructeur3 cFest une m't0ode sp'ciale sans type de retour / et qui porte le mLme nom que la classe. / Wn initialise ici les varia(le de Neu propre aux [ options \ //////////////////////////////////////////////////// pu(lic Neu(int n(re"nts3 int n(reNrs3params stringRS noms) { n(reDZnstances--% n(reNoueurs ) n(reNrs% n(re"atonets ) n(re"nts% t0is.noms ) noms% t0is.initVame()%

&

// $$ e proc0ain extrait de code sera 2 a#outer ici $$ // pu(lic void initVame() //Cette m't0ode permet dFinitialiser une nouvelle partie

{ #oueur ) +% tour ) +% (atonets ) n(re"atonets%

&

pu(lic (ool .our() //ex'cute un tour et renvoie 6aux si d'6aite. { int tmp% tour--% i6 (#oueur D n(reNoueurs:9) #oueur --% else #oueur ) +% System.Console.Write ine(!.our !-tour..oString())% System.Console.Write ine(!1 ! - nomsR#oueurS - !,nil reste ! - (atonets..oString() - ! alumettes,npreneK un nom(re d4allumettes entre 9 et = (de6aut =)!)% int..ryParse(System.Console.;ead ine()3out tmp)% i6 (tmp E + QQ tmp D =) (atonets :) tmp% else (atonets :) =% i6 ((atonets D 9) return 6alse% return true%

&

// a m't0ode Perdu sera remplac'e dans la partie sur la red'6inition pu(lic string Perdu() { & return nomsR#oueurS-! a perdu au (out de ! -tour..oString()-! .ours.!%

]Neu() { n(reDZnstances::% & &

class Program { static void Main() { Neu #eu ) neH Neu(9*383!Crovax!3!Popi!)% H0ile (#eu..our())% // ex'cutera le test #usquF2 ce quFil retourne 6aux Console.Write ine(#eu.Perdu())% // 6or (int i )+ % i D 9++++% i--) { Console.Write ine(Neu.n(reDZnstances)% #eu ) neH Neu(i3 i3 neH stringRS { !#oueur9!3 !#oueur8! &)% System..0reading..0read.Sleep(9+)% & // Console.;ead<ey()% & &

Remarque : 9oil un e/trait de code susce.tible d1claircir lint1rFt du mot cle$ static% "i vous d1G commentez la boucle $or et essa4ez .lusieurs $ois en modi$iant 0uel0ues valeurs, vous .ourrez constater le $onctionnement du garbage collector%0uand le garbage collector veut e$$acer un objet il a..elle de destructeur .uis su..rime les donn1es de linstance 0ui ne lont .as 1t1% Un mot cle5 important na pas t abord * this. Il est ici emplo) pour $iter un con5lit de noms. A this B correspond G linstance en cours de traitement donc this.noms correspond G la proprit public quand noms seul correspond G la $aleur pass en argument de la mthode. (e mot cle5 params est utilis ici dans le constructeur mais est optionnel et peut Htre utilise pour nimporte quelle mthode. Il est utilis pour le dernier argument0 il est sui$i dun t)pe arra) et

dun nom de $ariable IA noms BJ. 'ous les derniers arguments G lappel de la mthode de$ront Htre des strings et rentrerons dans larra). =ans le mot cle5 A params B0 linstanciation de la classe A Meu B naurait pas tait comme $u dans le!trait IA Neu #eu ) neH Neu(9*383!Crovax!3!Popi!)R BJ mais a$ec un $ritable arra) en argument IA Neu #eu )
neH Neu(9*383neH stringRS {!Crovax!3!Popi!&)R

BJ. Params accepte aussi la s)nta!e a$ec arra) en argument.

%ous utilisons le mot cle5 A out B dans la mthode statique A 'r)Parse B dInt320 ce mot cle5 apparait pour dire que largument passe par r5rence. +aest-G-dire que la $ariable pourra Htre modi5ie dans la mthode0 car les t)pes A $aleurs B ne sont jamais modi5ies quand ils sont passs en argument sans mots cle5s spci5iant le contraire. Un mot cle5 tr3s proche de out e!iste * re5. (a seule di55rence est que lon utilise out pour une mthode qui $as donner une $aleur sans tenir compte de lactuelle tant disque re5 sera plus utilis pour traiter une $ariable 5aire en sorte quelle ait une nou$elle $aleur G partir de sa $aleur actuelle. ;e ce 5ait0 re5 attend une $ariable a)ant une $aleur attribue tandis que out une $ariable dclare mHme sans attributions 5era la55aire. ;e ce 5ait on nest oblig de passer des $ariable et non pas des $aleurs pour que la mthode puisse mettre ses donnes quelque part. 'r)Parse proc3de comme Parse sau5 quil entre 9 dans la $ariable au lieu de gnrer des erreurs. (es mots cle5s param0 re5 et out paraissent dans les protot)pes,signature des mthodes qui les utilisent. (e ;estructeur na ni de t)pe de retour ni de degrs dacc3s ni darguments. =on nom est celui de la classe et est prcd dun tilde A i B. ".4." La surc$arge /ous trou$eF peut Htre quil nest pas pratique de ne pas pou$oir 5aire un objet par d5aut0 da$oir G spci5ier G chaque 5ois tous les arguments` Pour pou$oir a$oir le choi! entre plusieurs possibilit darguments en entre il e!iste la surcharge des mthodes. %ous allons procder G la surcharge du constructeur. (a surcharge dune mthode permet de changer la signature en gardant le mHme nom. Une surcharge permet de changer les param3tres et le t)pe de retour. (a surcharge peut aussi sappliquer G un oprateur comme le A P B0 le A , B0 il su55it de prcder loprateur du mot cle5 operator. ;u 5ait que ce soit $ous qui d5inissieF le!cution $ous pou$eF lutiliser a$ec la s)nta!e et la priorit des oprateurs sans pour autan bien que ce soit recommand 5aire une e!cution qui correspond G une addition ou qui retourne une $aleur. Cn peut aussi surcharger loprateur unaire de cast0 il ) a deu! t)pes de d5inition de cast * implicit et e!plicit. (a surcharge peut Htre dclare dans la classe dinstance source pour aller $ers un t)pe cible ou dans la classe cible source de t)pe quelconque et retourne un objet de classe. Pour amliorer la lisibilit du code il est encourag dutiliser e!plicit dont le comportement est plus pr$isible.
C#

class Neu { ^ pu(lic Neu() { n(reDZnstances--% n(reNoueurs ) 8% n(re"atonets ) 9*% t0is.noms ) neH stringRS {!Crovax!3!Popi!&% t0is.initVame()%

&

pu(lic static Neu operator-(Neu un3Neu deux)

{ stringRS noms)neH stringRun.noms. engt0-deux.noms. engt0S% int p )+% 6or (int i)+ % iDun.noms. engt0%i--) nomsRp--S)un.nomsRiS% 6or (int i)+ % iDdeux.noms. engt0%i--) nomsRp--S)deux.nomsRiS% return neH Neu(un.n(re"atonets - deux.n(re"atonets 3 un.n(reNoueurs - deux.n(reNoueurs3 noms)%

&

pu(lic static Neu operator: (Neu (3int a) { & return neH Neu((.n(re"atonets : a3 (.n(reNoueurs3 (.noms)%

pu(lic static implicit operator int(Neu a){return a.n(reNoueurs%& pu(lic static explicit operator Neu(int a){return neH Neu(a383!Pop!3 !Crov!)%& & // ( ;emettre initVame3 .our3 Perdu et ]Neu de lFexemple pr'c'dent ) ^ class Program { static void Main() { int c% Neu #eu ) neH Neu()% Neu a ) #eu - neH Neu(8*3 =3 !;iri!3 !Ai6i!3 !<nig0t H0o say CZ$!)% a ) a : 98% c ) a% a -) (Neu)c% H0ile (a..our())% Console.Write ine(a.Perdu())% Console.;ead<ey()% & &

@insi implment0 laddition permet de crer un jeu a)ant les joueurs en commun0 le nombre de bLtonnets initial additionn Idu 5ait quils soient en readonl) je suis oblig de recrer une instanceJ. Cn peut songer par e!emple dans une $entuelle $olution du jeu en rseau 5usionner les salles de jeu! par un simple oprateur -0 a$ec ce mHme oprateur en cast implicite $ers un int connaitre le nombre de joueurs dans les instances dun ser$eur. Cn pourrait aussi G partir de loption A nbre>atonets B gnrer en un cast une instance approprie par d5aut. ".4.% 8elegate (e delegate est comme un pointeur de 5onction0 caest-G-dire une $ariable qui indique une 5onction pou$ant sutiliser comme telle. +e principe permet de passer une mthode en argument et aussi de pou$oir modi5ier le!cution sui$ant ltat djune $ariable delegate. Cn commence par gnrer un t)pe de dlgu0 puis ou peut dclarer des dlgus a$ec un degr dacc3s in5erieur ou gal G celui du t)pe. (e t)pe de dlgu correspond G une signature0 un t)pe dlgu indique les t)pes des arguments et le t)pe de retour de la mthode que le dlgu associ $a contenir. (intrHt de crer des t)pes de dlgus est a$ant tout de scuriser le code et de sa$oir comment utiliser le dlgu. ;e plus si on entre dans un dlgu une mthode qui a plusieurs surcharges0 linterprteur dduira la quelle prendre pour que les signatures entre la surcharge et le t)pe de dlgu correspondent. (e!emple ici montre plus un e!emple dutilisation que lutilit relle des dlgus0 mais dautres e!emples pourront $ous clairer sur lutilit d3s la partie prochaine.
C#

using System% class testDelegate { pu(lic delegate int typeDeDelegue(re6 int a)%//D'claration 7 type de d'l'gu' //les m't0odes associ'es devront r'pondre 2 sa signature 7 int nom(re6 int var) pu(lic static int incrementer(re6 int Com(re) { & & return --Com(re%

class Program { static void Main() { int Galeur ) +% //ci dessous on d'clare une instance du d'l'gu' testDelegate.typeDeDelegue a ) testDelegate.incrementer% // le d'l'gu' sans parent05se correspond 2 la varia(le // la m't0ode sans parent05se correspond 2 l4adresse H0ile (a(re6 Galeur) D 9++) % // avec parent05ses la m't0ode est ex'cut'e. Console.Write ine(Galeur)% Console.;ead<ey()% & &

(es t)pes de dlgus sont accessibles comme des lments statiques. ;ans cet e!emple simple nous a$ons utilis a comme un pointeur $er la mthode incrmenter. %ous pou$ons aussi utiliser des dlgus en param3tres0 nous $errons cela dans la partie qui suit. %oteF le point $irgule apr3s le 8hile * seule la condition sera e!cute jusquG Htre 5ausse. ".4.' Les )nements (es $3nements 5ont parti dun t)pe de programmation G part enti3re0 on parle de programmation $3nementielle qui soppose partiellement G la programmation procdurale. (a programmation $nementielle consiste G ragir en 5onction des $3nements. (es applications G inter5aces graphiques sont sou$ent associes au! concepts de programmation $nementielle. Par e!emple0 un utilisateur qui clique sur un des boutons de linter5ace lance une procdure. (e 5ait que lutilisateur puisse G tout moment agir sur nimporte quel bouton entend que ce nest pas une procdure G $ariable qui se droule de mani3re uni5orme. +est bien agir en 5onction des interactions. ;ans nos e!emples nous allons utiliser sans quitter notre console les $3nements pour $oir leur 5onctionnement.
C#

t0is.(utton9 ) neH System.WindoHs.Aorms."utton() t0is.(utton9.ClicO -) neH System.Jvent_andler(t0is.(utton9YClicO)%

(es $3nements sont des dlgus $oire des listes de dlgus qui sappellent G peut prHt comme de simples mthodes. ;ans le!trait gnr de :in<orm ci-dessus nous $o)ons que le bouton a par d5aut un $3nement e!istant. (e plus sou$ent ce t)pe de dlgu sera celui du 5rame8or? * &$ent_andler I%ous $errons quelle signature correspond G ce t)pe de dlguJ. ($3nement ntant pas une notion tr3s simple G intgrer jai propos deu! e!emples. (es $3nements se dclarent a$ec le mot cle5 A e$ent B et un t)pe de dlgu. Un $3nement ne peut Htre e!cut que depuis la classe il est dclar mais peut Htre modi5i depuis une autre sil est public.
C#

using System% class exemple9 { // Jvent_andler est un d'l'gu' de mLme signature que celui:ci:dessous. // pu(lic delegate void elem(o(#ect sender3Jvent1rgs e) % // pu(lic event elem evenement% pu(lic event Jvent_andler evenement% pu(lic void addYevenement(int i) { // evenement(t0is3 Jvent1rgs.Jmpty)% (l5ve une exception si aucune m't0ode assici'es) sHitc0 (i) { case 97 evenement-)neH Jvent_andler(exempleYevenement9)% (reaO% case 87 evenement -) neH Jvent_andler(exempleYevenement8)% (reaO% case =7 evenement -) neH Jvent_andler(exempleYevenement9)% evenement -) neH Jvent_andler(exempleYevenement8)% (reaO% de6ault7 evenement :) neH Jvent_andler(exempleYevenement9)% (reaO% & & pu(lic void execute() {evenement(t0is3 Jvent1rgs.Jmpty)%& pu(lic static void exempleYevenement9(o(#ect sender3 Jvent1rgs e) {Console.Write ine(!execution de la m't0ode 9!)%& pu(lic static void exempleYevenement8(o(#ect sender3 Jvent1rgs e) & {Console.Write ine(!execution de la m't0ode 8!)%&

class Program { static void Main() { exemple9 a ) neH exemple9()% 6or (int i)9% i D ?% i--) { Console.Write ine(i..oString() - ! a.addYevenement(i)% a.execute()% ,n!)%

& & &

System.Console.;ead<ey()%

;ans notre premier e!emple l$3nement est utilis de mani3re tr3s procdurale. ;ans le deu!i3me e!emple bien que ce ne soit pas $ident en console nous allons montrer quelque chose de plus A $3nementiel B0 nous allons loguer ltat dune $ariable.
C#

using System% class exemple8 { pu(lic delegate void evenement_andler(exemple8 sender3 Jvent1rgs e)% pu(lic event evenement_andler lit%

pu(lic event evenement_andler ecrit% protected string Yloga(le% pu(lic string oga(le { get { i6(lit $) null)lit(t0is3Jvent1rgs.Jmpty)% return Yloga(le% & set {

Yloga(le)value% i6 (ecrit $) null) ecrit(t0is3 Jvent1rgs.Jmpty)%

&

&

pu(lic (ool sHitc0 og() { i6 { (lit )) null QQ ecrit )) null) lit ) neH evenement_andler(acces ecture)% ecrit ) neH evenement_andler(accesJcriture)% return true%

&

&

lit ) null% ecrit ) null% return 6alse%

pu(lic static void acces ecture(exemple8 sender3 Jvent1rgs e) { & Console.Write ine(!1cc5s en lecture7! sender.Yloga(le)%

pu(lic static void accesJcriture(exemple8 sender3 Jvent1rgs e) { Console.Write ine(!1cc5s en ecriture7! - sender.Yloga(le)% & &

class Program { static void Main() { exemple8 ( ) neH exemple8()% (.sHitc0 og()% (. oga(le ) !test!% (. oga(le ) (. oga(le% Console.Write ine((. oga(le)% (.sHitc0 og()% (. oga(le ) !sans log c4est moins ver(eux!% (. oga(le ) (. oga(le% Console.Write ine((. oga(le)% System.Console.;ead<ey()% & &

(e terminal nest pas la plus adapt des inter5aces pour parler d$3nements mais jesp3re que ces e!emples $ous su55iront pour $ous approprier les notions d$3nements qui seront utiliss dans de $rais programmes .%&'. ".4.4 Bt$odes anon-mes et +&pressions lam da (es mthodes anon)mes 5ait partie des nou$eauts du +.2.9. +et outil permet de crer une mthode point par un dlgu sans a$oir G la mettre dans une classe * (utilisation est simple *
C#

using System%

class testDelegate { pu(lic delegate void Co1rg ()% pu(lic delegate void 1rgDelegate(Co1rg a)% pu(lic void executer9+Aois(Co1rg 6onction) { & 6or(int i)+%iD9+%i--) 6onction()%

pu(lic void executer9+Aois(1rgDelegate 6onction3Co1rg argument) { 6or (int i ) +% i D 9+% i--) 6onction(argument)% & & class Program { static void Main() { testDelegate var ) neH testDelegate()% testDelegate.Co1rg a66ic0e1 ) delegate() { Console.Write(!a!)% &% var.executer9+Aois(a66ic0e1)% Console.Write ine(!,n ,n!)% testDelegate.1rgDelegate a ) var.executer9+Aois% // var.executer9+Aois(a3a66ic0e1) % ou plus instructi6 7 var.executer9+Aois ( delegate(testDelegate.Co1rg 6onction){6or(int i)+%iD9+%i--) 6onction()%&3 delegate() { Console.Write(!a!)% & )% Console.;ead<ey()% & &

/oici un e!emple asseF simple et tordu G la 5ois0 il nous montre une partie du potentiel des dlgus quels quils soient. %oteF que les dlgus anon)mes sont t)ps automatiquement pour entrer dans la $ariable ou en argument. /ous pou$eF 5acilement imaginer une attribution conditionnelle dans la quelle le 5ormatage dpendra de la mthode point par la $ariable dlgue. Bemar0ue : la .artie 0ui suit sur le/.ression lambda et les m1thodes de/tension est com.os1e essentiellement de nouveaut1s du CD +%E, si vous d1velo..ez sur un logiciel e/istant, il vous $audra s.1ci$ier de com.iler avec la s4nta/e CD +%E 0ui est r1tro com.atible .our .ouvoir $aire ce 0ui vas suivre% (es e!pressions lambda sont des dlgus anon)mes limits G une instruction0 la s)nta!e est claire0 rapide et lisible mais on ne peut mettre de boucles. =i le t)pe de dlgu attendu a un t)pe de retour0 la seule A instruction B de le!pression lambda sera retourne. (a s)nta!e de le!pression lambda est simple * les param3tres du dlgu anon)me0 le signe A WV B puis linstruction.
C#

(int arg93 int arg8) )E arg9- arg8 //delegate(int arg93int arg8){return arg9-arg8%& arg )E arg - > // delegate(int arg){return arg->%& // e type du param5tre pr'c'dent d'pend du type // d'l'gu' attendu (donc pas 6orc'ment int) () )E Console.Write(!a!) // delegate(){Console.Write(!a!)%&

/oici trois e!emples hors conte!te. =i on ne spci5ie pas le t)pe il est spci5i automatiquement et sil ) a un seul param3tre t)p implicitement pas besoin des parenth3ses pour lisoler. De5aisons la mHme chose que tout G lheure a$ec ces lambda e!pressions.

C#

using System% class testDelegate { pu(lic delegate void Co1rg ()% pu(lic delegate void 1rgDelegate(Co1rg a)% //ici on d'clare une instance du d'l'gu' pu(lic void executer9+Aois(Co1rg 6onction) { & 6or(int i)+%iD9+%i--) 6onction()%

pu(lic void executer9+Aois(1rgDelegate 6onction3Co1rg argument) { 6or (int i ) +% i D 9+% i--) 6onction(argument)% & & class Program { static void Main() { testDelegate var ) neH testDelegate()% testDelegate.1rgDelegate a ) var.executer9+Aois% var.executer9+Aois ( //(testDelegate.Co1rg 6onction) )E a(6onction)3 6onction )E a(6onction) 3 () )E Console.Write(!a!)

)% & &

Console.;ead<ey()%

%ous a$ons lessentiel les mthodes et les dlgus0 nous allons dsormais $oir comment on peut lier $u nos mthodes sur G des objets du 5rame8or?.

".4.=

Bt$ode de&tension. (es mthodes de!tensions sont des mthodes statiques qui permettent de sutiliser comme si elles taient propre G une classe autre que celle dans la quelle elle est d5inie. Me me!plique0 si $ous $ouleF 5aire une mthode de traitement de string0 $ous nalleF pas pou$oir modi5ier la classe string du 5rame8or? pour ajouter une mthode de traitement0 donc $ous alleF de$oir crer une classe a$ec une mthode statique puis 5aire appel G cette classe pour le traitement. (a mthode de!tension permet dappliquer la mthode statique comme si elle tait dans la classe. Par e!emple ci dessous on cre une mthode qui permet de na$oir G crire que $ar.:riteIJ a$ec $ar $ariable de t)pe string au lieu de 5aire +onsole.:rite(ineI$arJ.
C#

using System% static class String.ool"ox { static int titleZndex ) +% pu(lic static void Write(t0is string s) { & Console.Write ine(s)%

pu(lic static string titleAormat(t0is string s3int i) { return !,n! - !Y! - (--titleZndex)..oString() - !Y! s..o`pper() - !Y! - i..oString() - !Y! - !,n! % &

& class Program { static void Main() { 6or(int i)+%iD9+%i--) (!(on#our !-!Monsieur!).titleAormat(i).Write()% Console.;ead<ey()% & &

(e mot cle5 qui sert G spci5ier que la mthode est une mthode de!tension est le mot cle5 this0 on mettra toujours ce this a$ec le premier argument Iqui est lobjet qui prc3de le point lors de lappelJ. ".4.C Itrateurs +ertaines mthodes sont appeles des itrateurs0 elles utilisent le mot cle5 )ield. +es mthodes retournent des objets I&numerable ou I&numerator I%ous pri$ilgierons I&numerable qui peut Htre utilise dans un 5oreachJ. %ous allons $oir comment 5aire a$ec et sans le 5oreach pour que $ous puissieF comprendre comment sont les objets que nous utilisions. I&numerable et I&numerator ne contiennent pas le rsultat mais le mo)en d) accder0 pour preu$e0 le!emple modi5iera le rsultat apr3s la dclaration de lnumrable et le parcourra deu! 5ois a$ec deu! rsultats di55rents.
C#

using System% using System.Collections% static class String." { pu(lic static int Z ) +% pu(lic static void Write(t0is string s) { & Console.Write ine(s)%

pu(lic static ZJnumera(le titleAormat(t0is string s3 int limit) { 6or (int i )9%iD)limit%i--) yield return !,n!-!Y!-i..oString()-!Y!-s..o`pper() -!Y!-(--Z)..oString()-!Y!-!,n!% yield (reaO% & &

class Program { static void Main() { ZJnumera(le ) !(on#our Monsieur!.titleAormat(9++)% // on a cr''enumera(le l4'num'ra(le avec titleAormat ZJnumerator enumerateur ) enumera(le.VetJnumerator()% // on extrait l4'num'rateur String.".Z ) *% // proc5de 2 unen4as modi6ication qui c0angera le r'sultat // on conclusion rien encore 't' calcul'. 6or (int i ) +% i D 9++% i--) { // si on ne commenaait pas par un MoveCext le premier r'sultat serait !null! enumerateur.MoveCext()%

string s ) as string BB !erreur!% // caste enenumerateur.Current string (si impossi(les contiendra !erreur!) String.".Z ) String.".Z b 9+ )) + B String.".Z / 87String.".Z% // 8 toutes les 9+ it'rations // multiplie conclusionpar 7 les strings sont calcul's auZ6ur et 2 mesure & s.Write()%

String.".Z ) +% Console.;ead<ey()% // parcour avec 6oreac07 6oreac0 (string s in enumera(le) s.Write()% Console.;ead<ey()% & &

kield est un mot cle5 qui est central dans le linq bien que relati$ement cach0 cette technologie $ous permet de jouer a$ec des numrables0 de les imbriqus a$ec une 5acilit tonnante0 et bien- sur G lacc3s en lecture0 Oa e!cute le ncessaire pour accder G la donne. kield nest utilisable qua$ec un des deu! mots cle5s qui suit * Deturn et >rea?. kield return ajoute une entre dans lnumrateur et )ield brea? arrHte le!cution du bloc?. kield brea? emplo) dans notre e!emple0 il ne sert G rien.

".= L$ritage1 le pol-morp$isme et les inter3aces

".=.1 Introduction (hritage est un mo)en do55rir au! classes toutes les mthodes et tous les attributs public et protected dune classe e!istante. +ontrairement au +--0 le +. ne permet pas dhriter de plusieurs classes bien que les inter5aces permettent de 5aire un qui$alent. (hritage conduit G des similitudes entre les objets et donc de la simplicit pour apprendre. %ous ne la$ions pas $u mais tous les objets hritent de lobjet A object B. Cbject est la classe G la base de tout0 cest object qui implmente la mthode 'o=tring que lon a beaucoup utilis. +ette mthode tant de la classe m3re A uni$erselle B0 elle est implmente par d5aut par toutes les classes. (e pol)morphisme dans le 5rame8or? est un outil pratique qui permet par e!emple de ranger dans une liste t)pe des objets de classes di55rentes pour peu quils se comportent pareil. 'ous les objets peu$ent Htres appels comme des objets dun de leurs t)pes parents. ;e ce 5ait toutes $ariables quelque soient leur t)pe peu$ent Htre utilis comme des $ariable de t)pe object. 'oute $ariable peut Htre passe en argument dune mthode qui attend un objet de t)pe A object B. (es inter5aces sont des esp3ces de classes qui ne ser$ent quG Htre A hrites B Idans le cas dune inter5ace0 on dit quelle est A implmente BJ. Quand on implmente une inter5ace on garanti un comportement0 si on implmente par e!emple linter5ace I&numerable0 notre objet pourra bn5icier de linq et Htre numr dans un 5oreach. ;ans le!emple prcdant on utilisait I&numerable et I&numerator comme les t)pes des $ariables mais cest juste grLce au 5ait que le pol)morphisme marche a$ec les inter5aces en plus des classes m3res. ;e ce 5ait peut importe le t)pe de retour qui entrera la donne dans ma $ariable d3s lors que ce t)pe implmente linter5ace I&numerable car ce retour aura 5orcment le comportement attendu. (orient objet initie des nou$eau! mots-cle5s de restriction de droits0 commenOons par re!pliquer les mots que nous connaissons djG dans ce conte!te dhritage * public * (es lments public dune classe sont lgus au! classes en5antes. protected * (es lments protected dune classe sont lgus au! classes en5antes.

pri$ate * (es lments pri$ate dune classe ne sont pas hrit au! classes en5antes. static * Cn ne peut pas 5aire hriter une classe spci5ie en static. (es lments statiques dune classe non statique qui sont en public ou protected peu$ent Htres accds par les classes en5ante mais ne sont pas G proprement parl hrites. (e mot cle5 A base B permet daccder au! lments de la classe m3re sans se soucier de son nom Isutilise comme A this BJ. +omme les classes statiques ne peu$ent hriter il est $u comme un non sens que de spci5ier des lments en protected0 de ce 5ait on utilisera public ou pri$ate.

/oici une liste de quelques nou$eau! mots cle5s initis par la notion dhritage* sealed * @ucune classe de peut hriter dune classe dune mthode ou dune proprit sealed Isi on $eut quun lment soit public sans que les classes 5illes en hrite par e!empleJ. abstract * (es classes abstraites ne sont pas utilisables directement0 elles ne ser$ent que de classes m3re pour 5aciliter et regrouper la construction dobjets de mHme 5orme. (es lments abstraits dune classe eu! doi$ent Htre d5ini0 ils sont comme des contraintes de mthodes et $ariable interne G d5inir. IUne classe abstract ne peut Htre instanciJ $irtual * $irtual est 5onctionnellement comme abstract G une di55rence prHt * dans la classe m3re il ) a une implmentation par d5aut que lon peut ne pas red5inir. (e 5rame8or? utilise beaucoup lhritage et ce mod3le de pol)morphisme0 nous allons re$enir sur les e!ceptions qui hritent toutes de la classe e!ception qui elle mHme hrite de Cbject. ".=.2 +&emples d$ritage : les e&ceptions et t$ro6 +et e!emple est G coupl a$ec celui de la partie 2.". ;ans ce deu!i3me e!emple je cre un nou$eau t)pe de!ception dont je ne red5ini que le +onstructeur. +e t)pe de!ception a les mHmes attributs et les mHmes proprits que le!ception par de5ault au dtail prHt quil na quun constructeur. Pour d5inir les $ariables comme dans une e!ception standard simplement0 jajoute G mon constructeur le constructeur de la classe &!ception.
C#

using System% class MonJxception 7 Jxception { pu(lic MonJxception() 7 (ase(! e pro(l5me est de type custom!) { Console.Write ine(!Jrreur sp'ciale avec mon ex'cution!)% & & class Program { pu(lic static void Main() { ;andom r ) neH ;andom(Date.ime.CoH.Millisecond)% H0ile (true) { i6 { (9 E) r.Cext(+39++++++++)) MonJxception e ) neH MonJxception()% try { & t0roH e%

catc0 (MonJxception except)

{ & Console.Write ine(except..oString())% 6inally { e ) null% & & & & &

(a nou$elle classe est instancie et le$e comme nimporte quelle e!ception. (e mot cle5 thro8 permet de le$er une instance de!ception0 il sera plus commun de $oir A thro8 ne8 Eon&!ceptionIJ R B mais ctait pour justi5ier lusage dun bloc? 5inall) pour la ds-allocation de mmoire. ;ans le!emple de la partie 2." on perOoit plus nettement le pol)morphisme mais nous aurons loccasion d) re$enir. ".=." Aed3inition de mt$odes et dattri uts (e constructeur est une red5inition particuli3re $u que le nom nest pas le mHme mais pour les classes ou les lments abstract on se $erra oblig de red5inir des lments qui e!istent djG ce qui normalement est impossible. %ous allons utiliser deu! mots cle5s tr3s similaires dans ce conte!te * o$erride et ne8.
C#

using System% a(stract class mere { pu(lic pu(lic pu(lic pu(lic a(stract int longueur { get%& a(stract int largeur { get% set% & virtual int aire() { return longueur/largeur%& virtual void print1ire() { Console.Write ine(longueur/largeur)% &

&

class 6ille 7 mere { private private int int la% lo% pu(lic override int largeur { & get { return la% & set { la ) value% &

pu(lic override int longueur { & get { return lo% &

pu(lic 6ille() { & la ) ?% lo ) *%

pu(lic neH int aire() {return (largeur-longueur)/8%& pu(lic override void print1ire() { & Console.Write ine((largeur - longueur) / 8)% // (ase.print1ire()%

pu(lic override string .oString() {

return !on peut d'6inir comment r'agi la m't0ode ..oString comme ceci! % & & class Program { pu(lic static void Main() { mere m ) neH 6ille()% 6ille 6 ) neH 6ille()% Console.Write ine(!a66ic0age cast' en m5re puis en 6ille (override)!)% m.print1ire()% 6.print1ire()% Console.Write ine(!retour d4aire cast' en m5re et en 6ille (neH)!)% Console.Write ine(m.aire() - !,n! - 6.aire())% Console.;ead<ey()% & &

Retour Console:

a66ic0age cast' en m5re puis en 6ille (override) 88 88 retour d4aire cast' en m5re et en 6ille (neH) =+ 88

;ans cet e!emple on a une classe abstraite m3re et une classe 5ille. Quand $ous tenteF dimplmenter une proprit ou une mthode0 $ous $erreF que $otre I;& I/isual =tudio ou Eono;e$elopJ $ous propose directement la structure de base. (a s)nta!e des proprits de la classe m3re est encore une nou$eaut du +.3.90 on d5inie ce qui sera G implmenter. (a ligne commente montre comment jaurais pu par e!emple appeler la mthode par d5aut implmente par la classe m3re. (e!emple risque dHtre un bon complment de!plication sur la di55rence entre la red5inition a$ec o$erride et la red5inition a$ec ne8. %e8 * permet de crer une mthode propre G la classe 5ille qui sera appele normalement sur une instance de cette classe 5ille. =i linstance de la classe 5ille est range dans une $ariable de t)pe de la classe m3re si la mthode homon)me est appele ce sera la mthode par d5aut de la classe m3re qui sera appele et non celle de la classe 5ille. C$erride * permet quand G lui de remplacer rellement la mthode de la classe m3re pour linstance de la classe 5ille quelque soit le conte!te. ".=.% Les inter3aces (es inter5aces sutilisent comme des classes abstraites0 on peut les implmentes comme on hriterait dune classe. Cn d5ini dans linter5ace des mthodes et proprits G a$oir pour implmenter linter5ace pour pou$oir bn5icier du pol)morphisme li. =i on caste lobjet a$ec linter5ace0 seules les mthodes qui rel3$ent de linter5ace seront accessibles. +est donc une 5orme dhritage multiple. =i lon repense au! mthodes de!tensions0 je $ous laisse comprendre lintrHt du pol)morphisme0 pou$oir rduire le code et ne pas a$oir G le re5aire pour chaque classe. +ertaines inter5ace comme I&numerable sont au cQur du 5rame8or?0 cette inter5ace doit Htre implmente que ce soit pour utiliser le mot cle5 )ield0 pour pou$oir utiliser 5oreach0 pour pou$oir utiliser (inq2object` (es mthodes des inter5aces peu$ent Htres implmentes de deu! 5aOons * implicitement ou e!plicitement. (es inter5aces on toujours tous leurs attributs publics0 cest pourquoi le degr dacc3s

nest pas demand dans la dclaration de linter5ace. Cn ne peut pas 5aire de mthode $irtual0 les inter5aces tablissent une structure G respecter
C#

using System% inter6ace Zmere { int longueur { get%& int largeur { get% set% & void aire()% void print1ire()%

&

class 6ille 7 Zmere { private int la% private int lo% pu(lic 6ille() {la ) ?%lo ) *%& Pregion Zmere Mem(res // impl'ment'e explicitement int Zmere.longueur { get { return lo% && // impl'ment'e implicitement pu(lic int largeur { get la% &&& set { { return la ) value% // impl'ment'e explicitement void Zmere.aire() {Console.Write ine((largeur- ((Zmere)t0is).longueur)/8)%& //Zmpl'ment' implicitement pu(lic void print1ire() {Console.Write ine((largeur - ((Zmere)t0is).longueur) / 8)%& & Pendregion

class Program { pu(lic static void Main() { Zmere m8 ) neH 6ille()% 6ille 68 ) neH 6ille()% Console.Write ine(!a66ic0age cast' en inter6ace puis en 6ille (implicit)!)% m8.print1ire()% 68.print1ire()% Zmere m ) neH 6ille()% 6ille 6 ) neH 6ille()% Console.Write ine(!retour d4aire cast' en Zm5re et en 6ille (explicit)!)% m.aire()% ///////////////////////////////////////////////////////////////////// / la ligne qui suit ce commentaire ne passe pas la compilation. / Jrreur 97 / 46ille4 ne contient pas une d'6inition pour 4aire4 et aucune m't0ode d4extension / 4aire4 acceptant un premier argument de type 46ille4 n4a 't' trouv'e / (une directive using ou une r'6'rence d4assem(ly est:elle manquante B) ///////////////////////////////////////////////////////////////////// // 6.aire()% Console.Write ine(!erreur,n,nutilisons une liste maintenant!)% ZmereRS list ) neH ZmereRS { 63 m3 m83 68 &% 6oreac0 (var e in list)

&

&

e.aire()% Console.;ead<ey()%

".=.' Les attri uts (es attributs sont des classes hritant de attribut0 leurs usage sert G modi5ier le comportement dlments Iclasses0 enums0 structs0 mthodesJ. (es attributs ont une s)nta!e particuli3re utilisant les crochets IA l m BJ. Un e!emple pratique ou les attributs sont utiliss cest la srialisation. (usage dun simple attribut permettra de ranger asseF 5acilement dans un 5ichier KE( toutes les donnes dun objet. &t a$ec un simple attribut on peut demander G ce quun des champs ne soit pas srialis. Me ne $ais pas $ous insister sur la s)nta!e pour srialiser Iod il 5aut crer un 5lu! $ers un 5ichier te!teJ mais montrer comment rendre srialisable une classe. =i $ous $ouleF e!cuter cet e!emple $ous aureF besoin de la r5rence G
System.;untime.SerialiKation.Aormatters.Soap .
C#

using using using using

System% System.ZW% System.;untime.SerialiKation% System.;untime.SerialiKation.Aormatters.Soap%

RSerialiKa(le()S pu(lic class JxempleSerialisation { pu(lic int serialise% RConSerialiKed()S pu(lic string nonserialise% pu(lic JxempleSerialisation() { serialise ) 9==@% nonserialise ) !mon nom est Nir6ongri6engra6terg!%

&

pu(lic void a66ic0age() { Console.Write ine(!'l'ment s'rialiK' ) !- serialise..oString())% Console.Write ine(!'l'ment non s'rialiK' ) !- nonserialise)% & &

pu(lic class Program { pu(lic static void Main() { JxempleSerialisation varia(le.a66ic0age()%varia(le ) neH JxempleSerialisation()% // a partie qui suit permet de s'rialiser et d's'rialiser3 // #e ne m4atarderait pas dessus3 le su#et 'tant les attri(uts. Stream stream ) Aile.Wpen(!varia(le.xml!3 AileMode.Create)% SoapAormatter 6ormatter ) neH SoapAormatter()% 6ormatter.SerialiKe(stream3 varia(le)% stream.Close()% Console.Write ine(!s'rialisation 6inie,nd's'rialisation7!)% varia(le ) null% stream ) Aile.Wpen(!varia(le.xml!3 AileMode.Wpen)% 6ormatter ) neH SoapAormatter()% varia(le ) (JxempleSerialisation)6ormatter.DeserialiKe(stream)% stream.Close()%

Console.Write ine(!d's'rialisation 6inie.!)% varia(le.a66ic0age()% Console.;ead<ey()% & &

Retour Console:

'l'ment s'rialiK' ) 9==@ 'l'ment non s'rialiK' ) mon nom est Nir6ongri6engra6terg s'rialisation 6inie d's'rialisation7 d's'rialisation 6inie. 'l'ment s'rialiK' ) 9==@ 'l'ment non s'rialiK' )

(attribut P=erialiFableIJ- a automatiquement implment le ncessaire pour que la classe puisse Htre srialise. %ous ne $oulions pas retenir un des champs0 nous a$ons mis l%on=erialiFedIJm. (attribut ce place au dbut de llment et sapplique sur sa globalit.
C#

using System% static class String.ool"ox { static int titleZndex ) +% pu(lic static void Write(t0is string s) { & Console.Write ine(s)%

RW(solete()S pu(lic static string titleAormat(t0is string s3 int i) { return !,n! - !Y! - (--titleZndex)..oString() - !Y! s..o`pper() - !Y! - i..oString() - !Y! - !,n!% & &

/oilG un autre attribut simple pour mentionner quune mthode est d$alu. (en$ironnement de d$eloppement prcisera les mthodes que lon compte retirer au! d$eloppeurs pour les inciter G en utiliser dautres sils pr$oient de mettre G jour la librairie contenant la classe. (attribut Cbsolete peut se mettre sur nimporte quel lment. 'ous les attributs sont des classes hritant de =)stem.@ttribute.

Conclusion

%ous a$ons trait de mani3re tr3s s)nthtique un sujet quasiment inpuisable0 le 5rame8or? .%&' $ous permettra dutiliser les connaissances de ce tutorial pour crer des sites 8eb0 crer des applications 5enHtres0 5aire des applications graphiques0 des librairies` >re50 $ous pourreF 5aire quasiment presque tout ce qui est programmable a$ec le 5rame8or? et le +.. %ous a$ons abord de pr3s ou de loin tous les mots cle5s du +. G le!ception de quelques uns I$olatile0 loc?0 e!ternal et 8hereJ. Pour rappel nous a$ons $u * (histoire et 5onctionnement du +. (es t)pes $aleurs et string (es oprateurs

(es conditions (es boucles (es @rra)s +omment grer les erreurs +omment utiliser les pointeurs hrits du +-(es espaces de nom (es modi5icateurs dacc3s0 les attributs et les proprits (es mthodes dont Eain0 les constructeurs et les destructeurs (a surcharge des mthodes (es dlgus0 $3nements0 et e!pressions lambda (es itrateurs (hritage (e pol)morphisme (es inter5aces (es attributs

Pour tirer pleinement partie de ce premier tutoriel0 $ous de$rieF songer G aborder dautres cours de ;ot%et-<rance0 $ous a$eF dsormais le ni$eau requis. /oici les cours $er les quels $ous pourrieF $ous orienter. /ous $ous intresseF au! applications 5enHtres Z $ous pou$eF $ous diriger $ers le tutoriel traitant des :in<orm. /ous $ouleF 5aire des sites 8eb Z le tutoriel @=P.%&' :eb<orm. /ous $ouleF 5aire par e!emple un jeu $ido0 intresseF $ous peut Htre au tutoriel K%@. /ous $ous intresseF G lacc3s au! bases de donnes et 5ichiers KE(0 le tutoriel @;C.%&' est aussi lG pour $ous. /ous $ous intresseF G linteroprabilit et au! applications Uni! Z peut Htre de$rieF $ous $ous diriger $er le tutoriel Eono. /ous $ouleF amliorer $os connaissances globales sur les rouages du 5rame8or? Z (e tutoriel traitant du 5rame8or? de$rait $ous satis5aire. +ette liste $ous donne djG un a$ant goet de ce que $ous pourreF 5aire a$ec le +.. Mesp3re que ce chapitre ne $ous a pas perdu0 et mHme ou$ert une en$ie au d$eloppement .%&'0 nhsiteF pas a garder ce tutoriel sous le coude comme manuel de r5rence0 car je ne pense pas que lon puisse tout intgrer dune seule traite.

1er a$ril