UploadedFile 130338580799467993

1
C# : Lessentiel en concentr
Sommaire
1 Introduction ..................................................................................................................................... 3 1.1 1.2 1.3 1.4 1.5 2 Quest-ce quun lan a e de !ro rammation .......................................................................... 3 "ourquoi lorient o#$et .......................................................................................................... 3 %n !eu d&istoire ..................................................................................................................... 3 %n e'em!le ............................................................................................................................. 4 (estion de la mmoire )i)e en .*+, ....................................................................................... 5
La s-nta'e !rocdurale : lo ique C.C// a!!lique en C# ............................................................... 5 2.1 2.1.1 2.1.2 2.1.3 2.1.4 2.1.5 2.1.2 2.2 2.3 2.3.1 2.3.2 2.3.3 2.3.4 2.3.5 2.4 2.4.1 2.5 2.2 2.3 0aria#les1 o!rateurs numrique et t-!es.............................................................................. 2 Les t-!es .......................................................................................................................... 2 Les o!rateurs ................................................................................................................. 3 +'em!le de calculs et de dclaration de )aria#le ........................................................... 3 Les c&aines de caract4res : quelques dtails................................................................... 5 Les )aleurs cle6s et les t-!es nulla#le .............................................................................. 7 Le Cast ............................................................................................................................. 7 La condition: i6 8 else 8 s9itc&.case 8 o!rateur ternaire .................................................... 1: Les #oucles: 9&ile 8 do 8 6or 8 oto ...................................................................................... 12 ;&ile.............................................................................................................................. 12 <o 9&ile ......................................................................................................................... 13 =or.................................................................................................................................. 13 (oto ............................................................................................................................... 13 Sortie de #oucles : >rea?-Continue ............................................................................... 14 @rra- 8 enum 8 struct ............................................................................................................ 15 6oreac&........................................................................................................................... 12 (estion des erreurs : tr--catc& 8 6inall- ................................................................................ 12 Instructions !r!rocesseurs .................................................................................................. 15 Le code A unsa6e B et A c&ec?ed . unc&ec?ed B.................................................................... 15
Lorient C#$et en C#..................................................................................................................... 2: 3.1 3.2 3.3 Introduction ........................................................................................................................... 2: %sin ...................................................................................................................................... 2: Instanciation .......................................................................................................................... 2:
1er a)ril 2::5
3.3.1 3.4 3.5 3.2 3.2.1 3.2.2 3.2.3 3.2.4 3.2.5 3.2.2 3.2.3 3.2.5 3.3 3.3.1 3.3.2 3.3.3 3.3.4 3.3.5 4
Lattri#ut et le modi6icateur dacc4s ............................................................................. 21 La !ro!rit ........................................................................................................................... 22 Static ...................................................................................................................................... 23 Les mt&odes ........................................................................................................................ 24 Detour sur Eain ............................................................................................................. 24 Constructeur . destructeur ........................................................................................... 25 La surc&ar e .................................................................................................................. 23 <ele ate......................................................................................................................... 25 Les )nements ............................................................................................................. 27 Et&odes anon-mes et +'!ressions lam#da ................................................................ 31 Et&ode de'tension. ................................................................................................... 33 Itrateurs ....................................................................................................................... 34 L&rita e1 le !ol-mor!&isme et les inter6aces ..................................................................... 35 Introduction ................................................................................................................... 35 +'em!les d&rita e : les e'ce!tions et t&ro9 ............................................................. 32 Ded6inition de mt&odes et dattri#uts ....................................................................... 33 Les inter6aces ................................................................................................................. 35 Les attri#uts ................................................................................................................... 4:
Conclusion ..................................................................................................................................... 41
1er a)ril 2::5
1 Introduction
Comme ce c&a!itre rsume de mani4re s-nt&tique le lan a e de !ro rammation1 si )ous na)eF aucune connaissance en orient o#$et1 $a)a ou !ro rammation $e )ous recommande de lire au moins deu' 6ois ce cours !our donner une meilleure co&sion G lensem#le des connaissances qui en ressortent. 0ous )erreF quil - a #eaucou! de r6rences G des sous-!arties qui seront traites en a)al. Il marri)era sou)ent de coder !lusieurs 6ois des e'em!les identiques ou tr4s !roc&e a)ec des mots cle6s di66rents !our )ous !ermettre de com!rendre !ar analo ie et )ous )iter de relire lensem#le de la source a)ec attention !our com!rendre. <ans les !remi4res !arties il marri)era de dire A 6onction B G la !lace de A mt&ode B1 cest !arce que cest !lus !arlant !our #eaucou!1 cet a#us de lan a e )olontaire sera clairci dans la !artie rser)e au' mt&odes.
1.1 Quest-ce quun lan a e de !ro rammation

C#1 $e ne !ense !as )ous la!!rendre est un lan a e de !ro rammation. Ces lan a es ne sont !as le mode de !ens de la mac&ine qui elle ne com!rend que des instructions #inaires d!endantes du !rocesseur. Ces lan a es ont !our #ut dHtre !lus lisi#le et !lus !ratique que lassem#leur !our sim!li6ier la )ie des d)elo!!eurs. Le C et le C// sont des lan a es com!ils qui sont donc trans6orms directement en instructions !rocesseur. +n .*+,1 ce nest !as le cas la com!ilation donne un code IESIL.Eicroso6t Intermediate Lan ua eJ qui est inter!rt !ar un lo iciel Iinter!rteurJ. Il 6aut donc retenir que les lan a es sont des normes de d)elo!!ement qui c&erc&ent sou)ent un com!romis entre le con6ort1 la ra!idit de d)elo!!ement et la !er6ormance. Ces normes sont accom!a nes doutils tel un com!ilateur.
<u 6ait que le code com!il ESIL soit commun au lan a e .*+, utilis1 on !eu dire que le C# et le 0>.*+, sont deu' lan a es de !ro rammation a-ant un con6ort di66rent mais des !er6ormances tr4s similaires.
1.2 "ourquoi lorient o#$et

Lorient o#$et G t introduit !ar le lan a e Small,al? Id)elo!! !ar la socit Kero'J en 1732. Lorient o#$et est un ensem#le de r4 les1 de conce!ts1 doutils du lan a e de !ro rammation !our rendre le d)elo!!ement !lus ais rLce au rou!ement dlments. Les o#$ets sont donc des entits qui !ermettent de rou!er ensem#le des 6onctions et des )aria#les en 6acilitant leurs estions !ar rou!e et en ou)rant de multi!les !ossi#ilits. <6inir un o#$et !eut !araitre comme a$outer un outil1 Le 6rame9or? .*+, a!!orte lui un set im!osant do#$ets e'istants. %n lan a e Crient o#$et nest !as les o#$ets1 mais une s-nta'e et des mots cle6s !our les mani!uler et les crer. >ien que nous allons utiliser des o#$ets du 6rame9or? ce cour )isera G )ous a!!rendre le lan a e.
Lorient o#$et !ermet la estion densem#le1 le rou!ement1 lisolation des donnes et des 6onctions. Cet ensem#le de conce!ts et doutils !ermet !ar e'em!le de rou!er dans un coin les o#$ets !our accder au' donnes distinctement des o#$ets qui ser)ent a 6aire linter6ace a)ec lutilisateur et des o#$ets qui ser)ent G a!!liquer les calculs et !rocdure lo iques de 6ond. <e ce 6ait nous !ourrons dis!oser dun code sim!le et lisi#le.
1.3 %n !eu d&istoire

Le C# est un lan a e rcent a!!aru en 2::11 il est !rinci!alement ins!ir !ar le Ma)a I1775J mais aussi !ar le C//. Ce lan a e dont le nom se !rononce A C-S&ar! B G t cr !ar Eicroso6t G t normalis !ar l+CE@ lanne de sa sortie I!uis !ar lISC deu' ans !lus tardJ. Il - a eu trois )ersion du C# im!lmentant tou$ours quelques 6onctionnalits su!!lmentaires. Le C# tant un !roduit du 6rame9or? .*+, leurs )olutions sont tr4s lies. Le C# 2.: est sorti a)ec le 6rame9or? 2.:1 le C#3.: lui
1er a)ril 2::5
#ien quutilisa#le sur le 6rame9or?2.: arri)e nati)ement et !rend )raiment tout son intrHt dans le 6rame9or? 3.5 a)ec le LI*Q. "our utiliser la s-nta'e du C#3.: il 6aut utiliser le com!ilateur ada!t dans un en)ironnement ci#le 2.: ou su!rieur. Ce com!ilateur est notamment dis!oni#le et im!lment a)ec 0isualStudio 2::5.
1.4 %n e'em!le
Ce tutorial est a' sur le lan a e et la s-nta'e du C#1 dans le cas ou )ous serieF sous ;indo9s1 )ous !ou)eF essa-er 0isual Studio +'!ress ou S&ar!<e)elo! I)oire le mode C# de +cli!seJ. <ans le cas ou )ous serieF sous Linu' ou Eac1 $e )ous encoura e G lire d4s G !rsent les deu' !remiers tutoriels sur Eono. Il est im!ortant de connaitre ses outils et de les a)oir 6onctionnels !our !ou)oir se concentrer sur la lo ique de !ro rammation. Demarque : "our les inconditionnels de la li ne de commande1 a$outeF G )otre )aria#le den)ironnement "at& : A C:N;I*<C;SNEicroso6t.*+,N=rame9or?N)3.5 B1 )ous !ourreF com!iler les e'em!les que )ous aureF enre istr dans des 6ic&iers te'te en 6aisant A csc.e'e mon!remiercode.cs B !uis e'cuter le !ro ramme A mon!remiercode.e'e B1 )ous !ourreF aussi a$outer des o!tions de com!ilation1 !our )oir celles dis!oni#le e'cuteF : A csc.e'e .O B .
0oici un code a66ic&ant dans un terminal A >on$our P B. Le code !ro!os est rduit G sa !lus sim!le e'!ression. EHme les !ro$ets console !ar d6aut des en)ironnements de d)elo!!ement int rs sont !lus consquent. "our linstant nous nous concentrerons sur le contenu des accolades qui sui)ent A EainI J B. Les accolades sont !rcdes de mots cle6s et noms qui ser)ent G 6ormer une structure de'cution. Cette structure rele)ant de lorient o#$et est ncessaire G le'cution mais elle ne sera e'!lique seulement qua!r4s a)oir acquis les #ases de la lo ique !rocdurale.
C#
static class "ro ram Q static )oid EainIJ Q
.. <ans les e'em!les qui sui)ent nous !lacerons notre code ici
S-stem.Console.;riteLineIR>on$our PRJS T T
0ous a)eF remarqu que sur la !remi4re li ne de la Fone tudie Ila li ne )erteJ $ai crit un te'te li#re en 6ranUais. Cette li ne commence !ar A .. B. Ce s-m#ole est un s-m#ole de commentaire qui dit au com!ilateur de ne !as inter!rter la 6in de la li ne. Il marri)era sou)ent de )ous 6aire des remarques dans ces commentaires qui sont !artie int rante du tutoriel. Il e'iste aussi une autre con)ention de commentaire qui au lieu dc&a!!er la 6in de la li ne1 c&a!!e $usquG un s-m#ole de 6ermeture. Ces commentaires lG sou)rent a)ec A .V B et se 6erment a)ec A V. B I)ous aureF un e'em!le dans le !roc&ain e'trait de codeJ. Il - a une s-nta'e qui !ermet de nrer de la documentation G !artir des commentaires1 si )ous de)eF tra)ailler en qui!e ou !our une entre!rise1 nrer une documentation qui !ermettra G )otre successeur de !rendre la rel4)e sa)4re im!ortant I!a e sur la documentation du code en C#J. Si )ous )ous intresseF G cette s-nta'e1 cette !a e )ous e'!liquera lessentiel. Cela dit le contenu de cette !a e contient des donnes asseF tec&niques de ce 6ait il !ourrait Htre !ertinent d- $eter un Wil seulement a!r4s a)oir 6ini de lire ce tutorial.
1er a)ril 2::5
S-stem.Console.;riteLine est a!!el a)ec A >on$our P B en ar ument1 on a$oute G cela un A S B !our s!ci6ier A e'cute Ua !uis on !asse G la suite B. Cn a!!elle c&aque lment qui sui)i dun A S B une instruction. Il !eut Htres sur une ou !lusieurs li nes. Lorsque Eain a e'cut la derni4re instruction quil contient le !ro ramme !rend 6in. Si )ous a)eF lanc ra!&iquement )otre a!!lication1 la 6enHtre console se 6ermera car la 6in du !ro ramme entraine la 6in de la console. Me sais que Ua ne'!lique !as tout le'trait de code mais )enons - !ro ressi)ement a)ec cette arc&itecture en tHte. DeteneF #ien que c&aque im#rication de commandes 6inissant !ar un A S B sa!!elle A instruction B.
*oteF #ien que les !roc&ains e'em!les seront sou)ent $uste la !rocdure entre les accolades de la 6onction Eain
1.5 (estion de la mmoire )i)e en .*+,

"our com!rendre un !eu mieu' certains !&nom4nes qui seront a#ords !lus tard1 nous allons e'!liquer ra!idement la estion de la mmoire !ar le .*+, 6rame9or?. La mmoire est un !oint essentiel !our !ou)oir 6aire de la lo ique. Detenir des rsultats intermdiaire !our les rutiliser ou autres. "our enre istrer tem!orairement une )aleur lui donne un nom. Ce nom sera utilis comme un lien )ers un es!ace mmoire. Cette association nom1 es!ace mmoire et donne contenue est un tout que lon a!!elle )aria#le. <ans certains lan a es de !ro rammation comme le C1 le C// ou le C# nous a)ons des A )aria#les liens B. Ces )aria#les contiennent ladresse dune donne qui )entuellement !ourrait ne !as Htre nomme. Ces )aria#les liens sont en ralit a!!eles !ointeurs1 elles sont sou)ent cac&es dans le .*+, #ien quelles soient utilises au cWur du 6rame9or?.
.*+, s!are la mmoire en deu' !arties isoles1 la !ile et le tas. Quand on 6ait un !ro ramme en .*+,1 le 6rame9or? nous rser)e un es!ace mmoire. Les autres !ro rammes ne !eu)ent normalement !as - accder. Les donnes dites A t-!e )aleur B sont celles qui ont leurs )aleurs dans la !ile. Les )aria#les de t-!e )aleur sont le !lus sou)ent in6erieure G 32 octets. >ien que !er6ormant !our les !etites )aria#les le t-!e )aleur est com!lt !ar un autre t-!e : le t-!e r6rence. Les )aria#les de t-!e r6rence ont un !ointeur enre istr dans la !ile qui !ointe )ers les donnes de la )aria#le. Ces donnes sont dans la Fone mmoire a!!ele le tas.
%n outil a!!el A (ar#a e Collector B est c&ar de li#rer et d6ra menter d-namiquement la mmoire du tas. @insi1 si des donnes nont !lus de !ointeurs associes1 la mmoire est li#re. Si les donnes taient au milieu du tas1 les!ace li#r sera rutilis !ar les donnes du A 6ond du tas B. Ce !rocd !ermet de redimensionner notre es!ace mmoire rser) et donc de li#rer de la mmoire !our le s-st4me et les autres !rocessus.
2 La s-nta'e !rocdurale : lo ique C.C// a!!lique en C#

Comme nous le disions1 la s-nta'e du C# est tr4s ins!ire du C.C//1 on !eut mHme 6aire de larit&mtique de !ointeurs !our !eu que lon d6inisse notre code en tant que A %nsa6e B. Les !ersonnes a-ant de #onnes #ases en C.C// ne )erront rien de'traordinaire dans cette !artie qui risque de !araitre dense !our ceu' qui !artent de Fro. Demarque : Si cest )otre tout !remier cours de !ro rammation1 ce c&a!itre )a )ous !araitre dense1 $e )ous encoura e G essa-er c&aque e'em!le et essa-er de !rendre du recul a)ec cette !artie dans )otre #a a e !our mieu' re)enir sur la !artie traitant de lorient o#$et.
1er a)ril 2::5
2.1 0aria#les1 o!rateurs numrique et t-!es.

