P. 1
UploadedFile_130338580799467993.doc

UploadedFile_130338580799467993.doc

|Views: 0|Likes:
Published by ilyasamine

More info:

Published by: ilyasamine on Jan 10, 2014
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as RTF, PDF, TXT or read online from Scribd
See more
See less

01/10/2014

pdf

text

original

Sections

1

C# : L’essentiel en concentré

C# : L’essentiel en concentré
Sommaire
1 Introduction ..................................................................................................................................... 3 1.1 1.2 1.3 1.4 1.5 2 Qu’est-ce qu’un lan a e de !ro rammation .......................................................................... 3 "ourquoi l’orienté o#$et .......................................................................................................... 3 %n !eu d’&istoire ..................................................................................................................... 3 %n e'em!le ............................................................................................................................. 4 (estion de la mémoire )i)e en .*+, ....................................................................................... 5

La s-nta'e !rocédurale : lo ique C.C// a!!liquée 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 numérique et t-!es.............................................................................. 2 Les t-!es .......................................................................................................................... 2 Les o!érateurs ................................................................................................................. 3 +'em!le de calculs et de déclaration de )aria#le ........................................................... 3 Les c&aines de caract4res : quelques détails................................................................... 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

3

L’orienté C#$et en C#..................................................................................................................... 2: 3.1 3.2 3.3 Introduction ........................................................................................................................... 2: %sin ...................................................................................................................................... 2: Instanciation .......................................................................................................................... 2:

1er a)ril 2::5

2

C# : L’essentiel en concentré

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

L’attri#ut et le modi6icateur d’acc4s ............................................................................. 21 La !ro!riété ........................................................................................................................... 22 Static ...................................................................................................................................... 23 Les mét&odes ........................................................................................................................ 24 Detour sur Eain ............................................................................................................. 24 Constructeur . destructeur ........................................................................................... 25 La surc&ar e .................................................................................................................. 23 <ele ate......................................................................................................................... 25 Les é)énements ............................................................................................................. 27 Eét&odes anon-mes et +'!ressions lam#da ................................................................ 31 Eét&ode d’e'tension. ................................................................................................... 33 Itérateurs ....................................................................................................................... 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 Dedé6inition de mét&odes et d’attri#uts ....................................................................... 33 Les inter6aces ................................................................................................................. 35 Les attri#uts ................................................................................................................... 4:

Conclusion ..................................................................................................................................... 41

1er a)ril 2::5

3

C# : L’essentiel en concentré

1 Introduction
Comme ce c&a!itre résume de mani4re s-nt&étique le lan a e de !ro rammation1 si )ous n’a)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 l’ensem#le des connaissances qui en ressortent. 0ous )erreF qu’il - a #eaucou! de ré6érences G des sous-!arties qui seront traitées en a)al. Il m’arri)era sou)ent de coder !lusieurs 6ois des e'em!les identiques ou tr4s !roc&e a)ec des mots cle6s di66érents !our )ous !ermettre de com!rendre !ar analo ie et )ous é)iter de relire l’ensem#le de la source a)ec attention !our com!rendre. <ans les !remi4res !arties il m’arri)era de dire A 6onction B G la !lace de A mét&ode B1 c’est !arce que c’est !lus !arlant !our #eaucou!1 cet a#us de lan a e )olontaire sera éclairci dans la !artie réser)ée au' mét&odes.

1.1 Qu’est-ce qu’un lan a e de !ro rammation
C#1 $e ne !ense !as )ous l’a!!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 d’Htre !lus lisi#le et !lus !ratique que l’assem#leur !our sim!li6ier la )ie des dé)elo!!eurs. Le C et le C// sont des lan a es com!ilés qui sont donc trans6ormés directement en instructions !rocesseur. +n .*+,1 ce n’est !as le cas la com!ilation donne un code IESIL.Eicroso6t Intermediate Lan ua eJ qui est inter!rété !ar un lo iciel Iinter!réteurJ. 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 nées d’outils tel un com!ilateur.

<u 6ait que le code com!ilé ESIL soit commun au lan a e .*+, utilisé1 on !eu dire que le C# et le 0>.*+, sont deu' lan a es de !ro rammation a-ant un con6ort di66érent mais des !er6ormances tr4s similaires.

1.2 "ourquoi l’orienté o#$et
L’orienté o#$et G été introduit !ar le lan a e Small,al? Idé)elo!!é !ar la société Kero'J en 1732. L’orienté o#$et est un ensem#le de r4 les1 de conce!ts1 d’outils du lan a e de !ro rammation !our rendre le dé)elo!!ement !lus aisé rLce au rou!ement d’éléments. Les o#$ets sont donc des entités 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#ilités. <é6inir un o#$et !eut !araitre comme a$outer un outil1 Le 6rame9or? .*+, a!!orte lui un set im!osant d’o#$ets e'istants. %n lan a e Crienté o#$et n’est !as les o#$ets1 mais une s-nta'e et des mots cle6s !our les mani!uler et les créer. >ien que nous allons utiliser des o#$ets du 6rame9or? ce cour )isera G )ous a!!rendre le lan a e.

L’orienté o#$et !ermet la estion d’ensem#le1 le rou!ement1 l’isolation des données et des 6onctions. Cet ensem#le de conce!ts et d’outils !ermet !ar e'em!le de rou!er dans un coin les o#$ets !our accéder au' données distinctement des o#$ets qui ser)ent a 6aire l’inter6ace a)ec l’utilisateur et des o#$ets qui ser)ent G a!!liquer les calculs et !rocédure lo iques de 6ond. <e ce 6ait nous !ourrons dis!oser d’un code sim!le et lisi#le.

1.3 %n !eu d’&istoire
Le C# est un lan a e récent 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@ l’année de sa sortie I!uis !ar l’ISC deu' ans !lus tardJ. Il - a eu trois )ersion du C# im!lémentant tou$ours quelques 6onctionnalités su!!lémentaires. Le C# étant un !roduit du 6rame9or? .*+, leurs é)olutions sont tr4s liées. Le C# 2.: est sorti a)ec le 6rame9or? 2.:1 le C#3.: lui

1er a)ril 2::5

4

C# : L’essentiel en concentré

#ien qu’utilisa#le sur le 6rame9or?2.: arri)e nati)ement et !rend )raiment tout son intérHt 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!lémenté 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 !résent 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 d’en)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 réduit G sa !lus sim!le e'!ression. EHme les !ro$ets console !ar dé6aut des en)ironnements de dé)elo!!ement inté rés sont !lus conséquent. "our l’instant nous nous concentrerons sur le contenu des accolades qui sui)ent A EainI J B. Les accolades sont !récédées de mots cle6s et noms qui ser)ent G 6ormer une structure d’e'écution. Cette structure rele)ant de l’orienté o#$et est nécessaire G l’e'écution mais elle ne sera e'!liquée seulement qu’a!r4s a)oir acquis les #ases de la lo ique !rocédurale.
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 étudiée 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!réter la 6in de la li ne. Il m’arri)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 d’éc&a!!er la 6in de la li ne1 éc&a!!e $usqu’G un s-m#ole de 6ermeture. Ces commentaires lG s’ou)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 énérer de la documentation G !artir des commentaires1 si )ous de)eF tra)ailler en équi!e ou !our une entre!rise1 énérer une documentation qui !ermettra G )otre successeur de !rendre la rel4)e s’a)4re im!ortant I!a e sur la documentation du code en C#J. Si )ous )ous intéresseF G cette s-nta'e1 cette !a e )ous e'!liquera l’essentiel. Cela dit le contenu de cette !a e contient des données 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

"our com!rendre un !eu mieu' certains !&énom4nes qui seront a#ordés !lus tard1 nous allons e'!liquer ra!idement la estion de la mémoire !ar le . 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.*+. >ien que !er6ormant !our les !etites )aria#les le t-!e )aleur est com!lété !ar un autre t-!e : le t-!e ré6érence.C// a!!liquée en C# Comme nous le disions1 la s-nta'e du C# est tr4s ins!irée du C. @insi1 si des données n’ont !lus de !ointeurs associées1 la mémoire est li#érée.5 (estion de la mémoire )i)e en . Les !ersonnes a-ant de #onnes #ases en C. Ce !rocédé !ermet de redimensionner notre es!ace mémoire réser)é et donc de li#érer de la mémoire !our le s-st4me et les autres !rocessus. Cette association nom1 es!ace mémoire et donnée contenue est un tout que l’on a!!elle )aria#le. Me sais que Ua n’e'!lique !as tout l’e'trait de code mais )enons . Les )aria#les de t-!e )aleur sont le !lus sou)ent in6erieure G 32 octets. Quand on 6ait un !ro ramme en .Console. Si les données étaient au milieu du tas1 l’es!ace li#éré sera réutilisé !ar les données du A 6ond du tas B. Demarque : Si c’est )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 l’orienté o#$et. 6rame9or?. 2 La s-nta'e !rocédurale : lo ique C. . *oteF #ien que les !roc&ains e'em!les seront sou)ent $uste la !rocédure entre les accolades de la 6onction Eain 1. sé!are la mémoire en deu' !arties isolées1 la !ile et le tas.*+.5 C# : L’essentiel en concentré S-stem.*+. <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. Les )aria#les de t-!e ré6érence ont un !ointeur enre istré dans la !ile qui !ointe )ers les données de la )aria#le. Ces données sont dans la Fone mémoire a!!elée le tas.*+. Ce nom sera utilisé comme un lien )ers un es!ace mémoire.C//1 on !eut mHme 6aire de l’arit&métique de !ointeurs !our !eu que l’on dé6inisse notre code en tant que A %nsa6e B. Il !eut Htres sur une ou !lusieurs li nes. Cn a!!elle c&aque élément qui sui)i d’un A S B une instruction. Detenir des résultats intermédiaire !our les réutiliser ou autres. "our enre istrer tem!orairement une )aleur lui donne un nom.1 le 6rame9or? nous réser)e un es!ace mémoire.accéder. DeteneF #ien que c&aque im#rication de commandes 6inissant !ar un A S B s’a!!elle A instruction B.C// ne )erront rien d’e'traordinaire dans cette !artie qui risque de !araitre dense !our ceu' qui !artent de Féro.!ro ressi)ement a)ec cette arc&itecture en tHte. %n outil a!!elé A (ar#a e Collector B est c&ar é de li#érer et dé6ra menter d-namiquement la mémoire du tas.*+. Lorsque Eain a e'écuté la derni4re instruction qu’il contient le !ro ramme !rend 6in..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. Les données dites A t-!e )aleur B sont celles qui ont leurs )aleurs dans la !ile. Les autres !ro rammes ne !eu)ent normalement !as . La mémoire est un !oint essentiel !our !ou)oir 6aire de la lo ique. Ces )aria#les contiennent l’adresse d’une donnée qui é)entuellement !ourrait ne !as Htre nommée. Ces )aria#les liens sont en réalité a!!elées !ointeurs1 elles sont sou)ent cac&ées dans le . #ien qu’elles soient utilisées au cWur du 6rame9or?. 1er a)ril 2::5 .

%int32 S-stem. <ans une quHte de s-nt&4se1 $’ai 6ait !eu d’e'em!le dans cette !artie1 si )ous trou)eF dur G com!rendre les t-!es ou les o!érateurs tro! détac&eF de la !ratique a)anceF a)ec en !arall4le l’e'em!le en 2. 2.Sin le S-stem. 1er a)ril 2::5 .Int12 S-stem.>-te S-stem. 0ous )erreF un contrYle de t-!e utilisant cette mét&ode dans la !artie sur la estion des erreurs.Ea'0alue B !our retourner le !lus rand des int ou Ein0alue !our trou)er le !lus !etit.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 codées -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%.C&ar S-stem.C//1 )o-ons comment les utiliser.(et.S>-te S-stem.<ecimal S-stem.1 0aria#les1 o!érateurs numérique et t-!es. La déclaration des )aria#les1 l’attri#ution de leurs )aleurs et les o!érateurs numériques de #ase sont similaire en C# et en C.*+.2 C# : L’essentiel en concentré 2.1. 0ous n’a)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 n’Htes !as tenu de les retenir.ous les o!érateurs et tous les t-!es n’. <urant l’ensem#le du cours )ous )erreF l’usa e de c&aque o!erateur au moins une 6ois1 mais !our ce qui est des t-!es $’utiliserai !rinci!alement des entiers.-!eIJ B1 cela retournent le t-!e de la )aria#le.trou)ereF une e'!lication !lus détaillée et !lus ima ée de l’usa e de la mémoire )i)e en .=-12J 0aleur true ou 6alse C&aXne de caract4res Demarque : Ce ta#leau est ada!té d’un 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 l’orienté o#$et et )ous .Int24 S-stem.. La mémoire est un !oint cle6 de la !ro rammation.Int32 S-stem. Les o!érateurs numériques sont la #ase des calculs et de la lo ique.sont !as illustrés.3.1Les t-!es 0oici quelques t-!es de #ase utilisa#le en C#. Contrairement G certains lan a es Icomme le !-t&onJ tout o#$et doit Htre e'!licitement t-!é. Si )ous )ouleF trou)er 6acilement la )aleur ma'imale et la )aleur minimale d’un t-!e numérique1 6aites A S-stem. Si on a$oute G une )aria#les A . Les t-!es !résentés dans ce ta#leau G l’e'ce!tion de A strin B et les structures sont les seuls t-!es G Htre stoc?ées !ar )aleur. "our inter!réter le code #inaire dans une )aria#le et donc la donnée en mémoire il 6aut en connaitre le t-!e. .>oolean S-stem. Classe S-stem. C&aque )aria#le a un t-!e dé6ini et on est o#li é de s!éci6ier un t-!e !our c&aque ar ument de c&aque mét&ode.Int32. "our allouer de la mémoire G une )aria#le1 on crée une instruction a)ec d’une !art le t-!e et d’autre !art le nom de la )aria#le.1.<ou#le S-stem.