Les o!rateurs numriques sont la #ase des calculs et de la lo ique. La mmoire est un !oint cle6 de la !ro rammation. "our inter!rter le code #inaire dans une )aria#le et donc la donne en mmoire il 6aut en connaitre le t-!e. La dclaration des )aria#les1 lattri#ution de leurs )aleurs et les o!rateurs numriques de #ase sont similaire en C# et en C.C//1 )o-ons comment les utiliser. <ans une quHte de s-nt&4se1 $ai 6ait !eu de'em!le dans cette !artie1 si )ous trou)eF dur G com!rendre les t-!es ou les o!rateurs tro! dtac&eF de la !ratique a)anceF a)ec en !arall4le le'em!le en 2.1.3. ,ous les o!rateurs et tous les t-!es n- sont !as illustrs. <urant lensem#le du cours )ous )erreF lusa e de c&aque o!erateur au moins une 6ois1 mais !our ce qui est des t-!es $utiliserai !rinci!alement des entiers.
2.1.1Les t-!es 0oici quelques t-!es de #ase utilisa#le en C#. Les t-!es !rsents dans ce ta#leau G le'ce!tion de A strin B et les structures sont les seuls t-!es G Htre stoc?es !ar )aleur. Classe S-stem.S>-te S-stem.>-te S-stem.Int12 S-stem.Int32 S-stem.%int32 S-stem.Int24 S-stem.Sin le S-stem.<ou#le S-stem.<ecimal S-stem.C&ar S-stem.>oolean S-stem.Strin @lias s#-te #-te s&ort int uint lon 6loat dou#le decimal c&ar #ool strin Cctets 1 1 2 4 4 5 4 5 12 2 4 V 0aleur codes -125 G 123 : G 255 -32325 G 32323 -2143453245 G 2143453243 : G 4274723275 -7223332:325543355:5 G 7223332:325543355:3 -314+/35 G 314+/35 -1137+/3:5 G 1137+/3:5 -317+/27 G 317+/27 Caract4re %nicode I%,=-12J 0aleur true ou 6alse C&aXne de caract4res
Demarque : Ce ta#leau est ada!t dun ta#leau que )ous trou)ereF dans le c&a!itre 1 des cours sur le =rame9or?1 ce c&a!itre !ourrait )ous aider G a!!ro6ondir )os connaissances tec&niques des #ases du t-!a e1 de lorient o#$et et )ous - trou)ereF une e'!lication !lus dtaille et !lus ima e de lusa e de la mmoire )i)e en .*+,. Contrairement G certains lan a es Icomme le !-t&onJ tout o#$et doit Htre e'!licitement t-!. C&aque )aria#le a un t-!e d6ini et on est o#li de s!ci6ier un t-!e !our c&aque ar ument de c&aque mt&ode. "our allouer de la mmoire G une )aria#le1 on cre une instruction a)ec dune !art le t-!e et dautre !art le nom de la )aria#le. Si )ous )ouleF trou)er 6acilement la )aleur ma'imale et la )aleur minimale dun t-!e numrique1 6aites A S-stem.Int32.Ea'0alue B !our retourner le !lus rand des int ou Ein0alue !our trou)er le !lus !etit. 0ous na)eF !as encore )u comment 6aire usa e de ses )aleurs mais noteF que les )aleurs limites sont accessi#le dans le 6rame9or? et de ce 6ait )ous nHtes !as tenu de les retenir.
Si on a$oute G une )aria#les A .(et,-!eIJ B1 cela retournent le t-!e de la )aria#le. 0ous )erreF un contrYle de t-!e utilisant cette mt&ode dans la !artie sur la estion des erreurs.
1er a)ril 2::5
2.1.2 Les o!rateurs "our traiter la )aria#le on utilise des o!rateurs. 0oici les o!rateurs dans leur ordre de !riorit Ion !ourra utiliser des !arent&4ses !our red6inir les !riorits comme en mat&matique.J : C!rateur C# Calculs V . Z / ,ests is [ \ []1\] P] ]] Lo ique ^^ __ OO cond O )ar1 : )ar2 @ttri#ution ] /]1 -]1V]1.]1Z]1^]1_] Incrmentation VV // -Si ni6ication Ces o!rateurs !ermettent de 6aire des calculs Eulti!lication. <i)ision. Eodulo. @ddition. Soustraction. Ces o!rateurs !ermettent de retourner des #oolens I)rai ou 6au'J ,este le t-!e dun o#$et Iutilis !arti 2.5J In6erieur G. Su!rieur G. In6erieur ou al1 su!rieur ou al. <i66rent de. +st al G Ces o!rateurs traitent des )aria#les et en retournent une. +, lo ique I)rai si tous les mem#res sont )raiJ C% lo ique I)rai si au moins un des mem#res est )raiJ Detourne lo!rande de auc&e si non-null ou #ien celui de droite. I2.1.3J Den)oie )ar1 si cond est )rai ou alors )ar2 I0oir !artie 2.2J Ces o!rateurs !ermettent dattri#uer une )aleur G une )aria#le @ttri#ution I!ermet de donner une )aleur G une )aria#leJ. "ermet de contracter la )aria#le de lo!rateur et de lattri#ution V. Ces o!rateurs rattri#uent G une )aria#le sa )aleur modi6ie. @$oute 1 G la )aleur. +nl4)e 1 G la )aleur.
V : Ces o!rateurs dattri#utions ne ser)ent quG 6aire une contraction !ratique. @)ec lo!rateur /] on a$outera la )aleur actuelle de la )aria#le G la )aleur G attri#uer. 0aria#le [o!rateur\] 12 qui)aut G 0aria#le ] 0aria#le[o!rateur\12. 0ous aureF des e'em!les dans le'trait de code sui)ant. VV : Les o!rateurs dincrmentation se !lacent sur une )aria#le dans une instruction seule ou dans un calcul. Si le si ne est G auc&e de la )aria#le ce sera e'cut en !riorit a#solue dans linstruction1 sil est G droite la )aria#le on incrmentera G la toute 6in de linstruction. Demarque : Cn ne !eut !as a)oir !lus dun o!rateur dattri#ution !ar instruction. 2.1.3 +'em!le de calculs et de dclaration de )aria#le 0oici un e'em!le dutilisation :
C#
int aS.. on dclare a de t-!e int int # ] 5S .. on dclare # et - attri#u la )aleur 5 a ] :S..on attri#u la )aleur : dans a S-stem.Console.;riteLineIRa]NtR/a.,oStrin IJ/RNn#]NtR / #.,oStrin IJ / RNnRJS .VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
1er a)ril 2::5
V ,outes les )aria#les o#$ets ont la mt&ode R.,oStrin IJR. V @!!lique G un int1 R.,oStrin IJR retourne une c&aine de V te'te contenant la )aleur. V V Lò!rateur R/R entre des strin les concat4nes cèst G dire les 6usione V en les mettant G la suite. V V RNnR et RNtR sont des caract4res s!ciau' : )oir !artie 2.1.5 VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV. a /] a / //#S.. #]#/1S a]a/a/#S S-stem.Console.;riteLineIRa]NtR/a.,oStrin IJ/RNn#]NtR / #.,oStrin IJ / RNnRJS a .] #S.. a]a.# a -] 2V#//VaS.. a]a-2V#VaS #/]1S
S-stem.Console.;riteLineIRa]NtR/a.,oStrin IJ/RNn#]NtR / #.,oStrin IJ / RNnRJS S-stem.Console.Deadae-IJS .. attend que lùtilisateur a!!uie sur une touc&e
Detour Console:
a] #] a] #] a] #]
: 5 2 2 -11 3
Cet e'em!le !eut !araitre court1 cest )rais mais ne #loqueF !as dessus1 si ce nest !as acquis maintenant1 )ous )erreF des e'em!les !artout dans ce court )u que cest )raiment la #ase. Il 6aut retenir !our la dclaration des )aria#les : le nom du t-!e1 le nom de la )aria#le et le caract4re de 6in dinstruction IA S BJ. Le'em!le montre que lon !eut attri#uer une )aleur en mHme tem!s que lon dclare une )aria#le Ideu'i4me li neJ.
2.1.4Les c&aines de caract4res : quelques dtails <ans le commentaire le !lus im!osant1 on )oit que !our les strin s il e'iste des caract4res s!ciau' dont celui du retour G la li ne et de la ta#ulation. 0oici quelques caract4res s!ciau' : ' Nn1 Nr : retour G la li ne ' Nt : ta#ulation I!ratique !our les ali nements )erticau'J ' NN : !ermet da66ic&er un antislas& ' NR : !ermet da66ic&er un uillemet ' N'KK ou A KK Best une )aleur &e'adcimale de deu' caract4res Ic&acun entre : et =J : !ermet da66ic&er un caract4re !ar son code &e'a.
Si )ous ne )ouleF !as #n6icier du su!!ort de ces caract4res et a)oir une c&aine non inter!rte1 il su66it de !rcder la c&aine !ar un b I!ratique !our les adresses de 6ic&ier !ar e'em!leJ. Les c&aXnes !rcde dun aro#ase !eu)ent Htre a!!eles A c&aXne 0er#atim B1 ces c&aXnes !eu)ent contenir de rels retours G la li ne. @u lieu de concatner les c&aines a)ec le si ne A / B on !eut a$outer des )aria#les dans les strin s a)ec un mo-en sim!le de 6ormata e.
C#
int ar 1 ]12S strin ar 2 ] R#on$ourRS
1er a)ril 2::5
ulon ar 3 ] 1542431534S Console.;riteLineIRar 1]Q:TNnar 2]Q1TNnar 3]Q2TR1ar 11ar 21ar 3JS ar 2 ] strin .=ormatIRQ:T1 Q1T1 Q2TR1 ar 11 ar 21 ar 3JS Console.;riteLineIar 2JS Console.Deadae-IJS
Detour Console
ar 1]12 ar 2]#on$our ar 3]1542431534 121#on$our11542431534
Cette mt&ode !ermet une )isi#ilit un !eu !lus claire et !eut )iter un rand nom#re de A .,oStrin IJ B. Les ar uments nattendent !as de t-!e !articulier.
2.1.5 Les )aleurs cle6s et les t-!es nulla#le Il e'iste des )aleurs qui sont re!rsentes seulement !ar des mots cle6s. Ces mots cle6s sont null1 true et 6alse. "our !ou)oir attri#uer la )aleur null G une )aria#le Ide t-!e )aleurJ on utilise une structure qui contient un #oolen et la )aleur de t-!e d6iniIle mot structure est d6ini !artie 2.4J. Ce #oolen est a!!el cas0alue. Lorsque sa )aleur est G A true B le nulla#le a une )aleur1 quand il est G 6alse la )aria#le )aut null. Cet e'em!le )ous montre les deu' mt&odes !our 6aire un nulla#le.
C#
uintO a ] 2S S-stem.*ulla#le[uint\ # ] 15S # ] nullS a /] #S .. a ] null / 2 cest G dire a ] null # ] 12S S-stem.Console.;riteLineI#.,oStrin IJ/R-V-R/a.,oStrin IJ/R-V-R/IaOO#J.,oStrin IJJS S-stem.Console.Deadae-IJS
Detour Console
12-V--V-12
Si lon su66i'e le t-!e )aleur dun A O B on o#tient ce t-!e mais nulla#le. Cn !eut aussi mettre e'!licitement comme t-!e de la )aria#le nulla#le comme 6ait !our la )aria#le # I"our mieu' com!rendre lutilit des c&e)rons qui dans se conte'te ne )eulent )idement !as dire A su!rieur G B1 )ous !ourreF )oir les classes nriques dans le c&a!itre traitant de linstanciationJ. Ces )aria#les sont susce!ti#les de contenir null qui corres!ond G A nant B1 A rien B Idans certains cas dutilisation A non d6ini BJ. LintrHt da)oir une )aleur null est le !lus sou)ent !our mentionner que ce nest !as d6ini.
Lautre utilisation de null est la des-allocation de mmoire. <ans le cas ou la )aria#le est de t-!e r6rence1 si lui attri#ue null Ie'em!le : A )aria#le ] null S BJ ladresse stoc?e !ar le !ointeur dans la !ile sera mise G :. Lorsque le (ar#a e Collector contrYlera dans le tas la )aria#le1 )u que rien ne !ointe dessus elle sera su!!rime.
2.1.2 Le Cast Le cast est un mo-en dutiliser une )aria#le qui nest !as du t-!e G utiliser !our le calcul. Cest G dire le cast !ermet de retourner une )aleur du t-!e attendu G !artir de la )aria#le. @insi on !ourra !ar e'em!le caster un int en lon !our utiliser une )aria#le na-ant !as les mHme limites de d!assement. Il - a deu' mo-ens !our essa-er de c&an er le t-!e dun o#$et1 un )ite les erreurs quand on nest !as sur que lo#$et !uisse Htre cast et lautre ret-!e ou ren)oie une erreur ou une
1er a)ril 2::5
1:
)aleur a#errante I!our com!rendre quand on a une erreur ou une )aleur a#errante re ardeF la !artie sur c&ec?ed.unc&ec?edJ. Le mot cle6 A as B doit caster )ers un t-!e nulla#le ou r6rence I)oir !artie 2.3J. Si la )aria#le est du t-!e requis ou A com!ati#le B1 as retourne la )aleur t-!e. @u cas contraire il retournera null. Le A as B est traduit a)ec dautres o!rateurs dans le'em!le. "our ra!!el1 lo!rateur A OO B sert G retourner une autre )aleur si le !remier lment est null1 il est !ar6ois utilis a)ec as !our a)oir un retour en cas dim!ossi#ilit de cast di66rent de null. Le cast classique consiste G im!oser G une )aria#le de c&an er de t-!e1 si ce c&an ement de t-!e ne 6onctionne !as une e'ce!tion est le)e.
C#
int a ] int.Ea'0alueS lon # ] lon .Ea'0alueS lon c ] 15S .. cast im!licite o#$ect o ] cS .. cast e'!licite necessaire a ] IintJ#S..l4)e une o)er6lo9e'e!tion si les d!assements sont contrYls .. cast im!licite # ] aS
..6onctionne
.. usa e de as et de lò!rateur OO # ] Io as lon OJ OO : S .. qui)au G lìnstruction: # ] IIo is lon OJ O IIlon OJ oJ : IIlon OJnullJ J OO :S .. lò!rateur ternaire sera dtaill dans la !artie qui suit. .. ici1 seuls Rlon R et Rlon OR 6onctionnent !our le t-!e de c Console.;riteLineI#JS S-stem.Console.Deadae-IJS
2.2 La condition: i6 8 else 8 s9itc&.case 8 o!rateur ternaire

Le mot cle6 i6 Ien 6ranUais A si BJ !ermet le'cution conditionnelle de code. La condition soumise G i6 doit retourner un >ooleen I,rue ou =alseJ1 nous utiliserons sou)ent ici des o!rateurs de test. +nsuite nous !assons la !rocdure G e'cuter si la condition est )raie entre accolades. Sou)ent1 et cest )rai a)ec #eaucou! de mots cle6s1 quand les accolades ne !araissent !as G la suite de la condition1 le mot cle6 sa!!liquera uniquement sur linstruction qui suit. Le mot cle6 else IsinonJ est tou$ours !rcd dau moins un i6. else comme i6 est sui)i de code entre accolades. Ce code sera utilis seulement si la derni4re instruction i6 na !as eu G e'cuter le #loc. Si lon doit !rocder G une srie de test ou un seul doit Htre e'cut1 )ous )erreF une suite du enre A i61 Velse i61 else i6d/1 else B1 seule la !rocdure associe de la !remi4re condition )raie sera e'cute. Le mot cle6 s9itc& !ermet seulement de contrYler di66rentes )aleurs que !eut !rendre une )aria#le ou e'!ression et da ir en 6onction. Les !ro!ositions ne !eu)ent !as Htre des )aria#les1 il ne !eut !as - en )oir 2 identiques1 tous les t-!es de )aleurs ne !eu)ent - Htre utiliss et !our ce qui est des !er6ormances le s9itc& est la moins o!timise des 3 solutions. *anmoins certains d)elo!!eurs trou)ent sa s-nta'e !lus lisi#le et !lus !ratique que lim#rication de A i6 B.
1er a)ril 2::5
11
La s-nta'e de lo!rateur ternaire est la sui)ante : A I#oolenJ O retourSi0rai : retourSi=au' B. Cn !eut #ien )idemment en im#riquer !lusieurs !our cumuler !lusieurs conditions. Eais il 6aut noter que lo!rateur ternaire !ermet un retour conditionnel et non !as une e'cution conditionnelle1 cèst-G-dire quil ne !eut rien e'cut et quil se !lace dans des e'!ressions comme une )aleur.
C#
int aS strin #S S-stem.Console.;riteLineIR+ntreF 2RJS a ] int."arseIS-stem.Console.DeadLineIJJS .V int."arse !rend le te'te entr !ar lutilisateur IDeadlineIJJ V et en retourne la )aleur indique si ce te'te contien un nom#re. V.
.. Et&ode i6.else i6 Ia ]] 2J Q a ] aS.. a]a est une instruction inutile G titre de'em!le # ] RnormalR S .. on !eut mHtre !lusieurs instructions T else i6 Ia ]] 1 __ a ]] 3J # ] R"as loinRS .. on !eut se !asser dacollade !our une instruction seule else .. on aurai !u rem!lacer RelseR !ar Ri6Ia [ 1 __ a \ 3 JR Q # ] R#iFarreRS .. une instruction seule !asse mHme a)ec les acollades T .. Et&ode s9itc&.case s9itc& IaJ Q case 2:.. le s9itc& saute G cette condition si a )aut 2 # ] R>ien Mou PRS .. !uis e'cute ses instruction #rea?S.. Le #rea? 6ait sortir du s9itc& case 1:.. en C# : !as de #rea? ] !as dinstructions case 3:.. le cas 1 )ien e'cuter les instructions du cas 3 #]R"as loinRS #rea?S.. donc on sort du s9itc& de6ault:.. de6ault re!rsente tous les autres cas # ] R#iFarreRS #rea?S T .. Et&ode o!rateur de retour conditionel #] Ia ]] 2J O RnormalR : Ia ]] 1 __ a ]] 3J O R"as loinR :R#iFarreR S
S-stem.Console.;riteLineI#JS S-stem.Console.Deadae-IJS
Cet e'trait de code montre trois mani4res de 6aire la mHme c&ose1 Le !ro ramme demande G lutilisateur dentrer une )aleur qui est a66ect dans A a B. @ la 6in on a66ic&e la c&aine de caract4re A # B. +ntre trois 6aUons !our mettre dans A # B : ' la c&aine A >ien $ou P B si A a B est al G 2 ' A "as loin B si A a B est al G 1 ou 3 ' A #iFarre B si A a B ne r!ond G aucun de ces crit4res.
Comme e'!liqu antrieurement1 on constate que suite au A i6 B il - a une condition ellemHme sui)ie dune ou !lusieurs instructions. <ans le cas de le'em!le ci-dessus si A a B est al G 2 A a]]2 B retourne )rai ce qui en endre le'cution de la66ectation de A >ien $ou P B. Lorsque lon
1er a)ril 2::5
12
utilise le mot cle6 i6 $uste a!r4s le A else B cest !our 6aire une liste de test1 le !remier )rai sera le seul e'cut. Le s9itc& !ermet donc ici de tester les cas qui nous intressent indi)iduellement cèst-G-dire 11 2 et 3. 0u que le cas 1 et le cas 3 ont le mHme traitement on !eu les runir. Le mot cle6 #rea? doit Htre mis en 6in de'cution a)ant la nou)elle )aleur du s9itc&. Si )ous )ouleF !lus de rensei nement sur le s9itc& ou en cas de !ro#l4mes a)ec ce mot cle6 ou si )ous )ouleF )oir les di66rences entre le s9itc& C et le s9itc& C#1 $e )ous recommande cet article 6ranco!&one. Im#riqu1 lo!rateur ternaire nest !as un cadeau !our ce qui est de la lisi#ilit. "our rendre !lus clair G lWil1 nous aurions !u mettre des !arent&4ses autour de la sous e'!ression ternaire ou la mettre G la li ne. 0ous a)eF nanmoins !u constater las!ect !ratique de cet o!rateur qui est celui qui a eu la s-nta'e la !lus ra!ide1 Ua naurai !as t !our le'em!le1 $aurai certainement mis le'!ression directement en ar ument de la mt&ode ;riteLine sans !asser !ar A # B. >ien quil !uisse !araitre !ratique et asseF o!timis !our ce qui est des !er6ormances1 lo!rateur ternaire )a !ar son manque de lisi#ilit G lencontre des !rinci!es des lan a es rcents qui )isent le con6ort de d)elo!!ement et la lisi#ilit. Il sera !rinci!alement utilis en ar ument de 6onction )u quon ne !eut !as )raiment - mettre des e'cutions conditionnelles.
2.3 Les #oucles: 9&ile 8 do 8 6or 8 oto

Les #oucles 6ont !arti des 6ondamentau' de la lo ique de la !ro rammation1 notre !roc&ain e'em!le ressem#lera en6in G quelque c&ose )u que lon aura )u a!r4s Ua lessentiel de la !artie structure lo ique des instructions dans une !rocdure.
2.3.1 ;&ile ;&ile Ien 6ranUais A tant que BJ !ermet de 6aire une #oucle conditionnelle1 !ro#a#lement le t-!e de #oucle que )ous croisereF le !lus a)ec les #oucles 6or. *i)eau structure il ressem#le au i61 il a une condition entre !arent&4ses et un #loc? de code ncessairement entre accolade !our !eu quil ait !lusieurs instructions. Si la condition du 9&ile est )raie le #loc? de code est e'cut1 G la 6in de cette e'cution1 le #loc? est e'cut G nou)eau si la condition et )rai et ce $usquG ce que ce ne soit !lus le cas.
C#
int a]2S int #]15S int tem!S 9&ile I# \ :J Q i6 Ia ]] 1J a ] 2S else a ] 1S S-stem.Console.;riteLineIR,our du $oueur R/a.,oStrin IJ /RNnil reste R/#.,oStrin IJ /R allumettesNn!reneF un nom#re dàllumettes entre 1 et 3 Ide6aut 3JRJS tem! ] int."arseIS-stem.Console.DeadLineIJJS i6 Item! \ : ^^ tem! [ 4J #-]tem!S else #-] 3S T S-stem.Console.;riteLineIR$oueur R/a.,oStrin IJ/R a !erduRJS S-stem.Console.Deadae-IJS
Cn !eut )oir dans cet e'em!le que tant quil reste des allumettes1 les $oueurs !eu)ent en !rendre $usquG ce quil - en ait !lus moment ou on sortira de la #oucle !our a66ic&er le nom du
1er a)ril 2::5
13
!erdant. Le 6onctionnement est sim!le et commun au' autres. Il su66it de maitriser un t-!e de #oucle !our 6acilement com!rendre les autres.
2.3.2<o 9&ile ,r4s similaire au 9&ile normal1 il im!ose un minimum dune e'cution a)ant de contrYler les conditions de maintien de la #oucle.
C#
int a]:S do Q S-stem.Console.;riteLineIa//.,oStrin IJJS T 9&ile Ia \ : ^^ a [ 12J S S-stem.Console.Deadae-IJS
Le do-9&ile est lqui)alent du 9&ile mais la s-nta'e et di66rente et le contrYle de condition se 6ait G la 6in de la #oucle. <e ce 6ait le #loc? est e'cut au moins une 6ois mHme si la condition est 6ausse en !remier lieu. <ans ce cas A a B ] :1 il e'cute le #loc une !remi4re 6ois alors que la condition est 6ausse. +nsuite $usquG ce que A a B ne res!ecte !lus la condition il lincrmente et la66ic&e. I@66ic&e les nom#res de : G 11 inclusJ.
2.3.3=or La #oucle 6or est sou)ent tr4s !ratique mais nest !as tou$ours aime des d#utants1 cest un 9&ile a)ec deu' c&am!s su!!lmentaires : une )aria#le locale et une e'cution. Le tout est dans les !arent&4ses du 6or1 nous - )errons ncessairement deu' A S B !our s!arer les 3 c&am!s. De6aisons le'em!le du $eu des allumettes a)ec une #oucle 6or :
C#
int a ] 2S int tem!S 6or Iint # ] 15S # \ :S #-]Item!\: ^^ tem![4JOtem!:3 J Q i6 Ia ]] 1J a ] 2S else a ] 1S S-stem.Console.;riteLineIR,our du $oueur R / a.,oStrin IJ / RNnil reste R / #.,oStrin IJ / R alumettesNn!reneF un nom#re dàllumettes entre 1 et 3 Ide6aut 3JRJS tem! ] int."arseIS-stem.Console.DeadLineIJJS T S-stem.Console.;riteLineIR$oueur R / a.,oStrin IJ / R a !erduRJS S-stem.Console.Deadae-IJS
La #oucle 6or comme )ous !ou)eF le constater met en )aleur une )aria#le locale qui sera le !lus sou)ent utilise dans la condition de la #oucle Idonc son instanciationJ1 la condition mHme !uis une instruction qui met en )aleur le traitement 6ait G c&aque itration Ia !art la !remi4reJ1 )ous )erreF sou)ent A 6orIint a ] 1 S a[]1: Sa//JQ ..instructions ST B !our les #oucles qui doi)ent se r!ter 1: 6ois.
2.3.4 (oto Le oto est une alternati)e #ien quG )iter qui !ermet des c&oses asseF tonnantes. Le oto 6ait un saut $usquG un endroit nomm n im!orte oe dans la !rocdure. "our nommer un endroit on
1er a)ril 2::5
14
!arle de la#el ou dtiquette1 on met son nom sui)i de A : B. Mai mis la mt&ode Eain dans cet e'em!le !our montrer que !ar con)ention1 ces la#els sont indents en retrait sur la auc&e. La condition #oucle ralis a)ec i6. <ans ce conte'te le oto et le la#el sont G !roscrire du 6ait quun do 9&ile !ermet la mHme c&ose. Il est im!ortant de noter que le oto !eut aussi 6aire un saut )ers un la#el qui est en a)al dans le code ce qui !eut !ermettre de sortir !ar e'em!le dune im#rication de #oucles.
C#
static )oid EainIJ Q int a ] 2S int tem!]:S int # ] 15S nou)eau,our: i6 Ia ]] 1J a ] 2S else a ] 1S S-stem.Console.;riteLineIR,our du $oueur R / a.,oStrin IJ / RNnil reste R / #.,oStrin IJ / R alumettesNn!reneF un nom#re dàllumettes entre 1 et 3 Ide6aut 3JRJS tem! ] int."arseIS-stem.Console.DeadLineIJJS i6 Item! \ : ^^ tem! [ 4J # -] tem!S else # -] 3S i6 I# \ :J oto nou)eau,ourS
S-stem.Console.;riteLineIR$oueur R / a.,oStrin IJ / R a !erduRJS S-stem.Console.Deadae-IJS T
Demarque : Le oto est mal aim de #eaucou! de !ro rammeurs car oto ne res!ecte !as la structure lo ique de la !ense de de lindentation et du cou! cest moins lisi#le que les autres #oucles. Certains !ro rameurs )ont $usquG interdire lutilisation du oto ou d)elo!!er des lan a es nim!lmentant !as ce t-!e de #oucle. <e ce 6ait dans la mesure du !ossi#le il 6aut !ri)il ier lutil6isation dautres t-!es de #oucles.
2.3.5 Sortie de #oucles : >rea?-Continue Il !eut arri)er dans le cas ou les #oucles e66ectuent !lusieurs o!rations que lon )euille sortir directement de la #oucle ou sauter le'cution de la 6in du #loc?1 !our Ua il e'iste les mots cle6s #rea? et continue. Le mot cle6 #rea? !ermet de sortir #rutalement de la #oucle tandis que continue ren)oie au test. Il )a sans dire que ces deu' instructions ne 6onctionnent !as dans le cas de #oucle 6aites au oto.
C#
int a ] 2S int tem!]:S int # ] 15S 9&ileItrueJ Q i6 Ia ]] 1J a ] 2S else a ] 1S S-stem.Console.;riteLineIR,our du $oueur R / a.,oStrin IJ / RNnil reste R / #.,oStrin IJ / R alumettesNn!reneF un nom#re dàllumettes entre 1 et 3 Ide6aut 3JRJS tem! ] int."arseIS-stem.Console.DeadLineIJJS
1er a)ril 2::5
15
i6 Item! \ : ^^ tem! [ 4J # -] tem!S else # -] 3S i6 I# \ :J continueS #rea?S T S-stem.Console.;riteLineIR$oueur R / a.,oStrin IJ / R a !erduRJS S-stem.Console.Deadae-IJS
+)idemment ce cas est !lus un cas dtude quun cas !ratique1 )ous aureF un autre e'em!le aussi e'!licite mais montrant !lus lintrHt de ces mots cle6s dans la !artie sur la estion des erreurs.
2.4 @rra- 8 enum 8 struct