3 C# : L’essentiel en concentré 2.on attri#u la )aleur : dans a S-stem.oStrin IJ/RNn#]NtR / #.. @ddition. In6erieur ou é al1 su!érieur ou é al. Eodulo. VV : Les o!érateurs d’incrémentation se !lacent sur une )aria#le dans une instruction seule ou dans un calcul. 0aria#le [o!érateur\] 12 équi)aut G 0aria#le ] 0aria#le[o!érateur\12.2J Ces o!érateurs !ermettent d’attri#uer une )aleur G une )aria#le @ttri#ution I!ermet de donner une )aleur G une )aria#leJ.Console. Z / . +nl4)e 1 G la )aleur.este le t-!e d’un o#$et Iutilisé !arti 2.oStrin IJ / RNnRJS ..2 Les o!érateurs "our traiter la )aria#le on utilise des o!érateurs.riteLineIRa]NtR/a. "ermet de contracter la )aria#le de l’o!érateur et de l’attri#ution V..3 +'em!le de calculs et de déclaration de )aria#le 0oici un e'em!le d’utilisation : C# int aS. 0oici les o!érateurs dans leur ordre de !riorité Ion !ourra utiliser des !arent&4ses !our redé6inir les !riorités comme en mat&ématique. on déclare a de t-!e int int # ] 5S .attri#u la )aleur 5 a ] :S. <i66érent de. +st é al G Ces o!érateurs traitent des )aria#les et en retournent une.5J In6erieur G. I2.3J Den)oie )ar1 si cond est )rai ou alors )ar2 I0oir !artie 2.]1Z]1^]1_] Incrémentation VV // -Si ni6ication Ces o!érateurs !ermettent de 6aire des calculs Eulti!lication..ests is [ \ []1\] P] ]] Lo ique ^^ __ OO cond O )ar1 : )ar2 @ttri#ution ] /]1 -]1V]1.1. Si le si ne est G auc&e de la )aria#le ce sera e'écuté en !riorité a#solue dans l’instruction1 s’il est G droite la )aria#le on incrémentera G la toute 6in de l’instruction. 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 l’o!érande de auc&e si non-null ou #ien celui de droite. Demarque : Cn ne !eut !as a)oir !lus d’un o!érateur d’attri#ution !ar instruction. V : Ces o!érateurs d’attri#utions ne ser)ent qu’G 6aire une contraction !ratique. Soustraction.J : C!érateur C# Calculs V .. @$oute 1 G la )aleur. Ces o!érateurs !ermettent de retourner des #ooléens I)rai ou 6au'J . Ces o!érateurs réattri#uent G une )aria#le sa )aleur modi6iée. on déclare # et .1. <i)ision. 0ous aureF des e'em!les dans l’e'trait de code sui)ant. 2. Su!érieur G.VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV 1er a)ril 2::5 . @)ec l’o!érateur /] on a$outera la )aleur actuelle de la )aria#le G la )aleur G attri#uer.1. +..

a]a-2V#VaS #/]1S S-stem.oStrin IJR retourne une c&aine de V te'te contenant la )aleur..# a -] 2V#//VaS.....oStrin IJ/RNn#]NtR / #..oStrin IJ / RNnRJS a .Deadae-IJS .5 C# : L’essentiel en concentré V .. @u lieu de concaténer 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.Console. V V L`o!érateur R/R entre des strin les concat4nes c`est G dire les 6usione V en les mettant G la suite.riteLineIRa]NtR/a.. attend que l`utilisateur a!!uie sur une touc&e Detour Console: a] #] a] #] a] #] : 5 2 2 -11 3 Cet e'em!le !eut !araitre court1 c’est )rais mais ne #loqueF !as dessus1 si ce n’est !as acquis maintenant1 )ous )erreF des e'em!les !artout dans ce court )u que c’est )raiment la #ase.oStrin IJ/RNn#]NtR / #.1. Si )ous ne )ouleF !as #éné6icier du su!!ort de ces caract4res et a)oir une c&aine non inter!rétée1 il su66it de !récéder la c&aine !ar un b I!ratique !our les adresses de 6ic&ier !ar e'em!leJ.riteLineIRa]NtR/a. Les c&aXnes !récédée d’un aro#ase !eu)ent Htre a!!elées A c&aXne 0er#atim B1 ces c&aXnes !eu)ent contenir de réels retours G la li ne.outes les )aria#les o#$ets ont la mét&ode R.Console. L’e'em!le montre que l’on !eut attri#uer une )aleur en mHme tem!s que l’on déclare une )aria#le Ideu'i4me li neJ.. a /] a / //#S..oStrin IJ / RNnRJS S-stem. V @!!liquée G un int1 R. V V RNnR et RNtR sont des caract4res s!éciau' : )oir !artie 2.5 VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV. a]a.4Les c&aines de caract4res : quelques détails <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. 2.Console. 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 d’a66ic&er un antislas& ' NR : !ermet d’a66ic&er un uillemet ' N'KK ou A KK Best une )aleur &e'adécimale de deu' caract4res Ic&acun entre : et =J : !ermet d’a66ic&er un caract4re !ar son code &e'a. Il 6aut retenir !our la déclaration des )aria#les : le nom du t-!e1 le nom de la )aria#le et le caract4re de 6in d’instruction IA S BJ. C# int ar 1 ]12S strin ar 2 ] R#on$ourRS 1er a)ril 2::5 .] #S..oStrin IJR. #]#/1S a]a/a/#S S-stem.1..

a ] null / 2 c’est G dire a ] null # ] 12S S-stem.4J.. Lorsque sa )aleur est G A true B le nulla#le a une )aleur1 quand il est G 6alse la )aria#le )aut null. @insi on !ourra !ar e'em!le caster un int en lon !our utiliser une )aria#le n’a-ant !as les mHme limites de dé!assement..oStrin IJJS S-stem.. C’est G dire le cast !ermet de retourner une )aleur du t-!e attendu G !artir de la )aria#le. 2.oStrin IJ/R-V-R/IaOO#J.a deu' mo-ens !our essa-er de c&an er le t-!e d’un o#$et1 un é)ite les erreurs quand on n’est !as sur que l’o#$et !uisse Htre casté et l’autre ret-!e ou ren)oie une erreur ou une 1er a)ril 2::5 . Ces mots cle6s sont null1 true et 6alse. Ce #ooléen est a!!elé cas0alue.5 Les )aleurs cle6s et les t-!es nulla#le Il e'iste des )aleurs qui sont re!résentées seulement !ar des mots cle6s.Console.2 Le Cast Le cast est un mo-en d’utiliser une )aria#le qui n’est !as du t-!e G utiliser !our le calcul. C# uintO a ] 2S S-stem. <ans le cas ou la )aria#le est de t-!e ré6érence1 si lui attri#ue null Ie'em!le : A )aria#le ] null S BJ l’adresse stoc?ée !ar le !ointeur dans la !ile sera mise G :.Deadae-IJS Detour Console 12-V--V-12 Si l’on su66i'e le t-!e )aleur d’un A O B on o#tient ce t-!e mais nulla#le..oStrin IJ B. Les ar uments n’attendent !as de t-!e !articulier.Console. 2. "our !ou)oir attri#uer la )aleur null G une )aria#le Ide t-!e )aleurJ on utilise une structure qui contient un #ooléen et la )aleur de t-!e dé6iniIle mot structure est dé6ini !artie 2. Il .*ulla#le[uint\ # ] 15S # ] nullS a /] #S . L’intérHt d’a)oir une )aleur null est le !lus sou)ent !our mentionner que ce n’est !as dé6ini.1. 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 l’utilité des c&e)rons qui dans se conte'te ne )eulent é)idement !as dire A su!érieur G B1 )ous !ourreF )oir les classes énériques dans le c&a!itre traitant de l’instanciationJ.riteLineIRar 1]Q:TNnar 2]Q1TNnar 3]Q2TR1ar 11ar 21ar 3JS ar 2 ] strin .. Cet e'em!le )ous montre les deu' mét&odes !our 6aire un nulla#le. Lorsque le (ar#a e Collector contrYlera dans le tas la )aria#le1 )u que rien ne !ointe dessus elle sera su!!rimée.riteLineIar 2JS Console.Deadae-IJS Detour Console ar 1]12 ar 2]#on$our ar 3]1542431534 121#on$our11542431534 Cette mét&ode !ermet une )isi#ilité un !eu !lus claire et !eut é)iter un rand nom#re de A . Ces )aria#les sont susce!ti#les de contenir null qui corres!ond G A néant B1 A rien B Idans certains cas d’utilisation A non dé6ini BJ.riteLineI#.oStrin IJ/R-V-R/a. L’autre utilisation de null est la des-allocation de mémoire.=ormatIRQ:T1 Q1T1 Q2TR1 ar 11 ar 21 ar 3JS Console..1.7 C# : L’essentiel en concentré ulon ar 3 ] 1542431534S Console...

Htre utilisés et !our ce qui est des !er6ormances le s9itc& est la moins o!timisée des 3 solutions. La condition soumise G i6 doit retourner un >ooleen I. cast im!licite o#$ect o ] cS .l4)e une o)er6lo9e'e!tion si les dé!assements sont contrYlés . cast im!licite # ] aS . l`o!érateur ternaire sera détaillé dans la !artie qui suit. *éanmoins certains dé)elo!!eurs trou)ent sa s-nta'e !lus lisi#le et !lus !ratique que l’im#rication de A i6 B.en )oir 2 identiques1 tous les t-!es de )aleurs ne !eu)ent . Sou)ent1 et c’est )rai a)ec #eaucou! de mots cle6s1 quand les accolades ne !araissent !as G la suite de la condition1 le mot cle6 s’a!!liquera uniquement sur l’instruction qui suit. équi)au G l`instruction: # ] IIo is lon OJ O IIlon OJ oJ : IIlon OJnullJ J OO :S .case 8 o!érateur ternaire Le mot cle6 i6 Ien 6ranUais A si BJ !ermet l’e'écution conditionnelle de code.Ea'0alueS lon c ] 15S . Les !ro!ositions ne !eu)ent !as Htre des )aria#les1 il ne !eut !as ..Ea'0alueS lon # ] lon .. cast e'!licite necessaire a ] IintJ#S. Le mot cle6 s9itc& !ermet seulement de contrYler di66érentes )aleurs que !eut !rendre une )aria#le ou e'!ression et d’a ir en 6onction. usa e de as et de l`o!érateur OO # ] Io as lon OJ OO : S .2 La condition: i6 8 else 8 s9itc&...1: C# : L’essentiel en concentré )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.. C# int a ] int. 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.riteLineI#JS S-stem.. Si l’on doit !rocéder G une série de test ou un seul doit Htre e'écuté1 )ous )erreF une suite du enre A i61 Velse i61 else i6d/1 else B1 seule la !rocédure associée de la !remi4re condition )raie sera e'écutée.. "our ra!!el1 l’o!érateur A OO B sert G retourner une autre )aleur si le !remier élément est null1 il est !ar6ois utilisé a)ec as !our a)oir un retour en cas d’im!ossi#ilité de cast di66érent de null. else comme i6 est sui)i de code entre accolades. +nsuite nous !assons la !rocédure G e'écuter si la condition est )raie entre accolades..Console.6onctionne . 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 mot cle6 else IsinonJ est tou$ours !récédé d’au moins un i6.unc&ec?edJ. . Ce code sera utilisé seulement si la derni4re instruction i6 n’a !as eu G e'écuter le #loc.rue ou =alseJ1 nous utiliserons sou)ent ici des o!érateurs de test.3J.Deadae-IJS 2.. ici1 seuls Rlon R et Rlon OR 6onctionnent !our le t-!e de c Console. Le A as B est traduit a)ec d’autres o!érateurs dans l’e'em!le. Le mot cle6 A as B doit caster )ers un t-!e nulla#le ou ré6érence I)oir !artie 2. 1er a)ril 2::5 .