"our rou!er des )aria#les ou des )aleurs il - a !lusieurs outils1 les trois outils que $e )ous !rsente ici sont tr4s di66rents. ' Struct : d6ini un t-!e de )aria#le G !lusieurs c&am!s. ' +num : or anise des )aleurs cle6s ' Les arra-s sont des )aria#les dclares en tant que liste de )aleurs de t-!e commun.
Le'em!le !ro!ose un sem#lant dor aniseur de tLc&es et 6ait la somme de la dure des )nements de la semaine. enum et struct sont !our 6aire des dclarations qui seront en de&ors de Eain. enum et struct 6orment des lments1 une 6ois d6inis on ne !eut !lus les modi6ier. <ans la structure IstructJ on d6inie c&acune de ses sous )aria#les et leur t-!es comme si on dclarait des )aria#les. 0ous remarquereF le mot A !u#lic B. La structure est en ralit tr4s !roc&e de la classe I)oir c&a!itre 1 sur le 6rame9or?J mais nest en nral utilis que !our ran er un !etit nom#re de )aria#le.
C#
class truc Q struct e)enement Q !u#lic intfg $oursS !u#lic strin tac&eS !u#lic int dureeS T enum semaine Qlundi]11 mardi1 mercredi1 $eudi1 )endredi1 samedi1 dimanc&eT enum lon ueur,em!s QtresCourt]151court]3:1mo-en]2:1asseFlon ]7:1deu'&eures]12:1treslon ]24:T
static )oid EainIJ Q int tem!]:S e)enementfg cal ] ne9 e)enementfg Q .. La s-nta'e utilise ci-dessous !our rem!lir les )4nements ] C#3.: ne9 e)enementQ $ours] ne9 intfg QIintJsemaine.dimanc&e1IintJsemaine.mercrediT1 tac&e]R6aire la )aiselleR1 duree]IintJlon ueur,em!s.courtT1 ne9 e)enementQ $ours]ne9 intf3g1 tac&e]Rlire ses 6lu' DSSR1 duree]IintJlon ueur,em!s.asseFlon T1 ne9 e)enementQ
1er a)ril 2::5
12
$ours ] ne9 intfg QIintJsemaine.lundi1 IintJsemaine.mercrediT1 tac&e ] R!rendre un #ainR1 duree ] IintJlon ueur,em!s.mo-enT TS calf1g.tac&e /] R et sui)re quelques liensRS 6or Iint i]:S i [ cal.Len t&S i//J Q tem! /] calfig.duree V calfig.$ours.Len t&S S-stem.Console.;riteLineIIIdou#leJtem!.2:J.,oStrin IJ/ R &eures de ta semaine occu!e ItLc&e a$out: R / calfig.tac&e/R JRJS T S-stem.Console.Deadae-IJS T T
Detour Console:
1 &eures de ta 1115 &eures de quelques liens 1315 &eures de
semaine occu!e ItLc&e a$out: 6aire la )aiselle J ta semaine occu!e ItLc&e a$out: lire ses 6lu' DSS et sui)re J ta semaine occu!e ItLc&e a$out: !rendre un #ain J
Les !rinci!au' !oints G retenir ici sont : ' Lorsque lon a!!elle lenum il 6aut caster !our a)oir le t-!e dsir ' Les arra-s sont G taille statique1 )ous ne !ourreF !as a$outer dlments1 !our 6aire des sortes dA arra-s d-namique B on utilisera une classe nrique I)oqu dans le c&a!itre 3.3 sur linstanciationJ.
2.4.16oreac& 0ous a)eF constat que ma #oucle 6or me !ermettait de !arcourir la liste A cal B a)ec la )aria#le i qui me sert dinde'. <e ce 6ait $e traite tour G tour c&aque lment de larra-. "our 6aire cette dmarc&e !lus lisi#lement et a ner en taille de code $aurai !u re6aire ma #oucle comme suit :
C#
6oreac& Ie)enement e in calJ Q tem! /] e.duree V e.$ours.Len t&S S-stem.Console.;riteLineIIIdou#leJtem!.2:J.,oStrin IJ/ R &eures de ta semaine occu!e ItLc&e a$out: R / e.tac&e/R JR/semaine.lundi.(et,-!eIJJS T S-stem.Console.Deadae-IJS
La liste cal est la mHme que dans le'em!le !rcdent1 on 6ait !asser tour G tour dans la )aria#le locale c&aque lment e. @u 6inal on e'cute les mHmes instructions qua)ec la #oucle 6or dans le'em!le antrieur. *oteF le mot cle6 A in B qui na!!arait que dans ce conte'te. "our quun 6oreac& soit utilisa#le sur un o#$et ce dernier doit a)oir un com!ortement adquat I)oir la !artie sur les itrateursJ.
2.5 (estion des erreurs : tr--catc& 8 6inallComme )ous la)eF !eut Htre d$G constat1 si )ous entreF une c&ose qui nest !as assimila#le G du te'te dans le $eu qui nous sert de'em!le1 nous a)ons une erreur. "our rer les erreurs nous !ou)ons isoler le code !ro!ice G lerreur et lisoler dans un #loc de code A tr- B. *ous !ou)ons re arder la documentation de la mt&ode !ro!ice G lerreur !our )oir les di66rents t-!es derreurs
1er a)ril 2::5
13
qui !eu)ent ad)enir en ce conte'te. La mt&ode !ro!ice G lerreur dans notre code est A "arse B1 la surc&ar e !renant en ar ument un strin : les e'ce!tions de "arseIstrin J sur ES<*. "our !ou)oir traiter lerreur1 on )a ran er le code en cas derreur dans un #loc A catc& B. Si on met catc& seul Isans ar uments ni !arent&4sesJ le traitement sera le mHme quelque soit lerreur et on ne !ourra !as retourner din6ormations relati)es au' erreurs. +n mettant les !arent&4ses et un ar ument nral Icomme dans notre e'em!leJ on a une )aria#le interne au catc& IA e BJ qui contiens les donnes de lerreur et qui !ermet de es a66ic&er et de ra ir.
Les e'ce!tions sont des classes qui seront d6ini en e'em!le sur l&rita e. +'ce!tion re rou!e toutes les cat ories cèst-G-dire tous les t-!es de'ce!tions. <ans notre e'em!le nous com!arerons les t-!es de le'ce!tion G ceu' que lon a trou)s sur ES<* !our )oir la com!araison des t-!es. *ous retraiterons les erreurs dans la !artie A +'em!le d&rita e B. Le mot cle6 6inall- le !lus sou)ent utilis !our li#rer la mmoire est G !lac a!r4s le tr- et le catc&. Ce #loc? sera e'cut quil - ait erreur ou non. Demarque: )oici quelques !rinci!au' attri#uts communs G toutes les +'ce!tions !ermettant do#tenir des in6ormations !our si naler1 trou)er et corri er les #u s : ' Eessa e est un Strin dcri)ant la cause de lerreur de mani4re relati)ement e'!licite !our un utilisateur. ' cel!Lin? retourne ladresse Ie' :%DLJ du 6ic&ier daide associ au t-!e de le'ce!tion. ' Source donne le nom de la r6rence1 lassem#l- ou du 6ic&ier source qui est G lori ine. ' ,ar etSite !ermet da)oir le t-!e de retour de la mt&ode qui G le) lerreur et le t-!e des ar uments. ' Stac?,race donne la li ne de lerreur et remonte du Eain G la mt&ode qui l4)e le'ce!tion et 6ourni la li ne.
C#
uint a ] 2S uint tem! ] :S uint # ] 15S 9&ile I# \ :J Q i6 Ia ]] 1J a ] 2S else a ] 1S S-stem.Console.;riteLineIR,our du $oueur R / a.,oStrin IJ / RNnil reste R / #.,oStrin IJ / R alumettesNn!reneF un nom#re dàllumettes entre 1 et 3NnIde6aut 31 nom#re n ati6 !our a#andonerJRJS trQ tem! ] uint."arseIS-stem.Console.DeadLineIJJS T catc& IS-stem.+'ce!tion eJ Q S-stem.Console.;riteLineIe.Eessa eJS i6 Ie.(et,-!eIJ.+qualsIt-!eo6IS-stem.@r ument*ull+'ce!tionJJJ S-stem.Console.;riteLineIRim!ossi#le: retour minimal] NRNR InonnullJRJS else i6 Ie is S-stem.C)er6lo9+'ce!tionJ #rea?S else S-stem.Console.;riteLineIRmessa e non !arsa#leRJS
i6 Ia ]] 1J a ] 2S else a ] 1S continueS
1er a)ril 2::5
15
T i6 Item! [ 4J # -] tem!S else # -] 3S T S-stem.Console.;riteLineIR$oueur R / a.,oStrin IJ / R a !erduRJS S-stem.Console.Deadae-IJ S
Demarque : t-!eo6 est un mot cle6 qui !rend en ar ument une classe et qui retourne un t-!e1 ici il nous !ermet de sa)oir si le t-!e de lerreur A e B rel4)e #ien des classes en ar ument.
2.2 Instructions !r!rocesseurs

Me ne mettrai !as de'em!le !our linstruction !r!rocesseur1 cest asseF !eu utilis #ien que ce soit la seule mani4re !our !ou)oir d6inir des instructions G com!ilation conditionnelle. +n nral ce ne sera !as utilis1 dautan que contrairement au C.C// classique1 A #de6ine B ne !ermet !as de 6aire de macros. %ne liste des mots cle6s des instructions !r!rocesseurs est dis!oni#le G cette !a e : &tt!:..msdn.microso6t.com.6r-6r.li#rar-.ed5-d1&aI0S.5:J.as!'
2.3 Le code A unsa6e B et A c&ec?ed . unc&ec?ed B

Cette !artie aura du sens !articuli4rement !our ceu' qui ont d$G mani!ul des !ointeurs en C.C//1 #ien que cela !ermettes des c&oses asseF !uissante1 on !eu !ar6aitement se !asser de ce mode G !art !our le &ac?in . Le mode unsa6e I!ourrait Htre traduit !ar non shrJ !ermet de mani!uler directement les adresses mmoire et donc les !ointeurs. *ous allons )oquer ici quelques mots cle6s : unsa6e1 stac?alloc1 6i'ed. "our !ou)oir com!iler du code unsa6e1 )ous de)eF le s!ci6ier1 de!uis 0isual Studio slectionneF : !ro$et \ !ro!rits du !ro$et1 )ous de)reF coc&er une c&ec?#o' dans lon let nrer I!ro$et\o!tions\C!tions du com!ilateur !our Eono<e)elo! ou le !aram4tre de commande .unsa6e dans le terminalJ !our s!ci6ier e'!licitement )otre autorisation. Ces d!lacements de donnes tant Hnants si lon utilise des adresses mmoire1 on a deu' mo-ens de solutionner le !ro#l4me : stac?alloc? Ira!!elle un !eu le mallocJ qui !ermet dallouer de la mmoire dans la !ile et 6i'ed qui em!Hc&e au ar#a e collector de d!lacer certaines donnes du tas.
Illustrons !ar un e'em!le utilisant les !ointeurs :

C#
unsa6e static )oid EainIJ Q intV )aria#le ] stac?alloc intf1::gS .. stac?alloc ne sùtilise que !our des arra-s t-!es )aleur 6or Iint i ] :S i [ 1::S i//J Q V)aria#le// ] iS Console.;riteLineI IintJ)aria#le JS T )aria#le-]1::S 6or Iint i ] :S i [ 1::S i//J S-stem.Console.;riteLineIV)aria#le//JS
1er a)ril 2::5
17
c&arfg te'te ] ne9 c&arfg Q`t`1à`1`m`1`t`1`l`1è`1`m`1ò`1ù`1`s`1`s`1è`TS 6i'ed Ic&arV !ointeur ] ^te'tef:gJ Q !ointeurf3g ] `!`S V!ointeur ] !ointeurf3gS 6or Iint i ] :S i [] te'te.Len t&S i//J S-stem.Console.;riteI!ointeurfigJS T S-stem.Console.Deadae-IJS T
intV est un t-!e de donne !ointeur. Cest un !ointeur )er un o#$et de t-!e int. V)aria#le corres!ond au contenu de la )aria#le. Cest la donne G !ro!rement !arle. )aria#le corres!ond G ladresse mmoire de la )aria#le. ^)aria#le corres!ond G ladresse mmoire de la )aria#le. Stac?alloc est lqui)alent de ialloca de la #i#liot&4que runtime C1 il a allou 4:: octets et retourn un !ointeur. <erri4re on !eut mani!uler le !ointeur comme en C. 6i'ed !ermet de 6aire un !ointeur 6i'e1 la )aria#le A !ointeur B ne !eut Htre modi6i ni !ar notre code ni !ar le (ara e Collector. %nsa6e d6ini des #loc?s de code1 il !eut Htre mis seul a)ant un #loc? comme tr- Iunsa6eQ .VinstructionsV. TJ ou il !eut sa$outer au' s!ci6ications dun #loc? e'istant comme dans le'em!le. Le code mis en A unc&ec?ed B Iun calcul ou un #loc?J est un !eut !lus !er6ormant mais les rsultats !eu)ent c&an er1 unc&ec?ed consiste G ne !lus contrYler les d!assements de )aleurs. <e ce 6ait le com!ortement est de retourner G la )aleur minimale quand on est tro! rand et in)ersement. I@!!lication des o!rations #inaire a)ec mise G lcart des retenuesJ. "ar d6aut a)ec 0isual Studio tous les codes sont en unc&ec?ed1 de ce 6ait1 !our que ces #loc?s aient )raiment un sens1 il 6aut a)oir le contrYle de d!assement Ic&ec?#o' dans A !ro$et\!ro!rit du !ro$et\ nrer\o!tions a)ances B dans 0isual Studio ou sous Eono<e)elo! dans A !ro$et\o!tions\con6i uration\de#u \C!tions du com!ilateur BJ.
C#
int )arS unc&ec?ed Q )ar ] int.Ea'0alueS )ar V] 2S S-stem.Console.;riteLineIRNnR /)ar.,oStrin IJ / RNnR / IIintJIint.Ea'0alue /1JJ.,oStrin IJJS T S-stem.Console.Deadae-IJS
Detour Console:
-2 -2143453245
Si )ous na)eF !as dans les o!tions du com!ilateur le contrYle de d!assement de coc& !ar contre )ous !ou)eF lacti)er sur un calcul ou un #loc? a)ec le mot cle6 A c&ec?ed B.
C#
int a ] int.Ea'0alueS int # ] 12S #]c&ec?edIa V #JS .. ce code n4rera ici une erreur de t-!e C)er6lo9+'e!tion . Console.;riteLineI#JS
1er a)ril 2::5
2:
3 Lorient C#$et en C#
3.1 Introduction
Comme nous le disions dans lintroduction1 lorient o#$et est un mo-en de re rou!er des )aria#le !our !ou)oir traiter des ensem#le comme des entits !ro!res. C# est un lan a e 6ortement orient o#$et. Les o#$ets corres!ondants G quelque c&ose1 il 6aut les d6inir a)ant den utiliser. "ar c&ance le 6rame9or? .*+, !ro!ose d$G une #elle liste do#$ets. La A d6inition B est a!!ele la classe et la )aria#le contenant lo#$et est a!!eles linstance. @)ant de samuser G instancier nim!orte quoi nous allons )oir comment on cre des classes sim!les Iqui ran ent des )aria#lesJ1 nous )errons ensuite comment utiliser ces classes..
3.2 %sin
<ans la !artie 2 )ous a)eF certainement trou) que lon utilisait #eaucou! A S-stem. B. S-stem est un *ameS!ace que lon !eut aussi a!!eler A es!ace de nom B. Les *ameS!aces ser)ent G ran er les classes un !eu comme dans des dossiers. Si lon )eut sconomiser dcrire S-stem G c&aque 6ois que lon )eut accder G un o#$et de ce *ameS!ace1 il su66it de mettre au d#ut du 6ic&ier A usin S-stem S B. Ces im!orts des!aces de nom !ermettent daccder directement G tous les lments contenus Ia!!art les *ameS!aces quil contientJ sans a)oir G mentionn ou il est ran . "lus )ous 6erreF de usin !lus )ous aureF de !ro!ositions G lauto com!ltion1 doe lintrHt de limiter lusa e des usin car cela !ermet une auto com!ltion !lus ra!ide et !lus !ertinente.
3.3 Instanciation
*ous allons d6inir des classes mais !our sa)oir comment on les instancie nous allons da#ord re arder cette classe int re dans le =rame9or? que nous a)ons d$G utilise a)ec une instanciation sim!le : le Strin
C#
S-stem.Strin )ar] ne9 S-stem.Strin Ine9 c&arfg Q`l`1è`1`t`1`t`1`r`1è`TJS
<com!osons cette instruction. *ous a)ons dans un !remier tem!s le t-!e et le nom de la )aria#le !our la dclaration. +n suite nous a)ons le mot cle6 ne91 on utilise G nou)eau le t-!e que lon a!!elle comme une 6onction. Cette notion de 6onction et dar ument G la dclaration seront e'!liqus dans la !artie 3.5.2. *ous attendons aussi un ar ument. <ans cet e'em!le lar ument est un @rra- de c&ar1 comme on com!te en mettre un qui ne'iste !as1 qui nest !as dclar1 #re6 un nou)eau comme !our le Strin on met le mot cle6 ne9 et on met de la donne.
Demarque : les classes anon-mes sont une nou)eaut de C# 3.:1 si )ous d)elo!!eF sur un lo iciel e'istant1 il )ous 6audra s!ci6ier de com!iler a)ec la s-nta'e C# 3.: !our !ou)oir 6aire ce qui )as sui)re. Le code C#2.: com!ilera normalement en C#3.: sans modi6ications. "ar6ois on doit crer une classe !our ran er des )aria#les1 mais !our une utilisation locale et qui ne sortira !as de la mt&ode en court. <ans ce cas il e'iste une s-nta'e de dclaration de classe !rcise qui n4re des A Classes anon-mes B. Les classes anon-mes ont un nom de classe nr G la )ole sans in6ormer le d)elo!!eur de ce 6ait on ne !eut !as s!ci6ier e'!licitement le t-!e de la )aria#le qui )as contenir cette classe. "our dclarer une )aria#le dont on ne connait !as le t-!e1 il e'iste un mot cle6 a!!ro!ri : A )ar B. Le mot cle6 A )ar B !ermet de laisser le com!ilateur t-!er la )aria#le G notre !lace. %ne classe anon-me se rem!lie un !eu comme un arra-1 e'em!le :
C#
1er a)ril 2::5
21
)ar classeanon-me ] ne9 Q a]11 #]121 c]Rte'teR1 d] Rquelquec&oseRTS Console.;riteLineIclasseanon-me.#.,oStrin IJ/classeanon-me.cJS
Comme dit !rcdemment1 le 6rame9or? est un ensem#le de classes or anises dans des es!aces de noms1 !our linstant nous a)ons uniquement utilis des lments de S-stem. Me )ais )ous !rsenter des o#$ets de S-stem.Collection.(eneric. Ce *ameS!ace contient de quoi 6aire des listes d-namiques et de t-!e de )otre c&oi'1 ce t-!e doit Htre nomm. Le t-!e des lments contenus dans la liste doit corres!ondre au t-!e entre les c&e)rons.
C#
!u#lic List[int\ liste ] ne9 List[int\IJS liste.@ddI12JS
Ce t-!e de liste )ous !ermet de ran er1 a$outer1 enle)er1 modi6ier1 trier et c&erc&er les lments. 0ous !ourreF utiliser ces listes !our ran er des o#$ets de mHme t-!e ou de t-!e de mHme 6orme. <e ce 6ait !our 6aire des listes de t-!es anon-me1 #ien quil - ait des astuces1 que ce soit dcom!iler les assem#lies !our connaitre le nom de la classe anon-me ou autre elles sa)4rent rele)er de la #idouille et ne sont !as e'!licites G la lecture du code.
3.3.1 Lattri#ut et le modi6icateur dacc4s Cn a d6ini le mod4le o#$et comme un mo-en conce!tuel !our or aniser des )aria#les et les traiter !ar rou!e. Certaine )aria#les internes au' o#$ets ne requi4rent !as dinteractions de!uis dautres !arties a!!licati)es. <es acc4s !lus restreints entrainent !lus de 6acilit !our re!rer les erreurs1 en rduire le nom#re1 une auto com!ltion !lus !ertinente1 !lus de 6acilit si quelquun doit utiliser la classe et de ci#ler la documentation sur les )aria#les1 mt&odes et !ro!rits accessi#les.
Les attri#uts dans les classes comme dans les structures doi)ent a)oir de d6ini un de r dacc4s. Ces ni)eau' dacc4s sont d6inis !ar un de ces quatre mots cle6s: ' "u#lic : donne tout lacc4s G toutes les mt&odes de toutes les classes. ' "ri)ate : Destreint lacc4s G la classe mHme1 il sera sou)ent !r6ra#le dutiliser "rotected. ' "rotected : Comme "ri)ate1 la di66rence tant mince elle sera e'!lique dans la !artie sur l&rita e. ' Internal : internal retire lacc4s G toutes les mt&odes et tous les lments qui ne !arta ent !as la mHme assem#l- Iqui ne 6ont !as !arti du mHme 6ic&ier com!ilJ.
Ces modi6icateurs sont communs !our les classes1 les mt&odes1 les attri#uts1 les accesseurs1 cest donc im!ortant G connaitre et )ous aller les croiser sou)ent Isurtout les trois !remiersJ. Lattri#ut est donc la )aria#le sim!le dans la classe1 )ous en a)eF d$G )us dans la structure. De6aisons en "artial une !etite dclaration dattri#ut que lon )a instancier.
C# : 6ic&ier 2
usin S-stemS names!ace Console@!!lication Q !artial class Class Q !u#lic int a ]12S !u#lic const ulon constante ] Iulon J 125S
1er a)ril 2::5
22
T T
C# : 6ic&ier 1
usin S-stemS usin S-stem.Collections.(enericS names!ace Console@!!lication Q !artial class Class Q !u#lic strin # ] constante.,oStrin IJS !u#lic List[int\ liste ] ne9 List[int\IJS T static class "ro ram Q static )oid EainIJ Q Class )ar ] ne9 ClassIJS )ar.liste.@ddI)ar.aJS )ar.# /] R R / )ar.listef:g.,oStrin IJS
Console.;riteLineI)ar.#JS Console.Deadae-IJS T T T
La )aria#le dclare a)ec le mot cle6 A const B doit Htre attri#ue dans la mHme instruction et ne !ourra !lus Htre modi6ie. Cn )erra dautres mo-ens qui !eu)ent !araitre !lus !ratique !our limiter en criture les )aria#les.
3.4 La !ro!rit
Lorsque lon a des )aria#les assimiles G des o#$ets1 elles !eu)ent a)oir des contraintes autres que les contraintes in6ormatiques1 !our )iter quune )aria#le en6rei ne ces contraintes1 on !eut en d6inir G lattri#ution. <e !lus1 on !eut )ouloir contrYler lacc4s en lecture de certaines )aria#les ou mHme les mettre dans un 6ormat !lus !ro!ice que celui du 6onctionnement interne G lo#$et. 0oici un e'em!le de code1 noteF #ien les mots cle6s A et B1 A set B et A )alue B.
C#
class Class Q !rotected uint i)ar ] : S !u#lic uint a Q et Qreturn i)ar/1S T set Qi6 I)alue [ 1::J i)ar ] )alueS else i)ar ] 1::S T T T class "ro ram Q static )oid EainIJ Q Class o#$et ] ne9 ClassIJS 6or Iint i]:S i [ 12:S i//J Q o#$et.a ] iS
1er a)ril 2::5
23
Console.;riteLineIo#$et.aJS T Console.Deadae-IJS T T
@insi1 quand on a!!elle lattri#ut A a B dun o#$et de classe A Class B1 en ralit on acc4de G i)ar. Ce !rocd scurise la!!lication du 6ait que i)ar soit en A !rotected B et du cou! inaccessi#le !ar du code ne )enant !as de la classe. <ans notre e'em!le1 on em!Hc&e G la )aria#le de d!asser 1:: en )aleur interne1 elle !ourra retourner entre 1 et 1:1. Cn !ourrait tout G 6ait mettre !lusieurs instructions dans le et Iqui corres!ond G lacc4s en lecture de la )aria#le s!cialeJ. Cn !eut 6aire un accesseur a)ec seulement et ou seulement set !our la)oir en lecture seule ou criture seule. Les attri#uts ne sont !as 6orcment lis G une )aria#le interne1 elle !eut tout a 6ait mani!uler !lusieurs ou aucune )aria#le Idans ce dernier cas lintrHt sera limit !ar ra!!ort G une mt&odeJ. Com!arati)ement au mot cle6 A const B qui em!Hc&e toute criture1 le cou!le )aria#le !ri)e. et Isans setJ !ermet de modi6ier en interne les )aleurs.
3.5 Static
*ormalement !our accder G un attri#ut1 une !ro!rit ou une mt&ode1 on doit 6orcment crer un o#$et de la classe !our !ou)oir lutiliser. Le mot cle6 A static B !ermet da)oir des )aria#les et mt&odes utilisa#le non !as dune instance mais de la classe elle-mHme
C#
class Class Q static !rotected int i)ar ] : S static !u#lic int attri#ut Q et Q return i)ar/1S T set Q i6 I)alue [ 1::J i)ar ] )alueS else i)ar ] 1::S T T T class "ro ram Q static )oid EainIJ Q 6or Iint i]:S i [ 12:S i//J Q Class.attri#ut ] iS Console.;riteLineIClass.attri#utJS T Console.Deadae-IJS T T
Si $e )eu' une classe qui ser)e de A #oite G outils B $e !eu' crer des mt&odes statiques qui ne ncessitent !as que la classe soit instancie. Si on dclare la classe enti4re en statique1 cela entraine quon ne !ourra !as en 6aire dinstances et quil n- aura !as de constructeur. ,ous les lments dune classe statique doi)ent Htre s!ci6is en statique.
1er a)ril 2::5
24
Demarque : Les classes statiques sont un mo-en sim!le de 6aire un Sin leton. %n sin leton est un o#$et qui ne !eut Htre instenci quune seule 6ois1 ici la classe statique ne !eut a)oir quune A instance B. <ans le cas dune classe statique1 il 6audra utiliser !ri)ate au lieu de !rotected1 ce sera dtaill dans la !artie sur l&rita e.
3.2 Les mt&odes

Le mot 6onction )ous !araitrait certainement !lus clair et cest !our Ua que $usquG ce !oint du c&a!itre il marri)ait de lem!lo-er1 mais les 6onctions qui sont lis G des o#$ets ont une autre a!!ellation : ce sont des mt&odes. "our linstant nous na)ons )u que la mt&ode Eain qui sera trait et e'!lique en !remier lieu. "our com!rendre les mt&odes il 6aut sa)oir quelles sont d6inies !ar : un de r dacc4s1 un nom1 un t-!e de retour et des t-!es et un nom#re I!ou)ant Htre nulJ dar uments. Cette d6inition est a!!ele A !rotot-!e B ou A si nature B et a une s-nta'e !articuli4re. <ans cette !artie essentielle sur les mt&odes1 nous allons : ' commencer !ar e'!liquer la mt&ode Eain1 nous allons aussi )oir comment !asser des !aram4tres G le'cution1 comment une mt&ode retourne une )aleurd >re6 lessentiel de ce que lon a G com!rendre sur les mt&odes sera e'!liqu sur la mt&ode Eain que lon a #eaucou! utilise sans )raiment le'!liquer. ' *ous )errons ensuite comment crer une mt&ode qui !ermette de nrer !ro!rement le contenu de la classe a)ec des ar uments Iles constructeursJ. ' "uis nous a#orderons comment !ro!oser !lusieurs A si natures B a)ec la mHme mt&ode Ila surc&ar eJ. ' Comment entrer une mt&ode e'istante dans une )aria#le ' Comment 6aire des A mini-mt&odes B !ratiques en ar ument ' +t en6in nous a#orderons les Itrateurs.
3.2.1Detour sur Eain Le C# est tr4s orient o#$et1 du cou! mHme la mt&ode qui se'cute au d#ut du !ro ramme est ran e dans une classe. Comme on a d$G #eaucou! utilis Eain re ardons-le directement !our !ou)oir e'!liquer clairement les c&oses.
C#
class "ro ram Q static int EainIstrin fg ar sJ Q 6oreac& Istrin s in ar sJ Console.;riteLineIsJS Console.Deadae-IJS return :S T T
Detour Console: e'cut manuellement : A C:NadresseNa!!lication.e'e a)ec des ar uments B
a)ec des ar uments
Comme )ous laureF remarqu1 Eain est Statique1 cest tout #onnement car lorsque le !ro ramme se'cute1 la classe contenant Eain nest !as instancie. @ntrieurement1 Eain na)ait 1er a)ril 2::5
25
!as dar ument et G la !lace de A int B il - a)ait le mot )oid. Le t-!e s!cial )oid que nous utilisions sert G dire que la mt&ode ne retourne rien. )oid est lallias de S-stem.0oid1 il nest utilis que !our mentionner que la mt&ode ne retourne !as de )aleur et en unsa6e !our 6aire !ointeur )ers donnes de t-!e inconnu. <e ce 6ait1 dans cet e'em!le1 Eain retourne une )aleur : :. Le mot cle6 return met 6in G la mt&ode et lui 6ait retourner la )aleur qui suit. =aire retourner une )aleur de t-!e int G un !ro ramme sert G s!ci6ier un code derreur. "ar con)ention1 le : si ni6ie que tout cest #ien drouler1 ensuite on !eut crer !lein de )aleur de retour !our si naler les di66rentes erreurs !ossi#les. %suellement1 il est !u#li a)ec le lo iciel une corres!ondance entre la )aleur de retour en cas derreur et les erreurs elles mHmes. Contrairement au C1 une mt&ode de)ant retourner une )aleur sans mot cle6 return ne !asse !as la com!ilation1 de ce 6ait une mt&ode qui a un t-!e de retour autre que )oid 6inira s-stmatiquement !ar un return. "ar6ois !our les !rocdures1 il !eut Htre !lus !ratique de 6aire un return true quand il n- a !as de !ro#l4me et 6alse G la !lace de le)er une e'ce!tion1 on mettra #ool !our le t-!e de retour. Eain a 4 Si natures !ossi#les :
C#
!u#lic !u#lic !u#lic !u#lic
static static static static
int )oid int )oid
EainIJ EainIJ EainIstrin fg ar J EainIstrin fg ar J
L@rra- de strin est com!os de lensem#le des c&aines qui sui)ent la commande en s!arant !ar des es!aces. 3.2.2Constructeur . destructeur 0ous trou)ereF sou)ent dans les classes non statiques des mt&odes dites jconstructeursk. Ce sont des mt&odes qui ser)ent G mettre des )aleurs !ar d6aut1 G crer des lmentsd Si on )oulait !ar e'em!le 6aire une classe qui ran e un $eu dallumette !roc&e de celui que lon a 6ait antrieurement :
C#
usin S-stemS class Meu Q readonl- !u#lic int n#re>atonetsS.. readonl- ] )aria#le ne !eut Htre accde readonl- !u#lic int n#reMoueursS.. en criture que dans le constructeur. !rotected int $oueurS !rotected int tourS !rotected int #atonetsS !u#lic strin fg nomsS !u#lic static uint n#re<InstancesS
.VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV V 0oici le Constructeur1 cest une mt&ode s!ciale sans t-!e de retour V et qui !orte le mHme nom que la classe. V Cn initialise ici les )aria#le de Meu !ro!re au' A o!tions B VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV. !u#lic MeuIint n#re>nts1 int n#reMrs1!arams strin fg nomsJ Q n#re<Instances//S n#reMoueurs ] n#reMrsS n#re>atonets ] n#re>ntsS t&is.noms ] nomsS t&is.init(ameIJS T .. PP Le !roc&ain e'trait de code sera G a$outer ici PP .. !u#lic )oid init(ameIJ ..Cette mt&ode !ermet dinitialiser une nou)elle !artie
1er a)ril 2::5
22
Q $oueur ] :S tour ] :S #atonets ] n#re>atonetsS T !u#lic #ool ,ourIJ ..e'cute un tour et ren)oie 6au' si d6aite. Q int tm!S tour//S i6 I$oueur [ n#reMoueurs-1J $oueur //S else $oueur ] :S S-stem.Console.;riteLineIR,our R/tour.,oStrin IJJS S-stem.Console.;riteLineIR@ R / nomsf$oueurg / RNnil reste R / #atonets.,oStrin IJ / R alumettesNn!reneF un nom#re dàllumettes entre 1 et 3 Ide6aut 3JRJS int.,r-"arseIS-stem.Console.DeadLineIJ1out tm!JS i6 Itm! \ : ^^ tm! [ 3J #atonets -] tm!S else #atonets -] 3S i6 I#atonets [ 1J return 6alseS return trueS T .. La mt&ode "erdu sera rem!lace dans la !artie sur la red6inition !u#lic strin "erduIJ Q return nomsf$oueurg/R a !erdu au #out de R /tour.,oStrin IJ/R ,ours.RS T lMeuIJ Q n#re<Instances--S T
T class "ro ram Q static )oid EainIJ Q Meu $eu ] ne9 MeuI15121RCro)a'R1R"o!iRJS 9&ile I$eu.,ourIJJS .. e'cutera le test $usquG ce quil retourne 6au' Console.;riteLineI$eu."erduIJJS .V 6or Iint i ]: S i [ 1::::S i//J Q Console.;riteLineIMeu.n#re<InstancesJS $eu ] ne9 MeuIi1 i1 ne9 strin fg Q R$oueur1R1 R$oueur2R TJS S-stem.,&readin .,&read.Slee!I1:JS T V. Console.Deadae-IJS T T
Demarque : 0oilG un e'trait de code susce!ti#le dclaircir lintrHt du mot cle6 static. Si )ous dcommenteF la #oucle 6or et essa-eF !lusieurs 6ois en modi6iant quelques )aleurs1 )ous !ourreF constater le 6onctionnement du ar#a e collector.quand le ar#a e collector )eut e66acer un o#$et il a!!elle de destructeur !uis su!!rime les donnes de linstance qui ne lont !as t. %n mot cle6 im!ortant na !as t a#ord : t&is. Il est ici em!lo- !our )iter un con6lit de noms. A t&is B corres!ond G linstance en cours de traitement donc t&is.noms corres!ond G la !ro!rit !u#lic quand noms seul corres!ond G la )aleur !ass en ar ument de la mt&ode. Le mot cle6 !arams est utilis ici dans le constructeur mais est o!tionnel et !eut Htre utilise !our nim!orte quelle mt&ode. Il est utilis !our le dernier ar ument1 il est sui)i dun t-!e arra- et 1er a)ril 2::5
23
dun nom de )aria#le IA noms BJ. ,ous les derniers ar uments G la!!el de la mt&ode de)ront Htre des strin s et rentrerons dans larra-. Sans le mot cle6 A !arams B1 linstanciation de la classe A Meu B naurait !as tait comme )u dans le'trait IA Meu $eu ] ne9 MeuI15121RCro)a'R1R"o!iRJS BJ mais a)ec un )rita#le arra- en ar ument IA Meu $eu ] ne9 MeuI15121ne9 strin fg QRCro)a'R1R"o!iRTJS BJ. "arams acce!te aussi la s-nta'e a)ec arra- en ar ument.
*ous utilisons le mot cle6 A out B dans la mt&ode statique A ,r-"arse B dInt321 ce mot cle6 a!!arait !our dire que lar ument !asse !ar r6rence. Cèst-G-dire que la )aria#le !ourra Htre modi6ie dans la mt&ode1 car les t-!es A )aleurs B ne sont $amais modi6ies quand ils sont !asss en ar ument sans mots cle6s s!ci6iant le contraire. %n mot cle6 tr4s !roc&e de out e'iste : re6. La seule di66rence est que lon utilise out !our une mt&ode qui )as donner une )aleur sans tenir com!te de lactuelle tant disque re6 sera !lus utilis !our traiter une )aria#le 6aire en sorte quelle ait une nou)elle )aleur G !artir de sa )aleur actuelle. <e ce 6ait1 re6 attend une )aria#le a-ant une )aleur attri#ue tandis que out une )aria#le dclare mHme sans attri#utions 6era la66aire. <e ce 6ait on nest o#li de !asser des )aria#le et non !as des )aleurs !our que la mt&ode !uisse mettre ses donnes quelque !art. ,r-"arse !roc4de comme "arse sau6 quil entre : dans la )aria#le au lieu de nrer des erreurs. Les mots cle6s !aram1 re6 et out !araissent dans les !rotot-!es.si nature des mt&odes qui les utilisent.
Le <estructeur na ni de t-!e de retour ni de de rs dacc4s ni dar uments. Son nom est celui de la classe et est !rcd dun tilde A l B. 3.2.3 La surc&ar e 0ous trou)eF !eut Htre quil nest !as !ratique de ne !as !ou)oir 6aire un o#$et !ar d6aut1 da)oir G s!ci6ier G c&aque 6ois tous les ar umentsd "our !ou)oir a)oir le c&oi' entre !lusieurs !ossi#ilit dar uments en entre il e'iste la surc&ar e des mt&odes. *ous allons !rocder G la surc&ar e du constructeur. La surc&ar e dune mt&ode !ermet de c&an er la si nature en ardant le mHme nom. %ne surc&ar e !ermet de c&an er les !aram4tres et le t-!e de retour.
La surc&ar e !eut aussi sa!!liquer G un o!rateur comme le A V B1 le A . B1 il su66it de !rcder lo!rateur du mot cle6 o!erator. <u 6ait que ce soit )ous qui d6inissieF le'cution )ous !ou)eF lutiliser a)ec la s-nta'e et la !riorit des o!rateurs sans !our autan #ien que ce soit recommand 6aire une e'cution qui corres!ond G une addition ou qui retourne une )aleur. Cn !eut aussi surc&ar er lo!rateur unaire de cast1 il - a deu' t-!es de d6inition de cast : im!licit et e'!licit. La surc&ar e !eut Htre dclare dans la classe dinstance source !our aller )ers un t-!e ci#le ou dans la classe ci#le source de t-!e quelconque et retourne un o#$et de classe. "our amliorer la lisi#ilit du code il est encoura dutiliser e'!licit dont le com!ortement est !lus !r)isi#le.
C#
class Meu Q d !u#lic MeuIJ Q n#re<Instances//S n#reMoueurs ] 2S n#re>atonets ] 15S t&is.noms ] ne9 strin fg QRCro)a'R1R"o!iRTS t&is.init(ameIJS T
!u#lic static Meu o!erator/IMeu un1Meu deu'J
1er a)ril 2::5
25
Q strin fg noms]ne9 strin fun.noms.Len t&/deu'.noms.Len t&gS int ! ]:S 6or Iint i]: S i[un.noms.Len t&Si//J nomsf!//g]un.nomsfigS 6or Iint i]: S i[deu'.noms.Len t&Si//J nomsf!//g]deu'.nomsfigS return ne9 MeuIun.n#re>atonets / deu'.n#re>atonets 1 un.n#reMoueurs / deu'.n#reMoueurs1 nomsJS T !u#lic static Meu o!erator- IMeu #1int aJ Q return ne9 MeuI#.n#re>atonets - a1 #.n#reMoueurs1 #.nomsJS T !u#lic static im!licit o!erator intIMeu aJQreturn a.n#reMoueursST !u#lic static e'!licit o!erator MeuIint aJQreturn ne9 MeuIa121R"o!R1 RCro)RJST .. I Demettre init(ame1 ,our1 "erdu et lMeu de le'em!le !rcdent J d T class "ro ram Q static )oid EainIJ Q int cS Meu $eu ] ne9 MeuIJS Meu a ] $eu / ne9 MeuI251 31 RDiriR1 R=i6iR1 Rani &t 9&o sa- *IPRJS a ] a - 12S c ] aS a /] IMeuJcS 9&ile Ia.,ourIJJS Console.;riteLineIa."erduIJJS Console.Deadae-IJS T T
@insi im!lment1 laddition !ermet de crer un $eu a-ant les $oueurs en commun1 le nom#re de #Ltonnets initial additionn Idu 6ait quils soient en readonl- $e suis o#li de recrer une instanceJ. Cn !eut son er !ar e'em!le dans une )entuelle )olution du $eu en rseau 6usionner les salles de $eu' !ar un sim!le o!rateur /1 a)ec ce mHme o!rateur en cast im!licite )ers un int connaitre le nom#re de $oueurs dans les instances dun ser)eur. Cn !ourrait aussi G !artir de lo!tion A n#re>atonets B nrer en un cast une instance a!!ro!rie !ar d6aut.
3.2.4<ele ate Le dele ate est comme un !ointeur de 6onction1 cèst-G-dire une )aria#le qui indique une 6onction !ou)ant sutiliser comme telle. Ce !rinci!e !ermet de !asser une mt&ode en ar ument et aussi de !ou)oir modi6ier le'cution sui)ant ltat dmune )aria#le dele ate. Cn commence !ar nrer un t-!e de dl u1 !uis ou !eut dclarer des dl us a)ec un de r dacc4s in6erieur ou al G celui du t-!e. Le t-!e de dl u corres!ond G une si nature1 un t-!e dl u indique les t-!es des ar uments et le t-!e de retour de la mt&ode que le dl u associ )a contenir. LintrHt de crer des t-!es de dl us est a)ant tout de scuriser le code et de sa)oir comment utiliser le dl u. <e !lus si on entre dans un dl u une mt&ode qui a !lusieurs surc&ar es1 linter!rteur dduira la quelle !rendre !our que les si natures entre la surc&ar e et le t-!e de dl u corres!ondent.
Le'em!le ici montre !lus un e'em!le dutilisation que lutilit relle des dl us1 mais dautres e'em!les !ourront )ous clairer sur lutilit d4s la !artie !roc&aine.
C#
1er a)ril 2::5
27
usin S-stemS class test<ele ate Q !u#lic dele ate int t-!e<e<ele ueIre6 int aJS..<claration : t-!e de dl u ..les mt&odes associes de)ront r!ondre G sa si nature : int nomIre6 int )arJ !u#lic static int incrementerIre6 int *om#reJ Q return //*om#reS T T class "ro ram Q static )oid EainIJ Q int 0aleur ] :S ..ci dessous on dclare une instance du dl u test<ele ate.t-!e<e<ele ue a ] test<ele ate.incrementerS .. le dl u sans !arent&4se corres!ond G la )aria#le .. la mt&ode sans !arent&4se corres!ond G làdresse 9&ile IaIre6 0aleurJ [ 1::J S .. a)ec !arent&4ses la mt&ode est e'cute. Console.;riteLineI0aleurJS Console.Deadae-IJS T T
Les t-!es de dl us sont accessi#les comme des lments statiques. <ans cet e'em!le sim!le nous a)ons utilis a comme un !ointeur )er la mt&ode incrmenter. *ous !ou)ons aussi utiliser des dl us en !aram4tres1 nous )errons cela dans la !artie qui suit. *oteF le !oint )ir ule a!r4s le 9&ile : seule la condition sera e'cute $usquG Htre 6ausse. 3.2.5 Les )nements Les )4nements 6ont !arti dun t-!e de !ro rammation G !art enti4re1 on !arle de !ro rammation )4nementielle qui so!!ose !artiellement G la !ro rammation !rocdurale. La !ro rammation )nementielle consiste G ra ir en 6onction des )4nements. Les a!!lications G inter6aces ra!&iques sont sou)ent associes au' conce!ts de !ro rammation )nementielle. "ar e'em!le1 un utilisateur qui clique sur un des #outons de linter6ace lance une !rocdure. Le 6ait que lutilisateur !uisse G tout moment a ir sur nim!orte quel #outon entend que ce nest !as une !rocdure G )aria#le qui se droule de mani4re uni6orme. Cest #ien a ir en 6onction des interactions. <ans nos e'em!les nous allons utiliser sans quitter notre console les )4nements !our )oir leur 6onctionnement.
C#
t&is.#utton1 ] ne9 S-stem.;indo9s.=orms.>uttonIJ t&is.#utton1.Clic? /] ne9 S-stem.+)entcandlerIt&is.#utton1iClic?JS
Les )4nements sont des dl us )oire des listes de dl us qui sa!!ellent G !eut !rHt comme de sim!les mt&odes. <ans le'trait nr de ;in=orm ci-dessus nous )o-ons que le #outon a !ar d6aut un )4nement e'istant. Le !lus sou)ent ce t-!e de dl u sera celui du 6rame9or? : +)entcandler I*ous )errons quelle si nature corres!ond G ce t-!e de dl uJ. L)4nement ntant !as une notion tr4s sim!le G int rer $ai !ro!os deu' e'em!les. Les )4nements se dclarent a)ec le mot cle6 A e)ent B et un t-!e de dl u. %n )4nement ne !eut Htre e'cut que de!uis la classe il est dclar mais !eut Htre modi6i de!uis une autre sil est !u#lic.
C#
1er a)ril 2::5
3:
usin S-stemS class e'em!le1 Q .. +)entcandler est un dl u de mHme si nature que celui-ci-dessous. .. !u#lic dele ate )oid elemIo#$ect sender1+)ent@r s eJ S .. !u#lic e)ent elem e)enementS !u#lic e)ent +)entcandler e)enementS !u#lic )oid addie)enementIint iJ Q .. e)enementIt&is1 +)ent@r s.+m!t-JS Il4)e une e'ce!tion si aucune mt&ode assiciesJ s9itc& IiJ Q case 1: e)enement/]ne9 +)entcandlerIe'em!leie)enement1JS #rea?S case 2: e)enement /] ne9 +)entcandlerIe'em!leie)enement2JS #rea?S case 3: e)enement /] ne9 +)entcandlerIe'em!leie)enement1JS e)enement /] ne9 +)entcandlerIe'em!leie)enement2JS #rea?S de6ault: e)enement -] ne9 +)entcandlerIe'em!leie)enement1JS #rea?S T T !u#lic )oid e'ecuteIJ Qe)enementIt&is1 +)ent@r s.+m!t-JST !u#lic static )oid e'em!leie)enement1Io#$ect sender1 +)ent@r s eJ QConsole.;riteLineIRe'ecution de la mt&ode 1RJST !u#lic static )oid e'em!leie)enement2Io#$ect sender1 +)ent@r s eJ QConsole.;riteLineIRe'ecution de la mt&ode 2RJST T
class "ro ram Q static )oid EainIJ Q e'em!le1 a ] ne9 e'em!le1IJS 6or Iint i]1S i [ 2S i//J Q Console.;riteLineIi.,oStrin IJ / RiiiiiiiiNnRJS a.addie)enementIiJS a.e'ecuteIJS T S-stem.Console.Deadae-IJS T T
<ans notre !remier e'em!le l)4nement est utilis de mani4re tr4s !rocdurale. <ans le deu'i4me e'em!le #ien que ce ne soit !as )ident en console nous allons montrer quelque c&ose de !lus A )4nementiel B1 nous allons lo uer ltat dune )aria#le.
C#
usin S-stemS class e'em!le2 Q !u#lic dele ate )oid e)enementcandlerIe'em!le2 sender1 +)ent@r s eJS !u#lic e)ent e)enementcandler litS
1er a)ril 2::5
31
!u#lic e)ent e)enementcandler ecritS !rotected strin ilo a#leS !u#lic strin Lo a#le Q et Q i6Ilit P] nullJlitIt&is1+)ent@r s.+m!t-JS return ilo a#leS T set Q ilo a#le])alueS i6 Iecrit P] nullJ ecritIt&is1 +)ent@r s.+m!t-JS T T !u#lic #ool s9itc&Lo IJ Q i6 Ilit ]] null ^^ ecrit ]] nullJ Q lit ] ne9 e)enementcandlerIaccesLectureJS ecrit ] ne9 e)enementcandlerIacces+critureJS return trueS T lit ] nullS ecrit ] nullS return 6alseS T !u#lic static )oid accesLectureIe'em!le2 sender1 +)ent@r s eJ Q Console.;riteLineIR@cc4s en lecture:R / sender.ilo a#leJS T !u#lic static )oid acces+critureIe'em!le2 sender1 +)ent@r s eJ Q Console.;riteLineIR@cc4s en ecriture:R / sender.ilo a#leJS T
T class "ro ram Q static )oid EainIJ Q e'em!le2 # ] ne9 e'em!le2IJS #.s9itc&Lo IJS #.Lo a#le ] RtestRS #.Lo a#le ] #.Lo a#leS Console.;riteLineI#.Lo a#leJS #.s9itc&Lo IJS #.Lo a#le ] Rsans lo cèst moins )er#eu'RS #.Lo a#le ] #.Lo a#leS Console.;riteLineI#.Lo a#leJS S-stem.Console.Deadae-IJS T T
Le terminal nest !as la !lus ada!t des inter6aces !our !arler d)4nements mais $es!4re que ces e'em!les )ous su66iront !our )ous a!!ro!rier les notions d)4nements qui seront utiliss dans de )rais !ro rammes .*+,. 3.2.2 Et&odes anon-mes et +'!ressions lam#da Les mt&odes anon-mes 6ait !artie des nou)eauts du C#2.:. Cet outil !ermet de crer une mt&ode !oint !ar un dl u sans a)oir G la mettre dans une classe : Lutilisation est sim!le :
C#
usin S-stemS
1er a)ril 2::5
32
class test<ele ate Q !u#lic dele ate )oid *o@r IJS !u#lic dele ate )oid @r <ele ateI*o@r aJS !u#lic )oid e'ecuter1:=oisI*o@r 6onctionJ Q 6orIint i]:Si[1:Si//J 6onctionIJS T !u#lic )oid e'ecuter1:=oisI@r <ele ate 6onction1*o@r ar umentJ Q 6or Iint i ] :S i [ 1:S i//J 6onctionIar umentJS T T class "ro ram Q static )oid EainIJ Q test<ele ate )ar ] ne9 test<ele ateIJS test<ele ate.*o@r a66ic&e@ ] dele ateIJ Q Console.;riteIRaRJS TS )ar.e'ecuter1:=oisIa66ic&e@JS Console.;riteLineIRNniiiiiiiiiiiiiiiiiiiiiiiiiNnRJS test<ele ate.@r <ele ate a ] )ar.e'ecuter1:=oisS .. )ar.e'ecuter1:=oisIa1a66ic&e@J S ou !lus instructi6 : )ar.e'ecuter1:=ois I dele ateItest<ele ate.*o@r 6onctionJQ6orIint i]:Si[1:Si//J 6onctionIJST1 dele ateIJ Q Console.;riteIRaRJS T JS Console.Deadae-IJS T T
0oici un e'em!le asseF sim!le et tordu G la 6ois1 il nous montre une !artie du !otentiel des dl us quels quils soient. *oteF que les dl us anon-mes sont t-!s automatiquement !our entrer dans la )aria#le ou en ar ument. 0ous !ou)eF 6acilement ima iner une attri#ution conditionnelle dans la quelle le 6ormata e d!endra de la mt&ode !oint !ar la )aria#le dl ue. Demarque : la !artie qui suit sur le'!ression lam#da et les mt&odes de'tension est com!ose essentiellement de nou)eauts du C# 3.:1 si )ous d)elo!!eF sur un lo iciel e'istant1 il )ous 6audra s!ci6ier de com!iler a)ec la s-nta'e C# 3.: qui est rtro com!ati#le !our !ou)oir 6aire ce qui )as sui)re. Les e'!ressions lam#da sont des dl us anon-mes limits G une instruction1 la s-nta'e est claire1 ra!ide et lisi#le mais on ne !eut mettre de #oucles. Si le t-!e de dl u attendu a un t-!e de retour1 la seule A instruction B de le'!ression lam#da sera retourne. La s-nta'e de le'!ression lam#da est sim!le : les !aram4tres du dl u anon-me1 le si ne A ]\ B !uis linstruction.
C#
Iint ar 11 int ar 2J ]\ ar 1/ ar 2 ..dele ateIint ar 11int ar 2JQreturn ar 1/ar 2ST ar ]\ ar / 4.. dele ateIint ar JQreturn ar /4ST .. Le t-!e du !aram4tre !rcdent d!end du t-!e ..dl u attendu Idonc !as 6orcment intJ IJ ]\ Console.;riteIRaRJ..dele ateIJQConsole.;riteIRaRJST
0oici trois e'em!les &ors conte'te. Si on ne s!ci6ie !as le t-!e il est s!ci6i automatiquement et sil - a un seul !aram4tre t-! im!licitement !as #esoin des !arent&4ses !our lisoler. De6aisons la mHme c&ose que tout G l&eure a)ec ces lam#da e'!ressions.
1er a)ril 2::5
33
C#
usin S-stemS class test<ele ate Q !u#lic dele ate )oid *o@r IJS !u#lic dele ate )oid @r <ele ateI*o@r aJS ..ici on dclare une instance du dl u !u#lic )oid e'ecuter1:=oisI*o@r 6onctionJ Q 6orIint i]:Si[1:Si//J 6onctionIJS T !u#lic )oid e'ecuter1:=oisI@r <ele ate 6onction1*o@r ar umentJ Q 6or Iint i ] :S i [ 1:S i//J 6onctionIar umentJS T T class "ro ram Q static )oid EainIJ Q test<ele ate )ar ] ne9 test<ele ateIJS test<ele ate.@r <ele ate a ] )ar.e'ecuter1:=oisS )ar.e'ecuter1:=ois I ..Itest<ele ate.*o@r 6onctionJ ]\ aI6onctionJ1 6onction ]\ aI6onctionJ 1 IJ ]\ Console.;riteIRaRJ JS Console.Deadae-IJS T T
*ous a)ons )u lessentiel sur les mt&odes et les dl us1 nous allons dsormais )oir comment on !eut lier nos mt&odes G des o#$ets du 6rame9or?.
3.2.3 Et&ode de'tension. Les mt&odes de'tensions sont des mt&odes statiques qui !ermettent de sutiliser comme si elles taient !ro!re G une classe autre que celle dans la quelle elle est d6inie. Me me'!lique1 si )ous )ouleF 6aire une mt&ode de traitement de strin 1 )ous nalleF !as !ou)oir modi6ier la classe strin du 6rame9or? !our a$outer une mt&ode de traitement1 donc )ous alleF de)oir crer une classe a)ec une mt&ode statique !uis 6aire a!!el G cette classe !our le traitement. La mt&ode de'tension !ermet da!!liquer la mt&ode statique comme si elle tait dans la classe. "ar e'em!le ci dessous on cre une mt&ode qui !ermet de na)oir G crire que )ar.;riteIJ a)ec )ar )aria#le de t-!e strin au lieu de 6aire Console.;riteLineI)arJ.
C#
usin S-stemS static class Strin ,ool>o' Q static int titleInde' ] :S !u#lic static )oid ;riteIt&is strin sJ Q Console.;riteLineIsJS T !u#lic static strin title=ormatIt&is strin s1int iJ Q return RNnR / RiR / I//titleInde'J.,oStrin IJ / RiR / s.,o%!!erIJ / RiR / i.,oStrin IJ / RiR / RNnR S T
1er a)ril 2::5
34
T class "ro ram Q static )oid EainIJ Q 6orIint i]:Si[1:Si//J IR#on$our R/REonsieurRJ.title=ormatIiJ.;riteIJS Console.Deadae-IJS T T
Le mot cle6 qui sert G s!ci6ier que la mt&ode est une mt&ode de'tension est le mot cle6 t&is1 on mettra tou$ours ce t&is a)ec le !remier ar ument Iqui est lo#$et qui !rc4de le !oint lors de la!!elJ.
3.2.5 Itrateurs Certaines mt&odes sont a!!eles des itrateurs1 elles utilisent le mot cle6 -ield. Ces mt&odes retournent des o#$ets I+numera#le ou I+numerator I*ous !ri)il ierons I+numera#le qui !eut Htre utilise dans un 6oreac&J. *ous allons )oir comment 6aire a)ec et sans le 6oreac& !our que )ous !uissieF com!rendre comment sont les o#$ets que nous utilisions. I+numera#le et I+numerator ne contiennent !as le rsultat mais le mo-en d- accder1 !our !reu)e1 le'em!le modi6iera le rsultat a!r4s la dclaration de lnumra#le et le !arcourra deu' 6ois a)ec deu' rsultats di66rents.
C#
usin S-stemS usin S-stem.CollectionsS static class Strin ,> Q !u#lic static int I ] :S !u#lic static )oid ;riteIt&is strin sJ Q Console.;riteLineIsJS T !u#lic static I+numera#le title=ormatIt&is strin s1 int limitJ Q 6or Iint i ]1Si[]limitSi//J -ield return RNnR/RiR/i.,oStrin IJ/RiR/s.,o%!!erIJ /RiR/I//IJ.,oStrin IJ/RiR/RNnRS -ield #rea?S T T
class "ro ram Q static )oid EainIJ Q I+numera#le enumera#le ] R#on$our EonsieurR.title=ormatI1::JS .. on a cr l`numra#le a)ec title=ormat I+numerator enumerateur ] enumera#le.(et+numeratorIJS .. on e'trait l`numrateur Strin ,>.I ] 5S .. on !roc4de G une modi6ication qui c&an era le rsultat .. conclusion rien nàs encore t calcul. 6or Iint i ] :S i [ 1::S i//J Q .. si on ne commenUait !as !ar un Eo)e*e't le !remier rsultat serait RnullR enumerateur.Eo)e*e'tIJS
1er a)ril 2::5
35
strin s ] enumerateur.Current as strin OO RerreurRS .. caste en strin Isi im!ossi#les contiendra RerreurRJ Strin ,>.I ] Strin ,>.I Z 1: ]] : O Strin ,>.I V 2:Strin ,>.IS .. multi!lie !ar 2 toutes les 1: itrations I .. conclusion : les strin s sont calculs au 6ur et G mesure s.;riteIJS T Strin ,>.I ] :S Console.Deadae-IJS .. !arcour a)ec 6oreac&: 6oreac& Istrin s in enumera#leJ s.;riteIJS Console.Deadae-IJS T T
nield est un mot cle6 qui est central dans le linq #ien que relati)ement cac&1 cette tec&nolo ie )ous !ermet de $ouer a)ec des numra#les1 de les im#riqus a)ec une 6acilit tonnante1 et #iensur G lacc4s en lecture1 Ua e'cute le ncessaire !our accder G la donne. nield nest utilisa#le qua)ec un des deu' mots cle6s qui suit : Deturn et >rea?. nield return a$oute une entre dans lnumrateur et -ield #rea? arrHte le'cution du #loc?. nield #rea? em!lo- dans notre e'em!le1 il ne sert G rien.
3.3 L&rita e1 le !ol-mor!&isme et les inter6aces