DeadLineIJJS . le cas 1 )ien e'écuter les instructions du cas 3 #]R"as loinRS #rea?S.. Eais il 6aut noter que l’o!érateur ternaire !ermet un retour conditionnel et non !as une e'écution conditionnelle1 c`est-G-dire qu’il ne !eut rien e'écuté et qu’il se !lace dans des e'!ressions comme une )aleur.. Cn !eut #ien é)idemment en im#riquer !lusieurs !our cumuler !lusieurs conditions. Lorsque l’on 1er a)ril 2::5 . on aurai !u rem!lacer RelseR !ar Ri6Ia [ 1 __ a \ 3 JR Q # ] R#iFarreRS .. C# int aS strin #S S-stem.Deadae-IJS Cet e'trait de code montre trois mani4res de 6aire la mHme c&ose1 Le !ro ramme demande G l’utilisateur d’entrer une )aleur qui est a66ecté dans A a B. on !eut se !asser d’acollade !our une instruction seule else .riteLineIR+ntreF 2RJS a ] int. @ la 6in on a66ic&e la c&aine de caract4re A # B.a une condition ellemHme sui)ie d’une ou !lusieurs instructions... en C# : !as de #rea? ] !as d’instructions case 3:. donc on sort du s9itc& de6ault:.case s9itc& IaJ Q case 2:. !uis e'écute ses instruction #rea?S. Eét&ode o!érateur de retour conditionel #] Ia ]] 2J O RnormalR : Ia ]] 1 __ a ]] 3J O R"as loinR :R#iFarreR S S-stem. Comme e'!liqué antérieurement1 on constate que suite au A i6 B il .riteLineI#JS S-stem. Le #rea? 6ait sortir du s9itc& case 1:."arseIS-stem.. de6ault re!résente tous les autres cas # ] R#iFarreRS #rea?S T .else i6 Ia ]] 2J Q a ] aS.Console..Console.. on !eut mHtre !lusieurs instructions T else i6 Ia ]] 1 __ a ]] 3J # ] R"as loinRS . a]a est une instruction inutile G titre d’e'em!le # ] RnormalR S .Console.Console. Eét&ode i6.. <ans le cas de l’e'em!le ci-dessus si A a B est é al G 2 A a]]2 B retourne )rai ce qui en endre l’e'écution de l’a66ectation de A >ien $oué P B."arse !rend le te'te entré !ar l’utilisateur IDeadlineIJJ V et en retourne la )aleur indiquée si ce te'te contien un nom#re.. V. le s9itc& saute G cette condition si a )aut 2 # ] R>ien Moué PRS .. +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.. .11 C# : L’essentiel en concentré La s-nta'e de l’o!érateur ternaire est la sui)ante : A I#ooléenJ O retourSi0rai : retourSi=au' B.V int.. Eét&ode s9itc&. une instruction seule !asse mHme a)ec les acollades T .....

Il sera !rinci!alement utilisé en ar ument de 6onction )u qu’on ne !eut !as )raiment .Console.riteLineIR. >ien qu’il !uisse !araitre !ratique et asseF o!timisé !our ce qui est des !er6ormances1 l’o!érateur ternaire )a !ar son manque de lisi#ilité G l’encontre des !rinci!es des lan a es récents qui )isent le con6ort de dé)elo!!ement et la lisi#ilité..en ait !lus moment ou on sortira de la #oucle !our a66ic&er le nom du 1er a)ril 2::5 ..1 ."arseIS-stem. *i)eau structure il ressem#le au i61 il a une condition entre !arent&4ses et un #loc? de code nécessairement entre accolade !our !eu qu’il ait !lusieurs instructions. 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 di66érences entre le s9itc& C et le s9itc& C#1 $e )ous recommande cet article 6ranco!&one. Le mot cle6 #rea? doit Htre mis en 6in d’e'écution a)ant la nou)elle )aleur du s9itc&.Console.12 C# : L’essentiel en concentré utilise le mot cle6 i6 $uste a!r4s le A else B c’est !our 6aire une liste de test1 le !remier )rai sera le seul e'écuté.3.riteLine sans !asser !ar A # B..mettre des e'écutions conditionnelles. 0ous a)eF néanmoins !u constater l’as!ect !ratique de cet o!érateur qui est celui qui a eu la s-nta'e la !lus ra!ide1 Ua n’aurai !as été !our l’e'em!le1 $’aurai certainement mis l’e'!ression directement en ar ument de la mét&ode .oStrin IJ /RNnil reste R/#. Le s9itc& !ermet donc ici de tester les cas qui nous intéressent indi)iduellement c`est-G-dire 11 2 et 3. Im#riqué1 l’o!érateur ternaire n’est !as un cadeau !our ce qui est de la lisi#ilité. 0u que le cas 1 et le cas 3 ont le mHme traitement on !eu les réunir..DeadLineIJJS i6 Item! \ : ^^ tem! [ 4J #-]tem!S else #-] 3S T S-stem.&ile . 2.oStrin IJ/R a !erduRJS S-stem.oStrin IJ /R allumettesNn!reneF un nom#re d`allumettes entre 1 et 3 Ide6aut 3JRJS tem! ] int..Console. C# int a]2S int #]15S int tem!S 9&ile I# \ :J Q i6 Ia ]] 1J a ] 2S else a ] 1S S-stem.riteLineIR$oueur R/a. Si la condition du 9&ile est )raie le #loc? de code est e'écuté1 G la 6in de cette e'écution1 le #loc? est e'écuté G nou)eau si la condition et )rai et ce $usqu’G ce que ce ne soit !lus le cas.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 l’on aura )u a!r4s Ua l’essentiel de la !artie structure lo ique des instructions dans une !rocédure.our du $oueur R/a.&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.Deadae-IJS Cn !eut )oir dans cet e'em!le que tant qu’il reste des allumettes1 les $oueurs !eu)ent en !rendre $usqu’G ce qu’il . "our rendre !lus clair G l’Wil1 nous aurions !u mettre des !arent&4ses autour de la sous e'!ression ternaire ou la mettre G la li ne.Console. 2.

Console.Console. 2.Deadae-IJS Le do-9&ile est l’équi)alent du 9&ile mais la s-nta'e et di66érente et le contrYle de condition se 6ait G la 6in de la #oucle.)errons nécessairement deu' A S B !our sé!arer les 3 c&am!s.3.. Le oto 6ait un saut $usqu’G un endroit nommé n’ im!orte oe dans la !rocédure. Le tout est dans les !arent&4ses du 6or1 nous .3.Console..oStrin IJ / R alumettesNn!reneF un nom#re d`allumettes entre 1 et 3 Ide6aut 3JRJS tem! ] int. I@66ic&e les nom#res de : G 11 inclusJ. De6aisons l’e'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. 2. "our nommer un endroit on 1er a)ril 2::5 ..oStrin IJJS T 9&ile Ia \ : ^^ a [ 12J S S-stem..our du $oueur R / a.4 (oto Le oto est une alternati)e #ien qu’G é)iter qui !ermet des c&oses asseF étonnantes..2<o 9&ile .Deadae-IJS La #oucle 6or comme )ous !ou)eF le constater met en )aleur une )aria#le locale qui sera le !lus sou)ent utilisée 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 itération Ia !art la !remi4reJ1 )ous )erreF sou)ent A 6orIint a ] 1 S a[]1: Sa//JQ . <e ce 6ait le #loc? est e'écuté au moins une 6ois mHme si la condition est 6ausse en !remier lieu.3=or La #oucle 6or est sou)ent tr4s !ratique mais n’est !as tou$ours aimée des dé#utants1 c’est un 9&ile a)ec deu' c&am!s su!!lémentaires : une )aria#le locale et une e'écution.Console.r4s similaire au 9&ile normal1 il im!ose un minimum d’une e'écution a)ant de contrYler les conditions de maintien de la #oucle.Console. Le 6onctionnement est sim!le et commun au' autres..riteLineIa//.instructions ST B !our les #oucles qui doi)ent se ré!éter 1: 6ois.oStrin IJ / R a !erduRJS S-stem.Console. 2.oStrin IJ / RNnil reste R / #.13 C# : L’essentiel en concentré !erdant. <ans ce cas A a B ] :1 il e'écute le #loc une !remi4re 6ois alors que la condition est 6ausse."arseIS-stem. C# int a]:S do Q S-stem.3.riteLineIR$oueur R / a..riteLineIR.DeadLineIJJS T S-stem. Il su66it de maitriser un t-!e de #oucle !our 6acilement com!rendre les autres.. +nsuite $usqu’G ce que A a B ne res!ecte !lus la condition il l’incrémente et l’a66ic&e.

Console.DeadLineIJJS 1er a)ril 2::5 .. Le mot cle6 #rea? !ermet de sortir #rutalement de la #oucle tandis que continue ren)oie au test.our: i6 Ia ]] 1J a ] 2S else a ] 1S S-stem.DeadLineIJJS i6 Item! \ : ^^ tem! [ 4J # -] tem!S else # -] 3S i6 I# \ :J oto nou)eau.oStrin IJ / RNnil reste R / #. 2...Console.riteLineIR.our du $oueur R / a. <e ce 6ait dans la mesure du !ossi#le il 6aut !ri)ilé ier l’util6isation d’autres t-!es de #oucles.oStrin IJ / R alumettesNn!reneF un nom#re d`allumettes entre 1 et 3 Ide6aut 3JRJS tem! ] int.Console.oStrin IJ / R a !erduRJS S-stem.. <ans ce conte'te le oto et le la#el sont G !roscrire du 6ait qu’un do 9&ile !ermet la mHme c&ose.oStrin IJ / R alumettesNn!reneF un nom#re d`allumettes entre 1 et 3 Ide6aut 3JRJS tem! ] int. Certains !ro rameurs )ont $usqu’G interdire l’utilisation du oto ou dé)elo!!er des lan a es n’im!lémentant !as ce t-!e de #oucle..Console.oStrin IJ / RNnil reste R / #. Il )a sans dire que ces deu' instructions ne 6onctionnent !as dans le cas de #oucle 6aites au oto.riteLineIR.."arseIS-stem.14 C# : L’essentiel en concentré !arle de la#el ou d’étiquette1 on met son nom sui)i de A : B.Console.5 Sortie de #oucles : >rea?-Continue Il !eut arri)er dans le cas ou les #oucles e66ectuent !lusieurs o!érations que l’on )euille sortir directement de la #oucle ou sauter l’e'écution de la 6in du #loc?1 !our Ua il e'iste les mots cle6s #rea? et continue. M’ai mis la mét&ode Eain dans cet e'em!le !our montrer que !ar con)ention1 ces la#els sont indentés en retrait sur la auc&e. C# static )oid EainIJ Q int a ] 2S int tem!]:S int # ] 15S nou)eau. La condition #oucle réalisé a)ec i6."arseIS-stem.Console.riteLineIR$oueur R / a. 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 d’une im#rication de #oucles. C# int a ] 2S int tem!]:S int # ] 15S 9&ileItrueJ Q i6 Ia ]] 1J a ] 2S else a ] 1S S-stem.3.ourS S-stem.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 !ensée de de l’indentation et du cou! c’est moins lisi#le que les autres #oucles...our du $oueur R / a.

enum et struct sont !our 6aire des déclarations qui seront en de&ors de Eain.8 enum 8 struct "our rou!er des )aria#les ou des )aleurs il .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 . ' +num : or anise des )aleurs cle6s ' Les arra-s sont des )aria#les déclarées en tant que liste de )aleurs de t-!e commun. 2..: ne9 e)enementQ $ours] ne9 intfg QIintJsemaine. La s-nta'e utilisée ci-dessous !our rem!lir les é)4nements ] C#3.. ' Struct : dé6ini un t-!e de )aria#le G !lusieurs c&am!s.courtT1 ne9 e)enementQ $ours]ne9 intf3g1 tac&e]Rlire ses 6lu' DSSR1 duree]IintJlon ueur. enum et struct 6orment des éléments1 une 6ois dé6inis on ne !eut !lus les modi6ier.dimanc&e1IintJsemaine.em!s.Deadae-IJS +)idemment ce cas est !lus un cas d’étude qu’un cas !ratique1 )ous aureF un autre e'em!le aussi e'!licite mais montrant !lus l’intérHt de ces mots cle6s dans la !artie sur la estion des erreurs. <ans la structure IstructJ on dé6inie c&acune de ses sous )aria#les et leur t-!es comme si on déclarait des )aria#les.Console.oStrin IJ / R a !erduRJS S-stem. 0ous remarquereF le mot A !u#lic B.4 @rra.mercrediT1 tac&e]R6aire la )aiselleR1 duree]IintJlon ueur.em!s. La structure est en réalité tr4s !roc&e de la classe I)oir c&a!itre 1 sur le 6rame9or?J mais n’est en énéral 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.15 C# : L’essentiel en concentré i6 Item! \ : ^^ tem! [ 4J # -] tem!S else # -] 3S i6 I# \ :J continueS #rea?S T S-stem. L’e'em!le !ro!ose un sem#lant d’or aniseur de tLc&es et 6ait la somme de la durée des é)énements de la semaine.riteLineIR$oueur R / a..a !lusieurs outils1 les trois outils que $e )ous !résente ici sont tr4s di66érents.asseFlon T1 ne9 e)enementQ 1er a)ril 2::5 .Console.