3.3.1 Introduction L&rita e est un mo-en do66rir au' classes toutes les mt&odes et tous les attri#uts !u#lic et !rotected dune classe e'istante. Contrairement au C//1 le C# ne !ermet !as d&riter de !lusieurs classes #ien que les inter6aces !ermettent de 6aire un qui)alent. L&rita e conduit G des similitudes entre les o#$ets et donc de la sim!licit !our a!!rendre. *ous ne la)ions !as )u mais tous les o#$ets &ritent de lo#$et A o#$ect B. C#$ect est la classe G la #ase de tout1 cest o#$ect qui im!lmente la mt&ode ,oStrin que lon a #eaucou! utilis. Cette mt&ode tant de la classe m4re A uni)erselle B1 elle est im!lmente !ar d6aut !ar toutes les classes. Le !ol-mor!&isme dans le 6rame9or? est un outil !ratique qui !ermet !ar e'em!le de ran er dans une liste t-!e des o#$ets de classes di66rentes !our !eu quils se com!ortent !areil. ,ous les o#$ets !eu)ent Htres a!!els comme des o#$ets dun de leurs t-!es !arents. <e ce 6ait toutes )aria#les quelque soient leur t-!e !eu)ent Htre utilis comme des )aria#le de t-!e o#$ect. ,oute )aria#le !eut Htre !asse en ar ument dune mt&ode qui attend un o#$et de t-!e A o#$ect B.
Les inter6aces sont des es!4ces de classes qui ne ser)ent quG Htre A &rites B Idans le cas dune inter6ace1 on dit quelle est A im!lmente BJ. Quand on im!lmente une inter6ace on aranti un com!ortement1 si on im!lmente !ar e'em!le linter6ace I+numera#le1 notre o#$et !ourra #n6icier de linq et Htre numr dans un 6oreac&. <ans le'em!le !rcdant on utilisait I+numera#le et I+numerator comme les t-!es des )aria#les mais cest $uste rLce au 6ait que le !ol-mor!&isme marc&e a)ec les inter6aces en !lus des classes m4res. <e ce 6ait !eut im!orte le t-!e de retour qui entrera la donne dans ma )aria#le d4s lors que ce t-!e im!lmente linter6ace I+numera#le car ce retour aura 6orcment le com!ortement attendu.
Lorient o#$et initie des nou)eau' mots-cle6s de restriction de droits1 commenUons !ar re'!liquer les mots que nous connaissons d$G dans ce conte'te d&rita e : ' !u#lic : Les lments !u#lic dune classe sont l us au' classes en6antes. ' !rotected : Les lments !rotected dune classe sont l us au' classes en6antes.
1er a)ril 2::5
32
' '
!ri)ate : Les lments !ri)ate dune classe ne sont !as &rit au' classes en6antes. static : Cn ne !eut !as 6aire &riter une classe s!ci6ie en static. Les lments statiques dune classe non statique qui sont en !u#lic ou !rotected !eu)ent Htres accds !ar les classes en6ante mais ne sont !as G !ro!rement !arl &rites. Le mot cle6 A #ase B !ermet daccder au' lments de la classe m4re sans se soucier de son nom Isutilise comme A t&is BJ. Comme les classes statiques ne !eu)ent &riter il est )u comme un non sens que de s!ci6ier des lments en !rotected1 de ce 6ait on utilisera !u#lic ou !ri)ate.
0oici une liste de quelques nou)eau' mots cle6s initis !ar la notion d&rita e: ' sealed : @ucune classe de !eut &riter dune classe dune mt&ode ou dune !ro!rit sealed Isi on )eut quun lment soit !u#lic sans que les classes 6illes en &rite !ar e'em!leJ. ' a#stract : Les classes a#straites ne sont !as utilisa#les directement1 elles ne ser)ent que de classes m4re !our 6aciliter et re rou!er la construction do#$ets de mHme 6orme. Les lments a#straits dune classe eu' doi)ent Htre d6ini1 ils sont comme des contraintes de mt&odes et )aria#le interne G d6inir. I%ne classe a#stract ne !eut Htre instanciJ ' )irtual : )irtual est 6onctionnellement comme a#stract G une di66rence !rHt : dans la classe m4re il - a une im!lmentation !ar d6aut que lon !eut ne !as red6inir.
Le 6rame9or? utilise #eaucou! l&rita e et ce mod4le de !ol-mor!&isme1 nous allons re)enir sur les e'ce!tions qui &ritent toutes de la classe e'ce!tion qui elle mHme &rite de C#$ect.
3.3.2+'em!les d&rita e : les e'ce!tions et t&ro9 Cet e'em!le est G cou!l a)ec celui de la !artie 2.5. <ans ce deu'i4me e'em!le $e cre un nou)eau t-!e de'ce!tion dont $e ne red6ini que le Constructeur. Ce t-!e de'ce!tion a les mHmes attri#uts et les mHmes !ro!rits que le'ce!tion !ar de6ault au dtail !rHt quil na quun constructeur. "our d6inir les )aria#les comme dans une e'ce!tion standard sim!lement1 $a$oute G mon constructeur le constructeur de la classe +'ce!tion.
C#
usin S-stemS class Eon+'ce!tion : +'ce!tion Q !u#lic Eon+'ce!tionIJ : #aseIRLe !ro#l4me est de t-!e customRJ Q Console.;riteLineIR+rreur s!ciale a)ec mon e'cutionRJS T T class "ro ram Q !u#lic static )oid EainIJ Q Dandom r ] ne9 DandomI<ate,ime.*o9.EillisecondJS 9&ile ItrueJ Q i6 I1 \] r.*e'tI:11::::::::JJ Q Eon+'ce!tion e ] ne9 Eon+'ce!tionIJS trQ t&ro9 eS T catc& IEon+'ce!tion e'ce!tJ
1er a)ril 2::5
33
Q Console.;riteLineIe'ce!t.,oStrin IJJS T 6inallQ e ] nullS T T T T T
La nou)elle classe est instancie et le)e comme nim!orte quelle e'ce!tion. Le mot cle6 t&ro9 !ermet de le)er une instance de'ce!tion1 il sera !lus commun de )oir A t&ro9 ne9 Eon+'ce!tionIJ S B mais ctait !our $usti6ier lusa e dun #loc? 6inall- !our la ds-allocation de mmoire. <ans le'em!le de la !artie 2.5 on !erUoit !lus nettement le !ol-mor!&isme mais nous aurons loccasion d- re)enir. 3.3.3 Ded6inition de mt&odes et dattri#uts Le constructeur est une red6inition !articuli4re )u que le nom nest !as le mHme mais !our les classes ou les lments a#stract on se )erra o#li de red6inir des lments qui e'istent d$G ce qui normalement est im!ossi#le. *ous allons utiliser deu' mots cle6s tr4s similaires dans ce conte'te : o)erride et ne9.
C#
usin S-stemS a#stract class mere Q !u#lic a#stract int lon ueur Q etST !u#lic a#stract int lar eur Q etS setS T !u#lic )irtual int aireIJ Q return lon ueurVlar eurST !u#lic )irtual )oid !rint@ireIJ Q Console.;riteLineIlon ueurVlar eurJS T T class 6ille : mere Q !ri)ate int laS !ri)ate int loS
!u#lic o)erride int lar eur Q et Q return laS T set Q la ] )alueS T T !u#lic o)erride int lon ueur Q et Q return loS T T !u#lic 6illeIJ Q la ] 2S lo ] 5S T !u#lic ne9 int aireIJ Qreturn Ilar eur/lon ueurJV2ST !u#lic o)erride )oid !rint@ireIJ Q Console.;riteLineIIlar eur / lon ueurJ V 2JS .. #ase.!rint@ireIJS T !u#lic o)erride strin ,oStrin IJ Q
1er a)ril 2::5
35
return Ron !eut d6inir comment ra i la mt&ode .,oStrin comme ceciR S T T class "ro ram Q !u#lic static )oid EainIJ Q mere m ] ne9 6illeIJS 6ille 6 ] ne9 6illeIJS Console.;riteLineIRa66ic&a e cast en m4re !uis en 6ille Io)errideJRJS m.!rint@ireIJS 6.!rint@ireIJS Console.;riteLineIRretour dàire cast en m4re et en 6ille Ine9JRJS Console.;riteLineIm.aireIJ / RNnR / 6.aireIJJS Console.Deadae-IJS T T
Detour Console:
a66ic&a e cast en m4re !uis en 6ille Io)errideJ 22 22 retour dàire cast en m4re et en 6ille Ine9J 3: 22
<ans cet e'em!le on a une classe a#straite m4re et une classe 6ille. Quand )ous tenteF dim!lmenter une !ro!rit ou une mt&ode1 )ous )erreF que )otre I<+ I0isual Studio ou Eono<e)elo!J )ous !ro!ose directement la structure de #ase. La s-nta'e des !ro!rits de la classe m4re est encore une nou)eaut du C#3.:1 on d6inie ce qui sera G im!lmenter. La li ne commente montre comment $aurais !u !ar e'em!le a!!eler la mt&ode !ar d6aut im!lmente !ar la classe m4re.
Le'em!le risque dHtre un #on com!lment de'!lication sur la di66rence entre la red6inition a)ec o)erride et la red6inition a)ec ne9. ' *e9 : !ermet de crer une mt&ode !ro!re G la classe 6ille qui sera a!!ele normalement sur une instance de cette classe 6ille. Si linstance de la classe 6ille est ran e dans une )aria#le de t-!e de la classe m4re si la mt&ode &omon-me est a!!ele ce sera la mt&ode !ar d6aut de la classe m4re qui sera a!!ele et non celle de la classe 6ille. ' C)erride : !ermet quand G lui de rem!lacer rellement la mt&ode de la classe m4re !our linstance de la classe 6ille quelque soit le conte'te. 3.3.4 Les inter6aces Les inter6aces sutilisent comme des classes a#straites1 on !eut les im!lmentes comme on &riterait dune classe. Cn d6ini dans linter6ace des mt&odes et !ro!rits G a)oir !our im!lmenter linter6ace !our !ou)oir #n6icier du !ol-mor!&isme li. Si on caste lo#$et a)ec linter6ace1 seules les mt&odes qui rel4)ent de linter6ace seront accessi#les.
Cest donc une 6orme d&rita e multi!le. Si lon re!ense au' mt&odes de'tensions1 $e )ous laisse com!rendre lintrHt du !ol-mor!&isme1 !ou)oir rduire le code et ne !as a)oir G le re6aire !our c&aque classe. Certaines inter6ace comme I+numera#le sont au cWur du 6rame9or?1 cette inter6ace doit Htre im!lmente que ce soit !our utiliser le mot cle6 -ield1 !our !ou)oir utiliser 6oreac&1 !our !ou)oir utiliser Linq2o#$ectd Les mt&odes des inter6aces !eu)ent Htres im!lmentes de deu' 6aUons : im!licitement ou e'!licitement. Les inter6aces on tou$ours tous leurs attri#uts !u#lics1 cest !ourquoi le de r dacc4s
1er a)ril 2::5
37
nest !as demand dans la dclaration de linter6ace. Cn ne !eut !as 6aire de mt&ode )irtual1 les inter6aces ta#lissent une structure G res!ecter
C#
usin S-stemS inter6ace Imere Q int lon ueur Q etST int lar eur Q etS setS T )oid aireIJS )oid !rint@ireIJS T class 6ille : Imere Q!ri)ate int laS !ri)ate int loS !u#lic 6illeIJ Qla ] 2Slo ] 5ST #re ion Imere Eem#res .. im!lmente e'!licitement int Imere.lon ueur Q et Q return loS TT .. im!lmente im!licitement !u#lic int lar eur Q et Q return laS T set Q la ] )alueS TT .. im!lmente e'!licitement )oid Imere.aireIJ QConsole.;riteLineIIlar eur/ IIImereJt&isJ.lon ueurJV2JST ..Im!lment im!licitement !u#lic )oid !rint@ireIJ QConsole.;riteLineIIlar eur / IIImereJt&isJ.lon ueurJ V 2JST #endre ion T class "ro ram Q !u#lic static )oid EainIJ Q Imere m2 ] ne9 6illeIJS 6ille 62 ] ne9 6illeIJS Console.;riteLineIRa66ic&a e cast en inter6ace !uis en 6ille Iim!licitJRJS m2.!rint@ireIJS 62.!rint@ireIJS Imere m ] ne9 6illeIJS 6ille 6 ] ne9 6illeIJS Console.;riteLineIRretour dàire cast en Im4re et en 6ille Ie'!licitJRJS m.aireIJS .VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV V la li ne qui suit ce commentaire ne !asse !as la com!ilation. V +rreur 1: V `6ille` ne contient !as une d6inition !our àire` et aucune mt&ode dè'tension V àire` acce!tant un !remier ar ument de t-!e `6ille` nà t trou)e V Iune directi)e usin ou une r6rence dàssem#l- est-elle manquante OJ VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV. .. 6.aireIJS Console.;riteLineIRerreurNnNnutilisons une liste maintenantRJS Imerefg list ] ne9 Imerefg Q 61 m1 m21 62 TS 6oreac& I)ar e in listJ
1er a)ril 2::5
4:
e.aireIJS Console.Deadae-IJS T T
3.3.5 Les attri#uts Les attri#uts sont des classes &ritant de attri#ut1 leurs usa e sert G modi6ier le com!ortement dlments Iclasses1 enums1 structs1 mt&odesJ. Les attri#uts ont une s-nta'e !articuli4re utilisant les croc&ets IA f g BJ. %n e'em!le !ratique ou les attri#uts sont utiliss cest la srialisation. Lusa e dun sim!le attri#ut !ermettra de ran er asseF 6acilement dans un 6ic&ier KEL toutes les donnes dun o#$et. +t a)ec un sim!le attri#ut on !eut demander G ce quun des c&am!s ne soit !as srialis. Me ne )ais !as )ous insister sur la s-nta'e !our srialiser Ioe il 6aut crer un 6lu' )ers un 6ic&ier te'teJ mais montrer comment rendre srialisa#le une classe. Si )ous )ouleF e'cuter cet e'em!le )ous aureF #esoin de la r6rence G S-stem.Duntime.SerialiFation.=ormatters.Soa! .
C#
usin usin usin usin
S-stemS S-stem.ICS S-stem.Duntime.SerialiFationS S-stem.Duntime.SerialiFation.=ormatters.Soa!S
fSerialiFa#leIJg !u#lic class +'em!leSerialisation Q !u#lic int serialiseS f*onSerialiFedIJg !u#lic strin nonserialiseS !u#lic +'em!leSerialisationIJ Q serialise ] 1333S nonserialise ] Rmon nom est Mir6on ri6en ra6ter RS T !u#lic )oid a66ic&a eIJ Q Console.;riteLineIRlment srialiF ] R/ serialise.,oStrin IJJS Console.;riteLineIRlment non srialiF ] R/ nonserialiseJS T T !u#lic class "ro ram Q !u#lic static )oid EainIJ Q +'em!leSerialisation )aria#le ] ne9 +'em!leSerialisationIJS )aria#le.a66ic&a eIJS .. La !artie qui suit !ermet de srialiser et dsrialiser1 .. $e ne màtarderait !as dessus1 le su$et tant les attri#uts. Stream stream ] =ile.C!enIR)aria#le.'mlR1 =ileEode.CreateJS Soa!=ormatter 6ormatter ] ne9 Soa!=ormatterIJS 6ormatter.SerialiFeIstream1 )aria#leJS stream.CloseIJS Console.;riteLineIRsrialisation 6inieNndsrialisation:RJS )aria#le ] nullS stream ] =ile.C!enIR)aria#le.'mlR1 =ileEode.C!enJS 6ormatter ] ne9 Soa!=ormatterIJS )aria#le ] I+'em!leSerialisationJ6ormatter.<eserialiFeIstreamJS stream.CloseIJS
1er a)ril 2::5
41
Console.;riteLineIRdsrialisation 6inie.RJS )aria#le.a66ic&a eIJS Console.Deadae-IJS T T