*oteF le mot cle6 A in B qui n’a!!arait que dans ce conte'te.riteLineIIIdou#leJtem!.2:J. @u 6inal on e'écute les mHmes instructions qu’a)ec la #oucle 6or dans l’e'em!le antérieur.riteLineIIIdou#leJtem!. *ous !ou)ons re arder la documentation de la mét&ode !ro!ice G l’erreur !our )oir les di66érents t-!es d’erreurs 1er a)ril 2::5 ..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 l’on a!!elle l’enum il 6aut caster !our a)oir le t-!e désiré ' Les arra-s sont G taille statique1 )ous ne !ourreF !as a$outer d’éléments1 !our 6aire des sortes d’A arra-s d-namique B on utilisera une classe énérique Ié)oqué dans le c&a!itre 3.tac&e/R JRJS T S-stem..Console..Console.4.Len t&S S-stem.2:J. 2.B.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 d’inde'.Console.mo-enT TS calf1g.-!eIJJS T S-stem.Len t&S i//J Q tem! /] calfig.lundi1 IintJsemaine. "our qu’un 6oreac& soit utilisa#le sur un o#$et ce dernier doit a)oir un com!ortement adéquat I)oir la !artie sur les itérateursJ. "our érer les erreurs nous !ou)ons isoler le code !ro!ice G l’erreur et l’isoler dans un #loc de code A tr.duree V calfig.tac&e/R JR/semaine.. <e ce 6ait $e traite tour G tour c&aque élément de l’arra-.mercrediT1 tac&e ] R!rendre un #ainR1 duree ] IintJlon ueur.tac&e /] R et sui)re quelques liensRS 6or Iint i]:S i [ cal.oStrin IJ/ R &eures de ta semaine occu!ée ItLc&e a$outé: R / e.Console.oStrin IJ/ R &eures de ta semaine occu!ée ItLc&e a$outé: R / calfig.$ours.lundi.$ours.Len t&S S-stem.duree V e.Deadae-IJS La liste cal est la mHme que dans l’e'em!le !récédent1 on 6ait !asser tour G tour dans la )aria#le locale c&aque élément e.em!s.5 (estion des erreurs : tr--catc& 8 6inallComme )ous l’a)eF !eut Htre dé$G constaté1 si )ous entreF une c&ose qui n’est !as assimila#le G du te'te dans le $eu qui nous sert d’e'em!le1 nous a)ons une erreur.3 sur l’instanciationJ. 2.12 C# : L’essentiel en concentré $ours ] ne9 intfg QIintJsemaine. "our 6aire cette démarc&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.(et.

+'ce!tion re rou!e toutes les caté ories c`est-G-dire tous les t-!es d’e'ce!tions. Les e'ce!tions sont des classes qui seront dé6ini en e'em!le sur l’&érita e.riteLineIe.Console.ou du 6ic&ier source qui est G l’ori ine.-!eIJ.oStrin IJ / R alumettesNn!reneF un nom#re d`allumettes entre 1 et 3NnIde6aut 31 nom#re né ati6 !our a#andonerJRJS trQ tem! ] uint.Console.riteLineIR.riteLineIRim!ossi#le: retour minimal] NRNR InonnullJRJS else i6 Ie is S-stem.race donne la li ne de l’erreur et remonte du Eain G la mét&ode qui l4)e l’e'ce!tion et 6ourni la li ne.oStrin IJ / RNnil reste R / #. ' Source donne le nom de la ré6érence1 l’assem#l. ' . La mét&ode !ro!ice G l’erreur 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<*..ait erreur ou non. "our !ou)oir traiter l’erreur1 on )a ran er le code en cas d’erreur dans un #loc A catc& B.C)er6lo9+'ce!tionJ #rea?S else S-stem. +n mettant les !arent&4ses et un ar ument énéral Icomme dans notre e'em!leJ on a une )aria#le interne au catc& IA e BJ qui contiens les données de l’erreur et qui !ermet de es a66ic&er et de réa ir.(et.13 C# : L’essentiel en concentré qui !eu)ent ad)enir en ce conte'te. Le mot cle6 6inall.DeadLineIJJS T catc& IS-stem. Ce #loc? sera e'écuté qu’il .Console..+qualsIt-!eo6IS-stem.@r ument*ull+'ce!tionJJJ S-stem. ' Stac?...Eessa eJS i6 Ie."arseIS-stem.et le catc&.+'ce!tion eJ Q S-stem.. C# uint a ] 2S uint tem! ] :S uint # ] 15S 9&ile I# \ :J Q i6 Ia ]] 1J a ] 2S else a ] 1S S-stem. Demarque: )oici quelques !rinci!au' attri#uts communs G toutes les +'ce!tions !ermettant d’o#tenir des in6ormations !our si naler1 trou)er et corri er les #u s : ' Eessa e est un Strin décri)ant la cause de l’erreur de mani4re relati)ement e'!licite !our un utilisateur.ar etSite !ermet d’a)oir le t-!e de retour de la mét&ode qui G le)é l’erreur et le t-!e des ar uments.our du $oueur R / a. ' cel!Lin? retourne l’adresse Ie' :%DLJ du 6ic&ier d’aide associé au t-!e de l’e'ce!tion.Console.. <ans notre e'em!le nous com!arerons les t-!es de l’e'ce!tion G ceu' que l’on a trou)és sur ES<* !our )oir la com!araison des t-!es.riteLineIRmessa e non !arsa#leRJS i6 Ia ]] 1J a ] 2S else a ] 1S continueS 1er a)ril 2::5 .Console. Si on met catc& seul Isans ar uments ni !arent&4sesJ le traitement sera le mHme quelque soit l’erreur et on ne !ourra !as retourner d’in6ormations relati)es au' erreurs. *ous retraiterons les erreurs dans la !artie A +'em!le d’&érita e B.le !lus sou)ent utilisé !our li#érer la mémoire est G !lacé a!r4s le tr.

. Ces dé!lacements de données étant Hnants si l’on utilise des adresses mémoire1 on a deu' mo-ens de solutionner le !ro#l4me : stac?alloc? Ira!!elle un !eu le mallocJ qui !ermet d’allouer de la mémoire dans la !ile et 6i'ed qui em!Hc&e au ar#a e collector de dé!lacer certaines données du tas.5:J. unc&ec?ed B Cette !artie aura du sens !articuli4rement !our ceu' qui ont dé$G mani!ulé des !ointeurs en C. *ous allons é)oquer ici quelques mots cle6s : unsa6e1 stac?alloc1 6i'ed.. stac?alloc ne s`utilise que !our des arra-s t-!es )aleur 6or Iint i ] :S i [ 1::S i//J Q V)aria#le// ] iS Console.com.as!' 2.15 C# : L’essentiel en concentré T i6 Item! [ 4J # -] tem!S else # -] 3S T S-stem.6r-6r.2 Instructions !ré!rocesseurs Me ne mettrai !as d’e'em!le !our l’instruction !ré!rocesseur1 c’est asseF !eu utilisé #ien que ce soit la seule mani4re !our !ou)oir dé6inir des instructions G com!ilation conditionnelle.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 .riteLineI IintJ)aria#le JS T )aria#le-]1::S 6or Iint i ] :S i [ 1::S i//J S-stem.unsa6e dans le terminalJ !our s!éci6ier e'!licitement )otre autorisation.C// classique1 A #de6ine B ne !ermet !as de 6aire de macros...3 Le code A unsa6e B et A c&ec?ed .Console.. %ne liste des mots cle6s des instructions !ré!rocesseurs est dis!oni#le G cette !a e : &tt!:. Le mode unsa6e I!ourrait Htre traduit !ar non shrJ !ermet de mani!uler directement les adresses mémoire et donc les !ointeurs.oStrin IJ / R a !erduRJS S-stem.msdn. Illustrons !ar un e'em!le utilisant les !ointeurs : C# unsa6e static )oid EainIJ Q intV )aria#le ] stac?alloc intf1::gS . 2.li#rar-. +n énéral ce ne sera !as utilisé1 d’autan que contrairement au C.ed5-d1&aI0S.Console. "our !ou)oir com!iler du code unsa6e1 )ous de)eF le s!éci6ier1 de!uis 0isual Studio sélectionneF : !ro$et \ !ro!riétés du !ro$et1 )ous de)reF coc&er une c&ec?#o' dans l’on let énérer I!ro$et\o!tions\C!tions du com!ilateur !our Eono<e)elo! ou le !aram4tre de commande .riteLineIV)aria#le//JS 1er a)ril 2::5 .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 l’erreur A e B rel4)e #ien des classes en ar ument.microso6t.riteLineIR$oueur R / a.Console..

)aria#le corres!ond G l’adresse mémoire de la )aria#le. %nsa6e dé6ini des #loc?s de code1 il !eut Htre mis seul a)ant un #loc? comme tr. Console. I@!!lication des o!érations #inaire a)ec mise G l’écart des retenuesJ.Iunsa6eQ .17 C# : L’essentiel en concentré c&arfg te'te ] ne9 c&arfg Q`t`1`a`1`m`1`t`1`l`1`e`1`m`1`o`1`u`1`s`1`s`1`e`TS 6i'ed Ic&arV !ointeur ] ^te'tef:gJ Q !ointeurf3g ] `!`S V!ointeur ] !ointeurf3gS 6or Iint i ] :S i [] te'te.Console. "ar dé6aut 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!riété du !ro$et\ énérer\o!tions a)ancées 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.Console.. C’est la donnée G !ro!rement !arlée. C# int a ] int. TJ ou il !eut s’a$outer au' s!éci6ications d’un #loc? e'istant comme dans l’e'em!le.oStrin IJJS T S-stem..Ea'0alueS int # ] 12S #]c&ec?edIa V #JS ..riteLineIRNnR /)ar.Ea'0alue /1JJ. V)aria#le corres!ond au contenu de la )aria#le.Console. C’est un !ointeur )er un o#$et de t-!e int.VinstructionsV. Stac?alloc est l’équi)alent de ialloca de la #i#liot&4que runtime C1 il a alloué 4:: octets et retourné un !ointeur. Le code mis en A unc&ec?ed B Iun calcul ou un #loc?J est un !eut !lus !er6ormant mais les résultats !eu)ent c&an er1 unc&ec?ed consiste G ne !lus contrYler les dé!assements de )aleurs. ce code én4rera ici une erreur de t-!e C)er6lo9+'e!tion ..Deadae-IJS T intV est un t-!e de donnée !ointeur. ^)aria#le corres!ond G l’adresse mémoire de la )aria#le. C# int )arS unc&ec?ed Q )ar ] int.oStrin IJ / RNnR / IIintJIint.Ea'0alueS )ar V] 2S S-stem.Deadae-IJS Detour Console: -2 -2143453245 Si )ous n’a)eF !as dans les o!tions du com!ilateur le contrYle de dé!assement de coc&é !ar contre )ous !ou)eF l’acti)er sur un calcul ou un #loc? a)ec le mot cle6 A c&ec?ed B. <erri4re on !eut mani!uler le !ointeur comme en C. <e ce 6ait le com!ortement est de retourner G la )aleur minimale quand on est tro! rand et in)ersement.riteI!ointeurfigJS T S-stem.riteLineI#JS 1er a)ril 2::5 ...Console.Len t&S i//J S-stem. 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.

Ces im!orts d’es!aces de nom !ermettent d’accéder directement G tous les éléments contenus Ia!!art les *ameS!aces qu’il contientJ sans a)oir G mentionné ou il est ran é. 3. Cette notion de 6onction et d’ar ument G la déclaration seront e'!liqués dans la !artie 3. Les classes anon-mes ont un nom de classe énéré G la )olée 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. *ous attendons aussi un ar ument.: sans modi6ications. @)ant de s’amuser G instancier n’im!orte quoi nous allons )oir comment on crée des classes sim!les Iqui ran ent des )aria#lesJ1 nous )errons ensuite comment utiliser ces classes. <ans ce cas il e'iste une s-nta'e de déclaration de classe !récise qui én4re des A Classes anon-mes B. "ar c&ance le 6rame9or? .: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.2: C# : L’essentiel en concentré 3 L’orienté C#$et en C# 3. Le mot cle6 A )ar B !ermet de laisser le com!ilateur t-!er la )aria#le G notre !lace. "our déclarer une )aria#le dont on ne connait !as le t-!e1 il e'iste un mot cle6 a!!ro!rié : A )ar B.Strin Ine9 c&arfg Q`l`1`e`1`t`1`t`1`r`1`e`TJS <écom!osons cette instruction. Demarque : les classes anon-mes sont une nou)eauté de C# 3. Si l’on )eut s’économiser d’écrire S-stem G c&aque 6ois que l’on )eut accéder G un o#$et de ce *ameS!ace1 il su66it de mettre au dé#ut du 6ic&ier A usin S-stem S B.Strin )ar] ne9 S-stem. 3.*+. %ne classe anon-me se rem!lie un !eu comme un arra-1 e'em!le : C# 1er a)ril 2::5 . Les o#$ets corres!ondants G quelque c&ose1 il 6aut les dé6inir a)ant d’en utiliser. +n suite nous a)ons le mot cle6 ne91 on utilise G nou)eau le t-!e que l’on a!!elle comme une 6onction.: !our !ou)oir 6aire ce qui )as sui)re. Les *ameS!aces ser)ent G ran er les classes un !eu comme dans des dossiers. *ous a)ons dans un !remier tem!s le t-!e et le nom de la )aria#le !our la déclaration. "lus )ous 6erreF de usin !lus )ous aureF de !ro!ositions G l’auto com!létion1 d’oe l’intérHt de limiter l’usa e des usin car cela !ermet une auto com!létion !lus ra!ide et !lus !ertinente.1 Introduction Comme nous le disions dans l’introduction1 l’orienté o#$et est un mo-en de re rou!er des )aria#le !our !ou)oir traiter des ensem#le comme des entités !ro!res.de c&ar1 comme on com!te en mettre un qui n’e'iste !as1 qui n’est !as déclaré1 #re6 un nou)eau comme !our le Strin on met le mot cle6 ne9 et on met de la donnée.3 Instanciation *ous allons dé6inir des classes mais !our sa)oir comment on les instancie nous allons d’a#ord re arder cette classe inté rée dans le =rame9or? que nous a)ons dé$G utilisée a)ec une instanciation sim!le : le Strin C# S-stem. B. !ro!ose dé$G une #elle liste d’o#$ets. La A dé6inition B est a!!elée la classe et la )aria#le contenant l’o#$et est a!!elées l’instance..2. Le code C#2. <ans cet e'em!le l’ar ument est un @rra. S-stem est un *ameS!ace que l’on !eut aussi a!!eler A es!ace de nom B.2 %sin <ans la !artie 2 )ous a)eF certainement trou)é que l’on utilisait #eaucou! A S-stem.: com!ilera normalement en C#3. C# est un lan a e 6ortement orienté o#$et.5. "ar6ois on doit créer une classe !our ran er des )aria#les1 mais !our une utilisation locale et qui ne sortira !as de la mét&ode en court.

Ces modi6icateurs sont communs !our les classes1 les mét&odes1 les attri#uts1 les accesseurs1 c’est donc im!ortant G connaitre et )ous aller les croiser sou)ent Isurtout les trois !remiersJ. <es acc4s !lus restreints entrainent !lus de 6acilité !our re!érer les erreurs1 en réduire le nom#re1 une auto com!létion !lus !ertinente1 !lus de 6acilité si quelqu’un doit utiliser la classe et de ci#ler la documentation sur les )aria#les1 mét&odes et !ro!riétés accessi#les. Me )ais )ous !résenter des o#$ets de S-stem. Certaine )aria#les internes au' o#$ets ne requi4rent !as d’interactions de!uis d’autres !arties a!!licati)es. ' Internal : internal retire l’acc4s G toutes les mét&odes et tous les éléments qui ne !arta ent !as la mHme assem#l.@ddI12JS Ce t-!e de liste )ous !ermet de ran er1 a$outer1 enle)er1 modi6ier1 trier et c&erc&er les éléments. 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 .3. ' "ri)ate : Destreint l’acc4s G la classe mHme1 il sera sou)ent !ré6éra#le d’utiliser "rotected.Collection. L’attri#ut est donc la )aria#le sim!le dans la classe1 )ous en a)eF dé$G )us dans la structure. 3..#.21 C# : L’essentiel en concentré )ar classeanon-me ] ne9 Q a]11 #]121 c]Rte'teR1 d] Rquelquec&oseRTS Console. C# !u#lic List[int\ liste ] ne9 List[int\IJS liste.. ' "rotected : Comme "ri)ate1 la di66érence étant mince elle sera e'!liquée dans la !artie sur l’&érita e.oStrin IJ/classeanon-me. <e ce 6ait !our 6aire des listes de t-!es anon-me1 #ien qu’il . Le t-!e des éléments contenus dans la liste doit corres!ondre au t-!e entre les c&e)rons.1 L’attri#ut et le modi6icateur d’acc4s Cn a dé6ini le mod4le o#$et comme un mo-en conce!tuel !our or aniser des )aria#les et les traiter !ar rou!e.(eneric. 0ous !ourreF utiliser ces listes !our ran er des o#$ets de mHme t-!e ou de t-!e de mHme 6orme.Iqui ne 6ont !as !arti du mHme 6ic&ier com!iléJ. 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é.riteLineIclasseanon-me. Ces ni)eau' d’acc4s sont dé6inis !ar un de ces quatre mots cle6s: ' "u#lic : donne tout l’acc4s G toutes les mét&odes de toutes les classes.cJS Comme dit !récédemment1 le 6rame9or? est un ensem#le de classes or anisées dans des es!aces de noms1 !our l’instant nous a)ons uniquement utilisé des éléments de S-stem. Les attri#uts dans les classes comme dans les structures doi)ent a)oir de dé6ini un de ré d’acc4s.ait des astuces1 que ce soit décom!iler les assem#lies !our connaitre le nom de la classe anon-me ou autre elles s’a)4rent rele)er de la #idouille et ne sont !as e'!licites G la lecture du code. De6aisons en "artial une !etite déclaration d’attri#ut que l’on )a instancier.

@ddI)ar.Deadae-IJS T T T La )aria#le déclarée a)ec le mot cle6 A const B doit Htre attri#uée dans la mHme instruction et ne !ourra !lus Htre modi6iée.Collections.riteLineI)ar.# /] R R / )ar.(enericS names!ace Console@!!lication Q !artial class Class Q !u#lic strin # ] constante.oStrin IJS Console.22 C# : L’essentiel en concentré T T C# : 6ic&ier 1 usin S-stemS usin S-stem..#JS Console.aJS )ar..listef:g.a ] iS 1er a)ril 2::5 . 3.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. 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.. Cn )erra d’autres mo-ens qui !eu)ent !araitre !lus !ratique !our limiter en écriture les )aria#les. 0oici un e'em!le de code1 noteF #ien les mots cle6s A et B1 A set B et A )alue B. <e !lus1 on !eut )ouloir contrYler l’acc4s en lecture de certaines )aria#les ou mHme les mettre dans un 6ormat !lus !ro!ice que celui du 6onctionnement interne G l’o#$et.4 La !ro!riété Lorsque l’on a des )aria#les assimilées G des o#$ets1 elles !eu)ent a)oir des contraintes autres que les contraintes in6ormatiques1 !our é)iter qu’une )aria#le en6rei ne ces contraintes1 on !eut en dé6inir G l’attri#ution.

1er a)ril 2::5 . et Isans setJ !ermet de modi6ier en interne les )aleurs.. <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. . Si on déclare la classe enti4re en statique1 cela entraine qu’on ne !ourra !as en 6aire d’instances et qu’il n’.riteLineIo#$et. 3.riteLineIClass. Cn !ourrait tout G 6ait mettre !lusieurs instructions dans le et Iqui corres!ond G l’acc4s en lecture de la )aria#le s!écialeJ. Cn !eut 6aire un accesseur a)ec seulement et ou seulement set !our l’a)oir en lecture seule ou écriture seule. Le mot cle6 A static B !ermet d’a)oir des )aria#les et mét&odes utilisa#le non !as d’une 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#utJS T Console.aJS T Console.5 Static *ormalement !our accéder G un attri#ut1 une !ro!riété ou une mét&ode1 on doit 6orcément créer un o#$et de la classe !our !ou)oir l’utiliser.Deadae-IJS T T @insi1 quand on a!!elle l’attri#ut A a B d’un o#$et de classe A Class B1 en réalité on acc4de G i)ar. Com!arati)ement au mot cle6 A const B qui em!Hc&e toute écriture1 le cou!le )aria#le !ri)ée. Ce !rocédé sécurise l’a!!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.ous les éléments d’une classe statique doi)ent Htre s!éci6iés en statique. Les attri#uts ne sont !as 6orcément liés G une )aria#le interne1 elle !eut tout a 6ait mani!uler !lusieurs ou aucune )aria#le Idans ce dernier cas l’intérHt sera limité !ar ra!!ort G une mét&odeJ.23 C# : L’essentiel en concentré Console.aura !as de constructeur.attri#ut ] iS Console..Deadae-IJS T T Si $e )eu' une classe qui ser)e de A #oite G outils B $e !eu' créer des mét&odes statiques qui ne nécessitent !as que la classe soit instanciée.

2 Les mét&odes Le mot 6onction )ous !araitrait certainement !lus clair et c’est !our Ua que $usqu’G ce !oint du c&a!itre il m’arri)ait de l’em!lo-er1 mais les 6onctions qui sont liés G des o#$ets ont une autre a!!ellation : ce sont des mét&odes. "our com!rendre les mét&odes il 6aut sa)oir qu’elles sont dé6inies !ar : un de ré d’acc4s1 un nom1 un t-!e de retour et des t-!es et un nom#re I!ou)ant Htre nulJ d’ar uments. C# class "ro ram Q static int EainIstrin fg ar sJ Q 6oreac& Istrin s in ar sJ Console.. <ans le cas d’une classe statique1 il 6audra utiliser !ri)ate au lieu de !rotected1 ce sera détaillé dans la !artie sur l’&érita e.e'e a)ec des ar uments B a)ec des ar uments Comme )ous l’aureF remarqué1 Eain est Statique1 c’est tout #onnement car lorsque le !ro ramme s’e'écute1 la classe contenant Eain n’est !as instanciée. ' Comment entrer une mét&ode e'istante dans une )aria#le ' Comment 6aire des A mini-mét&odes B !ratiques en ar ument ' +t en6in nous a#orderons les Itérateurs. Cette dé6inition est a!!elée A !rotot-!e B ou A si nature B et a une s-nta'e !articuli4re. <ans cette !artie essentielle sur les mét&odes1 nous allons : ' commencer !ar e'!liquer la mét&ode Eain1 nous allons aussi )oir comment !asser des !aram4tres G l’e'écution1 comment une mét&ode retourne une )aleurd >re6 l’essentiel de ce que l’on a G com!rendre sur les mét&odes sera e'!liqué sur la mét&ode Eain que l’on a #eaucou! utilisée sans )raiment l’e'!liquer.1Detour sur Eain Le C# est tr4s orienté o#$et1 du cou! mHme la mét&ode qui s’e'écute au dé#ut du !ro ramme est ran ée dans une classe. ' "uis nous a#orderons comment !ro!oser !lusieurs A si natures B a)ec la mHme mét&ode Ila surc&ar eJ.2. "our l’instant nous n’a)ons )u que la mét&ode Eain qui sera traité et e'!liquée en !remier lieu. Comme on a dé$G #eaucou! utilisé Eain re ardons-le directement !our !ou)oir e'!liquer clairement les c&oses.24 C# : L’essentiel en concentré Demarque : Les classes statiques sont un mo-en sim!le de 6aire un Sin leton.riteLineIsJS Console. 3.Deadae-IJS return :S T T Detour Console: e'écuté manuellement : A C:NadresseNa!!lication. ' *ous )errons ensuite comment créer une mét&ode qui !ermette de énérer !ro!rement le contenu de la classe a)ec des ar uments Iles constructeursJ. 3. %n sin leton est un o#$et qui ne !eut Htre instencié qu’une seule 6ois1 ici la classe statique ne !eut a)oir qu’une A instance B. @ntérieurement1 Eain n’a)ait 1er a)ril 2::5 .

destructeur 0ous trou)ereF sou)ent dans les classes non statiques des mét&odes dites jconstructeursk..noms ] nomsS t&is.0oid1 il n’est utilisé que !our mentionner que la mét&ode ne retourne !as de )aleur et en unsa6e !our 6aire !ointeur )ers données de t-!e inconnu. =aire retourner une )aleur de t-!e int G un !ro ramme sert G s!éci6ier un code d’erreur. Ce sont des mét&odes qui ser)ent G mettre des )aleurs !ar dé6aut1 G créer des élémentsd Si on )oulait !ar e'em!le 6aire une classe qui ran e un $eu d’allumette !roc&e de celui que l’on a 6ait antérieurement : C# usin S-stemS class Meu Q readonl.Cette mét&ode !ermet d’initialiser une nou)elle !artie 1er a)ril 2::5 . %suellement1 il est !u#lié a)ec le lo iciel une corres!ondance entre la )aleur de retour en cas d’erreur et les erreurs elles mHmes. PP Le !roc&ain e'trait de code sera G a$outer ici PP . "ar6ois !our les !rocédures1 il !eut Htre !lus !ratique de 6aire un return true quand il n’.] )aria#le ne !eut Htre accédée readonl. )oid est l’allias de S-stem.init(ameIJS T . !rotected int $oueurS !rotected int tourS !rotected int #atonetsS !u#lic strin fg nomsS !u#lic static uint n#re<InstancesS . "ar con)ention1 le : si ni6ie que tout c’est #ien dérouler1 ensuite on !eut créer !lein de )aleur de retour !our si naler les di66érentes erreurs !ossi#les.. 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.!u#lic int n#reMoueursS.25 C# : L’essentiel en concentré !as d’ar ument et G la !lace de A int B il . Le t-!e s!écial )oid que nous utilisions sert G dire que la mét&ode ne retourne rien.a)ait le mot )oid. !u#lic )oid init(ameIJ .!u#lic int n#re>atonetsS..VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV V 0oici le Constructeur1 c’est une mét&ode s!éciale sans t-!e de retour V et qui !orte le mHme nom que la classe.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. 3. readonl. !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.2Constructeur . <e ce 6ait1 dans cet e'em!le1 Eain retourne une )aleur : :. Le mot cle6 return met 6in G la mét&ode et lui 6ait retourner la )aleur qui suit. en écriture que dans le constructeur... Contrairement au C1 une mét&ode de)ant retourner une )aleur sans mot cle6 return ne !asse !as la com!ilation1 de ce 6ait une mét&ode qui a un t-!e de retour autre que )oid 6inira s-stématiquement !ar un return.2.de strin est com!osé de l’ensem#le des c&aines qui sui)ent la commande en sé!arant !ar des es!aces. V Cn initialise ici les )aria#le de Meu !ro!re au' A o!tions B VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV.