Detour Console:
lment srialiF ] 1333 lment non srialiF ] mon nom est Mir6on ri6en ra6ter srialisation 6inie dsrialisation: dsrialisation 6inie. lment srialiF ] 1333 lment non srialiF ]
Lattri#ut VSerialiFa#leIJ/ a automatiquement im!lment le ncessaire !our que la classe !uisse Htre srialise. *ous ne )oulions !as retenir un des c&am!s1 nous a)ons mis f*onSerialiFedIJg. Lattri#ut ce !lace au d#ut de llment et sa!!lique sur sa lo#alit.
C#
usin S-stemS static class Strin ,ool>o' Q static int titleInde' ] :S !u#lic static )oid ;riteIt&is strin sJ Q Console.;riteLineIsJS T fC#soleteIJg !u#lic static strin title=ormatIt&is strin s1 int iJ Q return RNnR / RiR / I//titleInde'J.,oStrin IJ / RiR / s.,o%!!erIJ / RiR / i.,oStrin IJ / RiR / RNnRS T T
0oilG un autre attri#ut sim!le !our mentionner quune mt&ode est d)alu. Len)ironnement de d)elo!!ement !rcisera les mt&odes que lon com!te retirer au' d)elo!!eurs !our les inciter G en utiliser dautres sils !r)oient de mettre G $our la li#rairie contenant la classe. Lattri#ut C#solete !eut se mettre sur nim!orte quel lment. ,ous les attri#uts sont des classes &ritant de S-stem.@ttri#ute.
4 Conclusion
*ous a)ons trait de mani4re tr4s s-nt&tique un su$et quasiment in!uisa#le1 le 6rame9or? .*+, )ous !ermettra dutiliser les connaissances de ce tutorial !our crer des sites 9e#1 crer des a!!lications 6enHtres1 6aire des a!!lications ra!&iques1 des li#rairiesd >re61 )ous !ourreF 6aire quasiment !resque tout ce qui est !ro ramma#le a)ec le 6rame9or? et le C#. *ous a)ons a#ord de !r4s ou de loin tous les mots cle6s du C# G le'ce!tion de quelques uns I)olatile1 loc?1 e'ternal et 9&ereJ.
"our ra!!el nous a)ons )u : ' L&istoire et 6onctionnement du C# ' Les t-!es )aleurs et strin ' Les o!rateurs
1er a)ril 2::5
42
' ' ' ' ' ' ' ' ' ' ' ' ' ' '
Les conditions Les #oucles Les @rra-s Comment rer les erreurs Comment utiliser les !ointeurs &rits du C// Les es!aces de nom Les modi6icateurs dacc4s1 les attri#uts et les !ro!rits Les mt&odes dont Eain1 les constructeurs et les destructeurs La surc&ar e des mt&odes Les dl us1 )4nements1 et e'!ressions lam#da Les itrateurs L&rita e Le !ol-mor!&isme Les inter6aces Les attri#uts
"our tirer !leinement !artie de ce !remier tutoriel1 )ous de)rieF son er G a#order dautres cours de <ot*et-=rance1 )ous a)eF dsormais le ni)eau requis. 0oici les cours )er les quels )ous !ourrieF )ous orienter. ' 0ous )ous intresseF au' a!!lications 6enHtres O )ous !ou)eF )ous diri er )ers le tutoriel traitant des ;in=orm. ' 0ous )ouleF 6aire des sites 9e# O le tutoriel @S".*+, ;e#=orm. ' 0ous )ouleF 6aire !ar e'em!le un $eu )ido1 intresseF )ous !eut Htre au tutoriel K*@. ' 0ous )ous intresseF G lacc4s au' #ases de donnes et 6ic&iers KEL1 le tutoriel @<C.*+, est aussi lG !our )ous. ' 0ous )ous intresseF G lintero!ra#ilit et au' a!!lications %ni' O !eut Htre de)rieF )ous )ous diri er )er le tutoriel Eono. ' 0ous )ouleF amliorer )os connaissances lo#ales sur les roua es du 6rame9or? O Le tutoriel traitant du 6rame9or? de)rait )ous satis6aire.
Cette liste )ous donne d$G un a)ant oht de ce que )ous !ourreF 6aire a)ec le C#. Mes!4re que ce c&a!itre ne )ous a !as !erdu1 et mHme ou)ert une en)ie au d)elo!!ement .*+,1 n&siteF !as a arder ce tutoriel sous le coude comme manuel de r6rence1 car $e ne !ense !as que lon !uisse tout int rer dune seule traite.
1er a)ril 2::5