noms corres!ond G la !ro!riété !u#lic quand noms seul corres!ond G la )aleur !assé en ar ument de la mét&ode.. Console. Si )ous décommenteF la #oucle 6or et essa-eF !lusieurs 6ois en modi6iant quelques )aleurs1 )ous !ourreF constater le 6onctionnement du ar#a e collector...Slee!I1:JS T V.riteLineIMeu..Console.ourIJ . Il est ici em!lo-é !our é)iter un con6lit de noms.Console..oStrin IJ/R .."erduIJJS . Le mot cle6 !arams est utilisé ici dans le constructeur mais est o!tionnel et !eut Htre utilise !our n’im!orte quelle mét&ode.riteLineI$eu. La mét&ode "erdu sera rem!lacée dans la !artie sur la redé6inition !u#lic strin "erduIJ Q return nomsf$oueurg/R a !erdu au #out de R /tour. A t&is B corres!ond G l’instance en cours de traitement donc t&is.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..n#re<InstancesJS $eu ] ne9 MeuIi1 i1 ne9 strin fg Q R$oueur1R1 R$oueur2R TJS S-stem.V 6or Iint i ]: S i [ 1::::S i//J Q Console..Console. %n mot cle6 im!ortant n’a !as été a#ordé : t&is.ourIJJS ..riteLineIR@ R / nomsf$oueurg / RNnil reste R / #atonets.&read. e'écutera le test $usqu’G ce qu’il retourne 6au' Console..22 C# : L’essentiel en concentré Q $oueur ] :S tour ] :S #atonets ] n#re>atonetsS T !u#lic #ool .DeadLineIJ1out tm!JS i6 Itm! \ : ^^ tm! [ 3J #atonets -] tm!S else #atonets -] 3S i6 I#atonets [ 1J return 6alseS return trueS T . Q int tm!S tour//S i6 I$oueur [ n#reMoueurs-1J $oueur //S else $oueur ] :S S-stem..riteLineIR. Il est utilisé !our le dernier ar ument1 il est sui)i d’un t-!e arra.oStrin IJJS S-stem.ours.&readin ..Deadae-IJS T T Demarque : 0oilG un e'trait de code susce!ti#le d’éclaircir l’intérHt du mot cle6 static.et 1er a)ril 2::5 ...r-"arseIS-stem.oStrin IJ / R alumettesNn!reneF un nom#re d`allumettes entre 1 et 3 Ide6aut 3JRJS int.quand le ar#a e collector )eut e66acer un o#$et il a!!elle de destructeur !uis su!!rime les données de l’instance qui ne l’ont !as été.our R/tour.e'écute un tour et ren)oie 6au' si dé6aite.

"arams acce!te aussi la s-nta'e a)ec arra.r-"arse B d’Int321 ce mot cle6 a!!arait !our dire que l’ar ument !asse !ar ré6érence. La seule di66érence est que l’on utilise out !our une mét&ode qui )as donner une )aleur sans tenir com!te de l’actuelle tant disque re6 sera !lus utilisé !our traiter une )aria#le 6aire en sorte qu’elle ait une nou)elle )aleur G !artir de sa )aleur actuelle.noms ] ne9 strin fg QRCro)a'R1R"o!iRTS t&is.si nature des mét&odes qui les utilisent. Sans le mot cle6 A !arams B1 l’instanciation de la classe A Meu B n’aurait !as était comme )u dans l’e'trait IA Meu $eu ] ne9 MeuI15121RCro)a'R1R"o!iRJS BJ mais a)ec un )érita#le arra.3 La surc&ar e 0ous trou)eF !eut Htre qu’il n’est !as !ratique de ne !as !ou)oir 6aire un o#$et !ar dé6aut1 d’a)oir G s!éci6ier G c&aque 6ois tous les ar umentsd "our !ou)oir a)oir le c&oi' entre !lusieurs !ossi#ilité d’ar uments en entrée il e'iste la surc&ar e des mét&odes. <e ce 6ait1 re6 attend une )aria#le a-ant une )aleur attri#uée tandis que out une )aria#le déclarée mHme sans attri#utions 6era l’a66aire.en ar ument. C`est-G-dire que la )aria#le !ourra Htre modi6iée dans la mét&ode1 car les t-!es A )aleurs B ne sont $amais modi6iées quand ils sont !assés en ar ument sans mots cle6s s!éci6iant le contraire. B1 il su66it de !récéder l’o!érateur du mot cle6 o!erator. 3. *ous utilisons le mot cle6 A out B dans la mét&ode statique A .2. C# class Meu Q d !u#lic MeuIJ Q n#re<Instances//S n#reMoueurs ] 2S n#re>atonets ] 15S t&is. *ous allons !rocéder G la surc&ar e du constructeur.r-"arse !roc4de comme "arse sau6 qu’il entre : dans la )aria#le au lieu de énérer des erreurs. . <e ce 6ait on n’est o#li é de !asser des )aria#le et non !as des )aleurs !our que la mét&ode !uisse mettre ses données quelque !art. Le <estructeur n’a ni de t-!e de retour ni de de rés d’acc4s ni d’ar uments. Les mots cle6s !aram1 re6 et out !araissent dans les !rotot-!es. La surc&ar e !eut aussi s’a!!liquer G un o!érateur comme le A V B1 le A . "our améliorer la lisi#ilité du code il est encoura é d’utiliser e'!licit dont le com!ortement est !lus !ré)isi#le.ous les derniers ar uments G l’a!!el de la mét&ode de)ront Htre des strin s et rentrerons dans l’arra-. Son nom est celui de la classe et est !récédé d’un tilde A l B.en ar ument IA Meu $eu ] ne9 MeuI15121ne9 strin fg QRCro)a'R1R"o!iRTJS BJ. . Cn !eut aussi surc&ar er l’o!érateur unaire de cast1 il . %n mot cle6 tr4s !roc&e de out e'iste : re6.23 C# : L’essentiel en concentré d’un nom de )aria#le IA noms BJ. La surc&ar e !eut Htre déclarée dans la classe d’instance 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.a deu' t-!es de dé6inition de cast : im!licit et e'!licit. %ne surc&ar e !ermet de c&an er les !aram4tres et le t-!e de retour.init(ameIJS T !u#lic static Meu o!erator/IMeu un1Meu deu'J 1er a)ril 2::5 . La surc&ar e d’une mét&ode !ermet de c&an er la si nature en ardant le mHme nom. <u 6ait que ce soit )ous qui dé6inissieF l’e'écution )ous !ou)eF l’utiliser 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.

n#re>atonets 1 un.$e suis o#li é de recréer une instanceJ. Le t-!e de délé ué corres!ond G une si nature1 un t-!e délé ué indique les t-!es des ar uments et le t-!e de retour de la mét&ode que le délé ué associé )a contenir.Len t&gS int ! ]:S 6or Iint i]: S i[un.noms.n#reMoueursST !u#lic static e'!licit o!erator MeuIint aJQreturn ne9 MeuIa121R"o!R1 RCro)RJST .noms..Len t&Si//J nomsf!//g]un.riteLineIa.n#reMoueurs / deu'.25 C# : L’essentiel en concentré Q strin fg noms]ne9 strin fun.4<ele ate Le dele ate est comme un !ointeur de 6onction1 c`est-G-dire une )aria#le qui indique une 6onction !ou)ant s’utiliser comme telle. C# 1er a)ril 2::5 .n#reMoueurs1 nomsJS T !u#lic static Meu o!erator.nomsfigS 6or Iint i]: S i[deu'.Deadae-IJS T T @insi im!lémenté1 l’addition !ermet de créer un $eu a-ant les $oueurs en commun1 le nom#re de #Ltonnets initial additionné Idu 6ait qu’ils soient en readonl. Cn !ourrait aussi G !artir de l’o!tion A n#re>atonets B énérer en un cast une instance a!!ro!riée !ar dé6aut.n#re>atonets .noms."erduIJJS Console.nomsJS T !u#lic static im!licit o!erator intIMeu aJQreturn a.IMeu #1int aJ Q return ne9 MeuI#. L’intérHt de créer des t-!es de délé ués est a)ant tout de sécuriser le code et de sa)oir comment utiliser le délé ué.n#reMoueurs1 #..2. Ce !rinci!e !ermet de !asser une mét&ode en ar ument et aussi de !ou)oir modi6ier l’e'écution sui)ant l’état dmune )aria#le dele ate. Cn commence !ar énérer un t-!e de délé ué1 !uis ou !eut déclarer des délé ués a)ec un de ré d’acc4s in6erieur ou é al G celui du t-!e.. I Demettre init(ame1 .nomsfigS return ne9 MeuIun.ourIJJS Console. Cn !eut son er !ar e'em!le dans une é)entuelle é)olution du $eu en réseau 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 d’un ser)eur.Len t&/deu'.n#re>atonets / deu'. L’e'em!le ici montre !lus un e'em!le d’utilisation que l’utilité réelle des délé ués1 mais d’autres e'em!les !ourront )ous éclairer sur l’utilité d4s la !artie !roc&aine.Len t&Si//J nomsf!//g]deu'.noms.a1 #. 3. <e !lus si on entre dans un délé ué une mét&ode qui a !lusieurs surc&ar es1 l’inter!réteur déduira la quelle !rendre !our que les si natures entre la surc&ar e et le t-!e de délé ué corres!ondent.our1 "erdu et lMeu de l’e'em!le !récédent 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.12S c ] aS a /] IMeuJcS 9&ile Ia.*IPRJS a ] a .

%n é)4nement ne !eut Htre e'écuté que de!uis la classe il est déclaré mais !eut Htre modi6ié de!uis une autre s’il est !u#lic. 3. *ous !ou)ons aussi utiliser des délé ués en !aram4tres1 nous )errons cela dans la !artie qui suit.les mét&odes associées 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 ..<éclaration : t-!e de délé ué .=orms.>uttonIJ t&is. "ar e'em!le1 un utilisateur qui clique sur un des #outons de l’inter6ace lance une !rocédure.. C# 1er a)ril 2::5 .. C’est #ien a ir en 6onction des interactions.27 C# : L’essentiel en concentré usin S-stemS class test<ele ate Q !u#lic dele ate int t-!e<e<ele ueIre6 int aJS.ci dessous on déclare une instance du délé ué test<ele ate. Les é)4nements se déclarent a)ec le mot cle6 A e)ent B et un t-!e de délé ué.indo9s. La !ro rammation é)énementielle consiste G réa ir en 6onction des é)4nements.. Console.#utton1iClic?JS Les é)4nements sont des délé ués )oire des listes de délé ués qui s’a!!ellent G !eut !rHt comme de sim!les mét&odes..in=orm ci-dessus nous )o-ons que le #outon a !ar dé6aut un é)4nement e'istant.#utton1 ] ne9 S-stem. *oteF le !oint )ir ule a!r4s le 9&ile : seule la condition sera e'écutée $usqu’G Htre 6ausse.t-!e<e<ele ue a ] test<ele ate.2.. Les a!!lications G inter6aces ra!&iques sont sou)ent associées au' conce!ts de !ro rammation é)énementielle. la mét&ode sans !arent&4se corres!ond G l`adresse 9&ile IaIre6 0aleurJ [ 1::J S .incrementerS .. a)ec !arent&4ses la mét&ode est e'écutée. L’é)4nement n’étant !as une notion tr4s sim!le G inté rer $’ai !ro!osé deu' e'em!les. <ans l’e'trait énéré de . <ans nos e'em!les nous allons utiliser sans quitter notre console les é)4nements !our )oir leur 6onctionnement.. le délé ué sans !arent&4se corres!ond G la )aria#le .+)entcandlerIt&is. C# t&is. Le !lus sou)ent ce t-!e de délé ué sera celui du 6rame9or? : +)entcandler I*ous )errons quelle si nature corres!ond G ce t-!e de délé uéJ. Le 6ait que l’utilisateur !uisse G tout moment a ir sur n’im!orte quel #outon entend que ce n’est !as une !rocédure G )aria#le qui se déroule de mani4re uni6orme.Deadae-IJS T T Les t-!es de délé ués sont accessi#les comme des éléments statiques.Clic? /] ne9 S-stem. <ans cet e'em!le sim!le nous a)ons utilisé a comme un !ointeur )er la mét&ode incrémenter.#utton1.riteLineI0aleurJS Console.5 Les é)énements Les é)4nements 6ont !arti d’un t-!e de !ro rammation G !art enti4re1 on !arle de !ro rammation é)4nementielle qui s’o!!ose !artiellement G la !ro rammation !rocédurale.

addie)enementIiJS a..riteLineIi. <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 l’état d’une )aria#le.+m!t-JS Il4)e une e'ce!tion si aucune mét&ode assiciéesJ 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. 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 .riteLineIRe'ecution de la mét&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..Console. +)entcandler est un délé ué de mHme si nature que celui-ci-dessous. !u#lic dele ate )oid elemIo#$ect sender1+)ent@r s eJ S .riteLineIRe'ecution de la mét&ode 1RJST !u#lic static )oid e'em!leie)enement2Io#$ect sender1 +)ent@r s eJ QConsole. e)enementIt&is1 +)ent@r s....e'ecuteIJS T S-stem... .oStrin IJ / RiiiiiiiiNnRJS a..+m!t-JST !u#lic static )oid e'em!leie)enement1Io#$ect sender1 +)ent@r s eJ QConsole. !u#lic e)ent elem e)enementS !u#lic e)ent +)entcandler e)enementS !u#lic )oid addie)enementIint iJ Q .Deadae-IJS T T <ans notre !remier e'em!le l’é)4nement est utilisé de mani4re tr4s !rocédurale.3: C# : L’essentiel en concentré usin S-stemS class e'em!le1 Q .

ilo a#leJS T !u#lic static )oid acces+critureIe'em!le2 sender1 +)ent@r s eJ Q Console.+m!t-JS return ilo a#leS T set Q ilo a#le])alueS i6 Iecrit P] nullJ ecritIt&is1 +)ent@r s..Lo a#le ] #.riteLineI#.+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 ecriture:R / sender.s9itc&Lo IJS #..riteLineIR@cc4s en lecture:R / sender..Console.Lo a#le ] #. 3. Cet outil !ermet de créer une mét&ode !ointé !ar un délé ué sans a)oir G la mettre dans une classe : L’utilisation est sim!le : C# usin S-stemS 1er a)ril 2::5 ..2.Lo a#leS Console.Deadae-IJS T T Le terminal n’est !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 utilisés dans de )rais !ro rammes .:.2 Eét&odes anon-mes et +'!ressions lam#da Les mét&odes anon-mes 6ait !artie des nou)eautés du C#2.Lo a#leJS #.s9itc&Lo IJS #.ilo a#leJS T T class "ro ram Q static )oid EainIJ Q e'em!le2 # ] ne9 e'em!le2IJS #.Lo a#leJS S-stem.riteLineI#..*+.31 C# : L’essentiel en concentré !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.Lo a#le ] RtestRS #.Lo a#leS Console.Lo a#le ] Rsans lo c`est moins )er#eu'RS #.

..riteIRaRJS T JS Console.dele ateIJQConsole.*o@r a66ic&e@ ] dele ateIJ Q Console. C# Iint ar 11 int ar 2J ]\ ar 1/ ar 2 .e'ecuter1:=oisIa1a66ic&e@J S ou !lus instructi6 : )ar... Les e'!ressions lam#da sont des délé ués anon-mes limités G une instruction1 la s-nta'e est claire1 ra!ide et lisi#le mais on ne !eut mettre de #oucles. 1er a)ril 2::5 . 0ous !ou)eF 6acilement ima iner une attri#ution conditionnelle dans la quelle le 6ormata e dé!endra de la mét&ode !ointé !ar la )aria#le délé uée.a un seul !aram4tre t-!é im!licitement !as #esoin des !arent&4ses !our l’isoler. Si le t-!e de délé ué attendu a un t-!e de retour1 la seule A instruction B de l’e'!ression lam#da sera retournée.délé ué attendu Idonc !as 6orcément intJ IJ ]\ Console.e'ecuter1:=ois I dele ateItest<ele ate. La s-nta'e de l’e'!ression lam#da est sim!le : les !aram4tres du délé ué anon-me1 le si ne A ]\ B !uis l’instruction. De6aisons la mHme c&ose que tout G l’&eure a)ec ces lam#da e'!ressions... )ar.riteIRaRJ.riteLineIRNniiiiiiiiiiiiiiiiiiiiiiiiiNnRJS test<ele ate.e'ecuter1:=oisS ...riteIRaRJST 0oici trois e'em!les &ors conte'te. Demarque : la !artie qui suit sur l’e'!ression lam#da et les mét&odes d’e'tension est com!osée essentiellement de nou)eautés 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.riteIRaRJS TS )ar.32 C# : L’essentiel en concentré 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.e'ecuter1:=oisIa66ic&e@JS Console. *oteF que les délé ués anon-mes sont t-!és automatiquement !our entrer dans la )aria#le ou en ar ument.dele ateIint ar 11int ar 2JQreturn ar 1/ar 2ST ar ]\ ar / 4.@r <ele ate a ] )ar..: qui est rétro com!ati#le !our !ou)oir 6aire ce qui )as sui)re. Le t-!e du !aram4tre !récédent dé!end du t-!e ..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 délé ués quels qu’ils soient. Si on ne s!éci6ie !as le t-!e il est s!éci6ié automatiquement et s’il ..*o@r 6onctionJQ6orIint i]:Si[1:Si//J 6onctionIJST1 dele ateIJ Q Console. dele ateIint ar JQreturn ar /4ST .

Deadae-IJS T T *ous a)ons )u l’essentiel sur les mét&odes et les délé ués1 nous allons désormais )oir comment on !eut lier nos mét&odes G des o#$ets du 6rame9or?.. 3.ici on déclare une instance du délé 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.2. Les mét&odes d’e'tensions sont des mét&odes statiques qui !ermettent de s’utiliser comme si elles étaient !ro!re G une classe autre que celle dans la quelle elle est dé6inie.oStrin IJ / RiR / s. Me m’e'!lique1 si )ous )ouleF 6aire une mét&ode de traitement de strin 1 )ous n’alleF !as !ou)oir modi6ier la classe strin du 6rame9or? !our a$outer une mét&ode de traitement1 donc )ous alleF de)oir créer une classe a)ec une mét&ode statique !uis 6aire a!!el G cette classe !our le traitement.e'ecuter1:=ois I .o%!!erIJ / RiR / i.riteLineI)arJ.riteLineIsJS T !u#lic static strin title=ormatIt&is strin s1int iJ Q return RNnR / RiR / I//titleInde'J.@r <ele ate a ] )ar.riteIt&is strin sJ Q Console.. "ar e'em!le ci dessous on crée une mét&ode qui !ermet de n’a)oir G écrire que )ar. C# usin S-stemS static class Strin .33 C# : L’essentiel en concentré 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 ..Itest<ele ate.oStrin IJ / RiR / RNnR S T 1er a)ril 2::5 . La mét&ode d’e'tension !ermet d’a!!liquer la mét&ode statique comme si elle était dans la classe.riteIRaRJ JS Console.*o@r 6onctionJ ]\ aI6onctionJ1 6onction ]\ aI6onctionJ 1 IJ ]\ Console.....e'ecuter1:=oisS )ar.3 Eét&ode d’e'tension..ool>o' Q static int titleInde' ] :S !u#lic static )oid ..riteIJ a)ec )ar )aria#le de t-!e strin au lieu de 6aire Console.

on !roc4de G une modi6ication qui c&an era le résultat .o%!!erIJ /RiR/I//IJ. 6or Iint i ] :S i [ 1::S i//J Q . on a créé l`énuméra#le a)ec title=ormat I+numerator enumerateur ] enumera#le. *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.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.. conclusion rien n`as encore été calculé.> Q !u#lic static int I ] :S !u#lic static )oid .. 3.I ] 5S . si on ne commenUait !as !ar un Eo)e*e't le !remier résultat serait RnullR enumerateur. Ces mét&odes retournent des o#$ets I+numera#le ou I+numerator I*ous !ri)ilé ierons I+numera#le qui !eut Htre utilisée dans un 6oreac&J. I+numera#le et I+numerator ne contiennent !as le résultat mais le mo-en d’.riteIJS Console..34 C# : L’essentiel en concentré T class "ro ram Q static )oid EainIJ Q 6orIint i]:Si[1:Si//J IR#on$our R/REonsieurRJ. on e'trait l`énumérateur Strin ..>..title=ormatIiJ.CollectionsS static class Strin ..oStrin IJ/RiR/s..Eo)e*e'tIJS 1er a)ril 2::5 .(et+numeratorIJS .accéder1 !our !reu)e1 l’e'em!le modi6iera le résultat a!r4s la déclaration de l’énuméra#le et le !arcourra deu' 6ois a)ec deu' résultats di66érents.Deadae-IJS T T Le mot cle6 qui sert G s!éci6ier que la mét&ode est une mét&ode d’e'tension est le mot cle6 t&is1 on mettra tou$ours ce t&is a)ec le !remier ar ument Iqui est l’o#$et qui !réc4de le !oint lors de l’a!!elJ..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. C# usin S-stemS usin S-stem.2..riteIt&is strin sJ Q Console.5 Itérateurs Certaines mét&odes sont a!!elées des itérateurs1 elles utilisent le mot cle6 -ield..title=ormatI1::JS .

oute )aria#le !eut Htre !assée en ar ument d’une mét&ode qui attend un o#$et de t-!e A o#$ect B.>.>. <e ce 6ait !eut im!orte le t-!e de retour qui entrera la donnée dans ma )aria#le d4s lors que ce t-!e im!lémente l’inter6ace I+numera#le car ce retour aura 6orcément le com!ortement attendu. C#$ect est la classe G la #ase de tout1 c’est o#$ect qui im!lémente la mét&ode .. 1er a)ril 2::5 . <ans l’e'em!le !récédant on utilisait I+numera#le et I+numerator comme les t-!es des )aria#les mais c’est $uste rLce au 6ait que le !ol-mor!&isme marc&e a)ec les inter6aces en !lus des classes m4res.. ..>. 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 di66érentes !our !eu qu’ils se com!ortent !areil.oStrin que l’on a #eaucou! utilisé.Deadae-IJS .. ' !rotected : Les éléments !rotected d’une classe sont lé ués au' classes en6antes. !arcour a)ec 6oreac&: 6oreac& Istrin s in enumera#leJ s. <e ce 6ait toutes )aria#les quelque soient leur t-!e !eu)ent Htre utilisé comme des )aria#le de t-!e o#$ect.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 énuméra#les1 de les im#riqués a)ec une 6acilité étonnante1 et #iensur G l’acc4s en lecture1 Ua e'écute le nécessaire !our accéder G la donnée.. . Quand on im!lémente une inter6ace on aranti un com!ortement1 si on im!lémente !ar e'em!le l’inter6ace I+numera#le1 notre o#$et !ourra #éné6icier de linq et Htre énuméré dans un 6oreac&.IS .35 C# : L’essentiel en concentré strin s ] enumerateur.I V 2:Strin .I ] :S Console. 3.ous les o#$ets !eu)ent Htres a!!elés comme des o#$ets d’un de leurs t-!es !arents. L’&érita e conduit G des similitudes entre les o#$ets et donc de la sim!licité !our a!!rendre. nield #rea? em!lo-é dans notre e'em!le1 il ne sert G rien. caste en strin Isi im!ossi#les contiendra RerreurRJ Strin . Cette mét&ode étant de la classe m4re A uni)erselle B1 elle est im!lémentée !ar dé6aut !ar toutes les classes.riteIJS T Strin ..1 Introduction L’&érita e est un mo-en d’o66rir au' classes toutes les mét&odes et tous les attri#uts !u#lic et !rotected d’une classe e'istante. *ous ne l’a)ions !as )u mais tous les o#$ets &éritent de l’o#$et A o#$ect B. nield return a$oute une entrée dans l’énumérateur et -ield #rea? arrHte l’e'écution du #loc?.I ] Strin .>.I Z 1: ]] : O Strin .>.Current as strin OO RerreurRS . 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’orienté o#$et initie des nou)eau' mots-cle6s de restriction de droits1 commenUons !ar rée'!liquer les mots que nous connaissons dé$G dans ce conte'te d’&érita e : ' !u#lic : Les éléments !u#lic d’une classe sont lé ués au' classes en6antes. Les inter6aces sont des es!4ces de classes qui ne ser)ent qu’G Htre A &éritées B Idans le cas d’une inter6ace1 on dit qu’elle est A im!lémentée BJ. conclusion : les strin s sont calculés au 6ur et G mesure s.3.riteIJS Console.3 L’&érita e1 le !ol-mor!&isme et les inter6aces 3. nield n’est utilisa#le qu’a)ec un des deu' mots cle6s qui suit : Deturn et >rea?. multi!lie !ar 2 toutes les 1: itérations I .

5..32 C# : L’essentiel en concentré ' ' !ri)ate : Les éléments !ri)ate d’une classe ne sont !as &érité au' classes en6antes. Comme les classes statiques ne !eu)ent &ériter il est )u comme un non sens que de s!éci6ier des éléments en !rotected1 de ce 6ait on utilisera !u#lic ou !ri)ate. I%ne classe a#stract ne !eut Htre instanciéJ ' )irtual : )irtual est 6onctionnellement comme a#stract G une di66érence !rHt : dans la classe m4re il . static : Cn ne !eut !as 6aire &ériter une classe s!éci6iée en static. Les éléments statiques d’une classe non statique qui sont en !u#lic ou !rotected !eu)ent Htres accédés !ar les classes en6ante mais ne sont !as G !ro!rement !arlé &éritées. <ans ce deu'i4me e'em!le $e crée un nou)eau t-!e d’e'ce!tion dont $e ne redé6ini que le Constructeur. 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. "our dé6inir les )aria#les comme dans une e'ce!tion standard sim!lement1 $’a$oute G mon constructeur le constructeur de la classe +'ce!tion.a une im!lémentation !ar dé6aut que l’on !eut ne !as redé6inir. Le mot cle6 A #ase B !ermet d’accéder au' éléments de la classe m4re sans se soucier de son nom Is’utilise comme A t&is BJ. 0oici une liste de quelques nou)eau' mots cle6s initiés !ar la notion d’&érita e: ' sealed : @ucune classe de !eut &ériter d’une classe d’une mét&ode ou d’une !ro!riété sealed Isi on )eut qu’un élément soit !u#lic sans que les classes 6illes en &érite !ar e'em!leJ. Les éléments a#straits d’une classe eu' doi)ent Htre dé6ini1 ils sont comme des contraintes de mét&odes et )aria#le interne G dé6inir. 3. 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.EillisecondJS 9&ile ItrueJ Q i6 I1 \] r. ' 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 d’o#$ets de mHme 6orme.3. Ce t-!e d’e'ce!tion a les mHmes attri#uts et les mHmes !ro!riétés que l’e'ce!tion !ar de6ault au détail !rHt qu’il n’a qu’un constructeur.*o9.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.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.*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 .ime.