UploadedFile 130338580799467993

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

UploadedFile 130338580799467993

Uploaded by

Copyright:

Available Formats

1

1er a)ril 2::5

1er a)ril 2::5

1.1 Quest-ce quun lan a e de !ro rammation

1.2 "ourquoi lorient o#$et

1.3 %n !eu d&istoire

1er a)ril 2::5

static class "ro ram Q static )oid EainIJ Q

1er a)ril 2::5

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

2 La s-nta'e !rocdurale : lo ique C.C// a!!lique en C#

1er a)ril 2::5

2.1 0aria#les1 o!rateurs numrique et t-!es.

1er a)ril 2::5

1er a)ril 2::5

int ar 1 ]12S strin ar 2 ] R#on$ourRS

1er a)ril 2::5

ar 1]12 ar 2]#on$our ar 3]1542431534 121#on$our11542431534

1er a)ril 2::5

2.2 La condition: i6 8 else 8 s9itc&.case 8 o!rateur ternaire

1er a)ril 2::5

1er a)ril 2::5

2.3 Les #oucles: 9&ile 8 do 8 6or 8 oto

1er a)ril 2::5

int a]:S do Q S-stem.Console.;riteLineIa//.,oStrin IJJS T 9&ile Ia \ : ^^ a [ 12J S S-stem.Console.Deadae-IJS

1er a)ril 2::5

S-stem.Console.;riteLineIR$oueur R / a.,oStrin IJ / R a !erduRJS S-stem.Console.Deadae-IJS T

1er a)ril 2::5

2.4 @rra- 8 enum 8 struct

1er a)ril 2::5

1 &eures de ta 1115 &eures de quelques liens 1315 &eures de

1er a)ril 2::5

1er a)ril 2::5

T i6 Item! [ 4J # -] tem!S else # -] 3S T S-stem.Console.;riteLineIR$oueur R / a.,oStrin IJ / R a !erduRJS S-stem.Console.Deadae-IJ S

2.2 Instructions !r!rocesseurs

2.3 Le code A unsa6e B et A c&ec?ed . unc&ec?ed B

Illustrons !ar un e'em!le utilisant les !ointeurs :

1er a)ril 2::5

1er a)ril 2::5

S-stem.Strin )ar] ne9 S-stem.Strin Ine9 c&arfg Q`l`1`e`1`t`1`t`1`r`1`e`TJS

1er a)ril 2::5

)ar classeanon-me ] ne9 Q a]11 #]121 c]Rte'teR1 d] Rquelquec&oseRTS Console.;riteLineIclasseanon-me.#.,oStrin IJ/classeanon-me.cJS

!u#lic List[int\ liste ] ne9 List[int\IJS liste.@ddI12JS

1er a)ril 2::5

1er a)ril 2::5

1er a)ril 2::5

3.2 Les mt&odes

a)ec des ar uments

!u#lic !u#lic !u#lic !u#lic

static static static static

int )oid int )oid

EainIJ EainIJ EainIstrin fg ar J EainIstrin fg ar J

1er a)ril 2::5

!u#lic static Meu o!erator/IMeu un1Meu deu'J

1er a)ril 2::5

1er a)ril 2::5

t&is.#utton1 ] ne9 S-stem.;indo9s.=orms.>uttonIJ t&is.#utton1.Clic? /] ne9 S-stem.+)entcandlerIt&is.#utton1iClic?JS

1er a)ril 2::5

1er a)ril 2::5

1er a)ril 2::5

1er a)ril 2::5

1er a)ril 2::5

1er a)ril 2::5