5 on !erUoit !lus nettement le !ol-mor!&isme mais nous aurons l’occasion d’.33 C# : L’essentiel en concentré Q Console.3 Dedé6inition de mét&odes et d’attri#uts Le constructeur est une redé6inition !articuli4re )u que le nom n’est !as le mHme mais !our les classes ou les éléments a#stract on se )erra o#li é de redé6inir des éléments qui e'istent dé$G ce qui normalement est im!ossi#le..oStrin IJJS T 6inallQ e ] nullS T T T T T La nou)elle classe est instanciée et le)ée comme n’im!orte quelle e'ce!tion. Le mot cle6 t&ro9 !ermet de le)er une instance d’e'ce!tion1 il sera !lus commun de )oir A t&ro9 ne9 Eon+'ce!tionIJ S B mais c’était !our $usti6ier l’usa e d’un #loc? 6inall..oStrin IJ Q 1er a)ril 2::5 . 3. *ous allons utiliser deu' mots cle6s tr4s similaires dans ce conte'te : o)erride et ne9.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.!our la dés-allocation de mémoire.re)enir. <ans l’e'em!le de la !artie 2.. #ase. 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.riteLineIe'ce!t...3.!rint@ireIJS T !u#lic o)erride strin .riteLineIIlar eur / lon ueurJ V 2JS .

!rint@ireIJS 6. Si l’on re!ense au' mét&odes d’e'tensions1 $e )ous laisse com!rendre l’intérHt du !ol-mor!&isme1 !ou)oir réduire le code et ne !as a)oir G le re6aire !our c&aque classe.. La li ne commentée montre comment $’aurais !u !ar e'em!le a!!eler la mét&ode !ar dé6aut im!lémentée !ar la classe m4re.:1 on dé6inie ce qui sera G im!lémenter. Cn dé6ini dans l’inter6ace des mét&odes et !ro!riétés G a)oir !our im!lémenter l’inter6ace !our !ou)oir #éné6icier du !ol-mor!&isme lié. ' C)erride : !ermet quand G lui de rem!lacer réellement la mét&ode de la classe m4re !our l’instance de la classe 6ille quelque soit le conte'te. Si l’instance de la classe 6ille est ran ée dans une )aria#le de t-!e de la classe m4re si la mét&ode &omon-me est a!!elée ce sera la mét&ode !ar dé6aut de la classe m4re qui sera a!!elée et non celle de la classe 6ille.35 C# : L’essentiel en concentré return Ron !eut dé6inir comment réa i la mét&ode .4 Les inter6aces Les inter6aces s’utilisent comme des classes a#straites1 on !eut les im!lémentées comme on &ériterait d’une classe. Certaines inter6ace comme I+numera#le sont au cWur du 6rame9or?1 cette inter6ace doit Htre im!lémentée que ce soit !our utiliser le mot cle6 -ield1 !our !ou)oir utiliser 6oreac&1 !our !ou)oir utiliser Linq2o#$ectd Les mét&odes des inter6aces !eu)ent Htres im!lémentées de deu' 6aUons : im!licitement ou e'!licitement.aireIJJS Console.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. Les inter6aces on tou$ours tous leurs attri#uts !u#lics1 c’est !ourquoi le de ré d’acc4s 1er a)ril 2::5 .3.riteLineIRretour d`aire casté en m4re et en 6ille Ine9JRJS Console.aireIJ / RNnR / 6. C’est donc une 6orme d’&érita e multi!le. 3.!rint@ireIJS Console.. La s-nta'e des !ro!riétés de la classe m4re est encore une nou)eauté du C#3. ' *e9 : !ermet de créer une mét&ode !ro!re G la classe 6ille qui sera a!!elée normalement sur une instance de cette classe 6ille. L’e'em!le risque d’Htre un #on com!lément d’e'!lication sur la di66érence entre la redé6inition a)ec o)erride et la redé6inition a)ec ne9...riteLineIRa66ic&a e casté en m4re !uis en 6ille Io)errideJRJS m.Deadae-IJS T T Detour Console: a66ic&a e casté en m4re !uis en 6ille Io)errideJ 22 22 retour d`aire 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.riteLineIm. Si on caste l’o#$et a)ec l’inter6ace1 seules les mét&odes qui rel4)ent de l’inter6ace seront accessi#les. Quand )ous tenteF d’im!lémenter une !ro!riété ou une mét&ode1 )ous )erreF que )otre I<+ I0isual Studio ou Eono<e)elo!J )ous !ro!ose directement la structure de #ase.

Cn ne !eut !as 6aire de mét&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 ..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.est-elle manquante OJ VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV.aireIJS Console..aireIJS .riteLineIRretour d`aire casté en Im4re et en 6ille Ie'!licitJRJS m..lon ueur Q et Q return loS TT .!rint@ireIJS 62.aireIJ QConsole..Im!lémenté im!licitement !u#lic )oid !rint@ireIJ QConsole.riteLineIIlar eur/ IIImereJt&isJ. 6. im!lémentée e'!licitement )oid Imere...riteLineIIlar eur / IIImereJt&isJ.. .. V +rreur 1: V `6ille` ne contient !as une dé6inition !our `aire` et aucune mét&ode d`e'tension V `aire` acce!tant un !remier ar ument de t-!e `6ille` n`a été trou)ée V Iune directi)e usin ou une ré6érence d`assem#l.37 C# : L’essentiel en concentré n’est !as demandé dans la déclaration de l’inter6ace.riteLineIRa66ic&a e casté en inter6ace !uis en 6ille Iim!licitJRJS m2. im!lémentée e'!licitement int Imere.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 .lon ueurJV2JST .!rint@ireIJS Imere m ] ne9 6illeIJS 6ille 6 ] ne9 6illeIJS Console.. im!lémentée im!licitement !u#lic int lar eur Q et Q return laS T set Q la ] )alueS TT .VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV V la li ne qui suit ce commentaire ne !asse !as la com!ilation..

Me ne )ais !as )ous insister sur la s-nta'e !our sérialiser Ioe il 6aut créer un 6lu' )ers un 6ic&ier te'teJ mais montrer comment rendre sérialisa#le une classe.Duntime.<eserialiFeIstreamJS stream. C# usin usin usin usin S-stemS S-stem.5 Les attri#uts Les attri#uts sont des classes &éritant de attri#ut1 leurs usa e sert G modi6ier le com!ortement d’éléments Iclasses1 enums1 structs1 mét&odesJ.Duntime. Les attri#uts ont une s-nta'e !articuli4re utilisant les croc&ets IA f g BJ...CreateJS Soa!=ormatter 6ormatter ] ne9 Soa!=ormatterIJS 6ormatter..3.4: C# : L’essentiel en concentré e.SerialiFationS S-stem.C!enIR)aria#le.'mlR1 =ileEode.riteLineIRsérialisation 6inieNndésérialisation:RJS )aria#le ] nullS stream ] =ile.Deadae-IJS T T 3.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.aireIJS Console. %n e'em!le !ratique ou les attri#uts sont utilisés c’est la sérialisation.=ormatters.riteLineIRélément sérialiFé ] R/ serialise.CloseIJS 1er a)ril 2::5 . La !artie qui suit !ermet de sérialiser et désérialiser1 ..C!enIR)aria#le. $e ne m`atarderait !as dessus1 le su$et étant les attri#uts.SerialiFation.riteLineIRélément non sérialiFé ] 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 .'mlR1 =ileEode.Duntime.oStrin IJJS Console.. Stream stream ] =ile. L’usa e d’un sim!le attri#ut !ermettra de ran er asseF 6acilement dans un 6ic&ier KEL toutes les données d’un o#$et. Si )ous )ouleF e'écuter cet e'em!le )ous aureF #esoin de la ré6érence G S-stem. +t a)ec un sim!le attri#ut on !eut demander G ce qu’un des c&am!s ne soit !as sérialisé.=ormatters.Soa! .SerialiFeIstream1 )aria#leJS stream.SerialiFation..ICS S-stem.C!enJS 6ormatter ] ne9 Soa!=ormatterIJS )aria#le ] I+'em!leSerialisationJ6ormatter.CloseIJS Console.

ool>o' Q static int titleInde' ] :S !u#lic static )oid ..@ttri#ute.riteLineIsJS T fC#soleteIJg !u#lic static strin title=ormatIt&is strin s1 int iJ Q return RNnR / RiR / I//titleInde'J. L’attri#ut ce !lace au dé#ut de l’élément et s’a!!lique sur sa lo#alité. *ous ne )oulions !as retenir un des c&am!s1 nous a)ons mis f*onSerialiFedIJg. L’attri#ut C#solete !eut se mettre sur n’im!orte quel élément.. élément sérialiFé ] 1333 élément non sérialiFé ] L’attri#ut VSerialiFa#leIJ/ a automatiquement im!lémenté le nécessaire !our que la classe !uisse Htre sérialisée.*+.. . "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 .riteLineIRdésérialisation 6inie..oStrin IJ / RiR / RNnRS T T 0oilG un autre attri#ut sim!le !our mentionner qu’une mét&ode est dé)alué.a66ic&a eIJS Console.RJS )aria#le.riteIt&is strin sJ Q Console.o%!!erIJ / RiR / i. *ous a)ons a#ordé de !r4s ou de loin tous les mots cle6s du C# G l’e'ce!tion de quelques uns I)olatile1 loc?1 e'ternal et 9&ereJ. L’en)ironnement de dé)elo!!ement !récisera les mét&odes que l’on com!te retirer au' dé)elo!!eurs !our les inciter G en utiliser d’autres s’ils !ré)oient de mettre G $our la li#rairie contenant la classe. C# usin S-stemS static class Strin . )ous !ermettra d’utiliser les connaissances de ce tutorial !our créer des sites 9e#1 créer des a!!lications 6enHtrées1 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#.41 C# : L’essentiel en concentré Console. 4 Conclusion *ous a)ons traité de mani4re tr4s s-nt&étique un su$et quasiment iné!uisa#le1 le 6rame9or? .oStrin IJ / RiR / s.Deadae-IJS T T Detour Console: élément sérialiFé ] 1333 élément non sérialiFé ] mon nom est Mir6on ri6en ra6ter sérialisation 6inie désérialisation: désérialisation 6inie.ous les attri#uts sont des classes &éritant de S-stem..

' 0ous )ous intéresseF au' a!!lications 6enHtrées O )ous !ou)eF )ous diri er )ers le tutoriel traitant des .*+. 0oici les cours )er les quels )ous !ourrieF )ous orienter.*+. 1er a)ril 2::5 .1 n’&ésiteF !as a arder ce tutoriel sous le coude comme manuel de ré6érence1 car $e ne !ense !as que l’on !uisse tout inté rer d’une seule traite. ' 0ous )ouleF 6aire !ar e'em!le un $eu )idéo1 intéresseF )ous !eut Htre au tutoriel K*@. ' 0ous )ouleF améliorer )os connaissances lo#ales sur les roua es du 6rame9or? O Le tutoriel traitant du 6rame9or? de)rait )ous satis6aire.42 C# : L’essentiel en concentré ' ' ' ' ' ' ' ' ' ' ' ' ' ' ' Les conditions Les #oucles Les @rra-s Comment érer les erreurs Comment utiliser les !ointeurs &érités du C// Les es!aces de nom Les modi6icateurs d’acc4s1 les attri#uts et les !ro!riétés Les mét&odes dont Eain1 les constructeurs et les destructeurs La surc&ar e des mét&odes Les délé ués1 é)4nements1 et e'!ressions lam#da Les itérateurs 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 d’autres cours de <ot*et-=rance1 )ous a)eF désormais le ni)eau requis.e#=orm. M’es!4re que ce c&a!itre ne )ous a !as !erdu1 et mHme ou)ert une en)ie au dé)elo!!ement . ' 0ous )ous intéresseF G l’intero!éra#ilité et au' a!!lications %ni' O !eut Htre de)rieF )ous )ous diri er )er le tutoriel Eono. est aussi lG !our )ous. Cette liste )ous donne dé$G un a)ant oht de ce que )ous !ourreF 6aire a)ec le C#.*+. ' 0ous )ouleF 6aire des sites 9e# O le tutoriel @S". .in=orm. ' 0ous )ous intéresseF G l’acc4s au' #ases de données et 6ic&iers KEL1 le tutoriel @<C.

You're Reading a Free Preview

Download
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->