Professional Documents
Culture Documents
2008 Micro Application 20-22, rue des Petits-Htels 75010 Paris 2me dition - Juillet 2009
Auteurs
Frdryk BLOT, Yann LAUTREDOU Toute reprsentation ou reproduction, intgrale ou partielle, faite sans le consentement de MICRO APPLICATION est illicite (article L122-4 du code de la proprit intellectuelle). Cette reprsentation ou reproduction illicite, par quelque procd que ce soit, constituerait une contrefaon sanctionne par les articles L335-2 et suivants du code de la proprit intellectuelle. Le code de la proprit intellectuelle nautorise aux termes de larticle L122-5 que les reproductions strictement destines lusage priv et non destines lutilisation collective dune part, et dautre part, que les analyses et courtes citations dans un but dexemple et dillustration.
Les informations contenues dans cet ouvrage sont donnes titre indicatif et nont aucun caractre exhaustif voire certain. A titre dexemple non limitatif, cet ouvrage peut vous proposer une ou plusieurs adresses de sites Web qui ne seront plus dactualit ou dont le contenu aura chang au moment o vous en prendrez connaissance. Aussi, ces informations ne sauraient engager la responsabilit de lEditeur. La socit MICRO APPLICATION ne pourra tre tenue responsable de toute omission, erreur ou lacune qui aurait pu se glisser dans ce produit ainsi que des consquences, quelles quelles soient, qui rsulteraient des informations et indications fournies ainsi que de leur utilisation. Tous les produits cits dans cet ouvrage sont protgs, et les marques dposes par leurs titulaires de droits respectifs. Cet ouvrage nest ni dit, ni produit par le(s) propritaire(s) de(s) programme(s) sur le(s)quel(s) il porte et les marques ne sont utilises qu seule fin de dsignation des produits en tant que noms de ces derniers.
ISBN : 978-2-300-023873
MICRO APPLICATION 20-22, rue des Petits-Htels 75010 PARIS Tl. : 01 53 34 20 20 Fax : 01 53 34 20 00 http://www.microapp.com
Retrouvez des informations sur cet ouvrage ! Rendez-vous sur le site Internet de Micro Application www.microapp.com. Dans le module de recherche, sur la page daccueil du site, entrez la rfrence 4 chiffres indique sur le prsent livre. Vous accdez directement sa fiche produit.
2387
Avant-propos
Destine aussi bien aux dbutants quaux utilisateurs initis, la collection Guide Complet repose sur une mthode essentiellement pratique. Les explications, donnes dans un langage clair et prcis, sappuient sur de courts exemples. En n de chaque chapitre, dcouvrez, en fonction du sujet, des exercices, une check-list ou une srie de FAQ pour rpondre vos questions. Vous trouverez dans cette collection les principaux thmes de lunivers informatique : matriel, bureautique, programmation, nouvelles technologies...
Conventions typographiques
An de faciliter la comprhension des techniques dcrites, nous avons adopt les conventions typographiques suivantes :
j gras
: menu, commande, bote de dialogue, bouton, onglet. : zone de texte, liste droulante, case cocher, bouton
j italique
radio.
j
saisir.
j
Met laccent sur un point important, souvent dordre technique quil ne faut ngliger aucun prix.
Sommaire
Chapitre 1
1.1. 1.2. 1.3. 1.4.
Premiers pas
19
Crer un premier projet ........................................... 20 crire un programme .............................................. 21 Compiler, excuter ................................................. 24 Mieux comprendre ................................................. 25
Chapitre 2
2.1. 2.2. 2.3. 2.4.
Dynamiser un programme
29
2.5.
2.6.
Dclarer une variable .............................................. 30 Utiliser une variable ................................................ 31 Les boolens ........................................................ 31 Les nombres ........................................................ 33 Les nombres entiers ................................................ 33 Ajouter des virgules ................................................. 34 Les jeux de lettres .................................................. 35 Les caractres ....................................................... 35 Les chanes .......................................................... 35 Cas pratique : crypter des messages ............................ 37 Convertir les types ................................................. 39 Passer dun entier une chane de caractres ................. 40 Transformer une chane de caractres en nombre entier ..... 40
Chapitre 3
3.1.
43
3.2.
3.3.
3.4.
Les numrations .................................................. 44 Dfinition ............................................................. 44 Dclarer une numration ......................................... 44 Utiliser des numrations .......................................... 44 Les enregistrements ............................................... 45 Dfinition ............................................................. 45 Dclarer un enregistrement ........................................ 45 Utilisation des enregistrements ................................... 46 Les tableaux ......................................................... 47 Dfinition ............................................................. 47 Dclarer un tableau ................................................. 47 Utiliser les tableaux ................................................. 48 Cas pratique : une bibliothque multimdia .................. 49
4 LE GUIDE COMPLET
Sommaire
Chapitre 4
4.1. 4.2. 4.3.
Contrler un programme
51
4.4.
Imposer des conditions ........................................... 52 Faire les bons choix ................................................ 54 Linstruction Select ................................................. 54 Rpter des oprations ........................................... 56 La boucle Tant que Faire ........................................... 56 La boucle Faire Tant que ........................................... 58 La boucle Pour Faire ................................................ 59 Bien dcouper un programme ................................... 61 Les fonctions et procdures ....................................... 61 Les paramtres ...................................................... 63 Les variables de fonction et la porte ............................ 65
Chapitre 5
5.1.
67
5.2.
Les diffrents contrles ........................................... 68 Dfinition ............................................................. 68 Les vnements ..................................................... 69 Le contrle Label .................................................... 70 Le contrle Button .................................................. 72 Le contrle ListBox ................................................. 73 Les contrles PictureBox et OpenFileDialog ................... 75 Le contrle WebBrowser .......................................... 79 Les contrles FontDialog et ColorDialog ........................ 80 Le contrle TreeView ............................................... 82 Le contrle ComboBox ............................................ 84 Les formulaires ..................................................... 86
Chapitre 6
6.1.
Penser lutilisateur
89
6.2.
Les menus ........................................................... 91 La barre de menus classique ...................................... 91 Les barres doutils .................................................. 95 Crer un lien homme-machine ................................. 105 tre clair ............................................................. 105 Organiser ........................................................... 105 Faire du beau ....................................................... 106 La transparence ................................................... 106 Lopacit ............................................................ 109
LE GUIDE COMPLET 5
Sommaire
Lancrage, le docking et le regroupement ..................... 111 Attention aux pirates ! ........................................... 115 Penser aux vrifications .......................................... 115
6.3.
Chapitre 7
7.1. 7.2. 7.3. 7.4. 7.5. 7.6. 7.7.
119
Les chiers ......................................................... 120 Les bases de donnes ........................................... 120 crire dans un chier ............................................. 122 Lire un chier ...................................................... 126 Ajouter une base de donnes au projet ...................... 131 Afficher les donnes de la base ................................ 137 Ne pas perdre la base ............................................. 141 Aller plus loin grce aux bases de donnes ................. 144
Chapitre 8
8.1. 8.2. 8.3.
145
La prvention maximale ......................................... 146 Gestion des exceptions .......................................... 147 La chasse aux bogues ........................................... 152 Cration de journaux dvnements ........................... 153 Ne pas se perdre .................................................. 161
Chapitre 9
9.1.
163
9.2.
9.3.
La programmation oriente objet ............................. 164 Cration dune classe et de ses membres .................... 165 Encapsulation ...................................................... 167 Les membres partags ........................................... 174 Les mthodes surcharges ...................................... 178 Le polymorphisme ................................................ 180 La vie des donnes ............................................... 197 Gestion des variables locales ................................... 198 Les constructeurs dobjets ...................................... 201 Rcupration de la mmoire : le ramasse-miettes ........... 203 Les destructeurs dobjets ........................................ 204 Enregistrer automatiquement vos objets : la srialisation . 205 Quest-ce que la srialisation ? ................................. 206
6 LE GUIDE COMPLET
Sommaire
Les diffrentes mthodes de srialisation ..................... 210 Les modles de conception .................................... 222 Implmentation du modle Singleton .......................... 223 Quelques modles de conception courants .................. 226 Quelques bonnes habitudes prendre ....................... 228 Pour une meilleure comprhension, bien indenter ........... 229 tre clair et expliquer ............................................. 230 Tester les lments sparment dabord ...................... 231 Forcer un comportement pour les cas derreur ............... 232 Bien dissocier les parties de votre programme ............. 233 Une application indpendante .................................. 234 La mme application rutilisable ............................... 236 Utiliser de bons outils pour de bons rsultats .............. 243 Logger avec log4net .............................................. 243 Avoir une documentation professionnelle : Ndoc ............ 256 Garder linteractivit avec lutilisateur ........................ 269 Introduction au multithreading et ses problmatiques .... 273 Une solution nave mais efficace : lexclusion mutuelle ..... 282 Le principe des tches de fond ................................. 286 Comment agir sur linterface utilisateur ? ..................... 292 Bien grer les erreurs avec plusieurs processus ............. 297
9.4.
9.5.
9.6.
9.7.
9.8.
Chapitre 10
301
10.1. Un album photo ................................................... 302 Le contrle ListView ............................................... 302 Le contrle ImageList ............................................. 309 Faire pivoter une image ........................................... 315 10.2. Dcouvrir DirectX ................................................. 319 10.3. Un lecteur multimdia ........................................... 319
Chapitre 11
11.1. 11.2. 11.3. 11.4.
323
Le langage HTML ................................................. 324 Les liens HTML .................................................... 326 Ajouter du style .................................................... 327 Garder le style ..................................................... 328 Avoir la classe ...................................................... 329 Organiser la page .................................................. 330
LE GUIDE COMPLET 7
Sommaire
11.5. Faire bouger les pages .......................................... 331 JavaScript et les variables ....................................... 332 Rester fonctionnel ................................................. 334 Les vnements ................................................... 334 Distribuer un site ................................................... 336
Chapitre 12
337
12.1. Le schma client-serveur ....................................... 338 12.2. PHP .................................................................. 339 Installer une solution PHP ........................................ 339 Utiliser les formulaires web ...................................... 340 Les deux mthodes ............................................... 343 Les instructions de contrle ..................................... 345 12.3. PHP ct serveur ................................................. 350 Enregistrer un cookie ............................................. 350 Organiser des sessions ........................................... 352
Chapitre 13
355
13.1. Lditeur, le langage .............................................. 356 Crer un projet ..................................................... 356 13.2. Les contrles web ................................................ 357
Chapitre 14
14.1. 14.2. 14.3. 14.4. 14.5.
Annexes
361
Glossaire de programmation ................................... 362 Raccourcis clavier ................................................ 365 Sites web ........................................................... 366 Blogs ................................................................ 368 Comparatif des langages ....................................... 371 C ..................................................................... 371 C++ .................................................................. 371 C# .................................................................... 372 Java .................................................................. 372 PHP .................................................................. 373 ASP .................................................................. 373 HTML ................................................................ 373
8 LE GUIDE COMPLET
Sommaire
14.6. Mots cls du langage Visual Basic .NET ..................... 374 14.7. Les Balises HTML ................................................ 376 14.8. Rcapitulatif des projets ........................................ 377 Lalbum photo ..................................................... 377 Lecteur Multimdia ................................................ 378 La RichTextBox .................................................... 379
Chapitre 15
Index
381
LE GUIDE COMPLET 9
Introduction
Quest ce que la programmation ?
Bien souvent, la premire ide que lon a de la programmation ressemble celle que lon se fait dun cours de mathmatiques : une horde de notions techniques et thoriques dont la comprhension est rserve une lite dinformaticiens. Cest totalement faux. En adoptant une dnition un tant soit peu largie, nous pouvons dire que nous sommes tous un peu programmeurs. Pourquoi ? Simplement parce que nous avons tous autour de nous des appareils lectromnagers qui nous pouvons donner des ordres et qui fournissent en rponse le rsultat voulu. Peut-tre avez-vous dj demand votre magntoscope denregistrer une mission alors que vous tiez absent ? La programmation nest rien dautre que demander un ordinateur de faire ceci, puis cela et dafficher le rsultat, le tout dans une langue quil comprend. Bien sr, le clavier dun PC a plus de touches que la tlcommande dun magntoscope. Mais cela ne signie pas que cest plus compliqu. Au contraire, un ordinateur parle un langage qui est presque proche du ntre. Lensemble du monde de la programmation se rsume alors apprendre parler une langue que comprend la machine et avec laquelle vous allez pouvoir vous entendre. Comme nous allons le voir au long de ce livre, cette tche est bien plus aise et amusante quil ny parat. Une fois que vous parlerez un langage que votre ordinateur comprend, vous pourrez alors lui donner une liste dinstructions qui vont constituer un programme autrement appel "logiciel".
Pourquoi programmer ?
Vous vous demandez peut-tre quel est lintrt de savoir programmer puisquun ordinateur est livr avec un lot de logiciels et pourquoi prendre du temps essayer de dvelopper vous-mme des programmes Si vous avez dj t bloqu par les logiciels fournis avec votre PC, si vous navez pas russi, avec votre logiciel photo, mettre des oreilles de chat sur le portrait de votre patron, ou encore si vous souhaitez ajouter
LE GUIDE COMPLET 11
Introduction
dautres niveaux votre jeu prfr, cela justie que vous vous intressiez la programmation. Comme nonc en introduction, programmer, cest donner un ordinateur une suite dinstructions pour arriver un rsultat. Ainsi, la premire raison de sintresser la programmation, cest de pouvoir dire la machine ce quelle doit faire. Peut-tre cherchez-vous simplement un nouveau passe-temps, voire un nouveau mtier ? En apprenant programmer, vous ouvrez les portes dun monde inni de possibilits. En effet, ds lors que vous savez programmer, tout devient possible : quil sagisse de jeux, de faire les comptes, de retoucher des photos, dorganiser la navigation Internet La liste est sans n.
En lisant ces deux lignes on peut avoir une vague ide de ce que fait le programme, mais le ct naturel nest pas encore prsent. Apparaissent
12 LE GUIDE COMPLET
Introduction
alors dans les annes 70 et 80 des langages comme le C, plus proches de lhomme, comme le montrent les lignes suivantes :
If(x>10) Printf("x est suprieur 10") ; Else Printf("x est infrieur 10") ;
Ici, avec quelques notions danglais, le langage apparat presque comprhensible ds lors que lon sait quen langage C, printf permet un affichage lcran. En 1983, la micro-informatique nest en aucun cas comparable avec ce quelle est aujourdhui. IBM lance tout juste son ordinateur personnel, avec un rve : un ordinateur par foyer. la n des annes 80 apparaissent des langages qui permettent un utilisateur de raliser de manire simple des applications compltes et attrayantes. Se dveloppe alors la programmation grand public, hors du contexte totalement universitaire. Dix ans plus tard, sont dvelopps des langages comme Java de Sun et C# de Microsoft. Leur intrt est de permettre au dveloppeur de ne plus avoir connatre la machine. Ils facilitent grandement la programmation, puisque le programmeur peut maintenant se concentrer sur lapprentissage du langage sans avoir forcment de connaissances sur lordinateur auquel le programme est destin. Dans ce livre, nous utiliserons Visual Basic .NET de Microsoft. Ce langage est plus accessible que le C, traditionnellement utilis dans les cursus universitaires.
LE GUIDE COMPLET 13
Introduction
Lditeur
Dans un premier temps, il va falloir donner vos ordres lordinateur. Pour cela, vous utiliserez un diteur de texte. Dans ce livre, nous avons choisi Visual Basic Express 2008, qui regroupe un diteur et tous les outils dont vous aurez besoin. Il est entirement gratuit, et vous pourrez le trouver ladresse http://msdn.microsoft.com/fr-fr/express. Lditeur permet, comme tout traitement de texte, de saisir du texte. Comme nous le verrons plus tard, il ne diffre aucunement dun diteur de texte classique. Une fois le tlchargement du programme dinstallation de Visual Basic Express 2008 termin, vous disposez du chier vbsetup.exe. Doublecliquez dessus pour lancer linstallation du programme.
14 LE GUIDE COMPLET
Introduction
Voici le contrat de licence utilisateur. Il est conseill de le lire attentivement. Cochez la case Jaccepte les termes du contrat de licence, puis cliquez sur Suivant.
Vriez que vous avez suffisamment despace disque disponible, puis cliquez sur Installer.
LE GUIDE COMPLET 15
Introduction
Le programme dinstallation tlcharge les composants ncessaires et les installe sur votre ordinateur. Lopration peut tre longue.
Le compilateur
La programmation consiste en un ensemble dordres passs lordinateur via un diteur de texte. Mais est-ce que la machine comprend directement les instructions qui lui sont passes via cet diteur ? En fait, non. En dbut de chapitre, nous avons dit quun langage de programmation est compris la fois par lhomme et par la machine. Ce nest pas tout fait vrai. En fait, il nest pas compris par la machine, mais par un programme spcique appel "compilateur". Cest le compilateur qui transforme ce que vous saisissez en un langage utilis par la machine. Le fonctionnement dun compilateur est simple. Une fois que vous avez termin dentrer vos instructions dans un chier, qui est appel "source", vous appelez le compilateur (nous expliquerons comment ultrieurement). Celui-ci vrie la syntaxe du chier, le traduit en
16 LE GUIDE COMPLET
Introduction
langage machine et place le rsultat dans un chier de type excutable. On dit alors que le chier source a t compil. Il suffira ensuite de double-cliquer sur ce chier pour que les instructions que vous avez donnes soient excutes, les unes la suite des autres. Visual Basic Express saccompagne dun compilateur qui fonctionne de manire transparente vis--vis de lditeur. Nul besoin de connatre une longue suite de commandes sapparentant de la magie : une touche suffit pour compiler et gnrer un programme de manire le rendre excutable. Maintenant que vous savez ce que sont les compilateurs et les diteurs de texte, et que votre machine est prte, passons un cas pratique
Versions de Visual Studio Express
Les versions 2005 et 2008 sont presque totalement compatibles entre elles. Si vous aviez dj install une version 2005 de Visual Studio Express, vous pouvez trs bien lutiliser en lieu et place de la version 2008. Le code prsent dans cet ouvrage est compatible avec la version 2005 de Visual Studio Express.
LE GUIDE COMPLET 17
Premiers pas
Crer un premier projet ....................................................................................................... crire un programme ........................................................................................................... Compiler, excuter ............................................................................................................... Mieux comprendre ...............................................................................................................
20 21 24 25
Chapitre 1
Premiers pas
Dans le menu Fichier, cliquez sur Nouveau Projet. Vous arrivez alors au menu de choix suivant :
20 LE GUIDE COMPLET
crire un programme
Chapitre 1
Vriez que lentre Application Windows est slectionne, saisissez un nom pour votre projet en lieu et place de WindowsApplication1, par exemple MonPremierProjet, et cliquez sur OK. Vous arrivez la troisime tape du processus de cration de projet. Lcran de Visual Basic ressemble ceci :
qui va regrouper les proprits relatives au projet en cours. Nous dtaillerons son fonctionnement plus tard. Form1.vb, qui est la fentre principale de lapplication.
LE GUIDE COMPLET 21
Chapitre 1
Premiers pas
Reprez le carr gris gauche de lespace de travail. Cette zone sappelle le designer et le carr gris est un formulaire Windows. Une fois que vous aurez ni ce chapitre, il ressemblera une fentre Windows classique. Cliquez sur le formulaire (le carr gris) et observez la fentre des proprits (en bas droite de lespace de travail). Elle se remplit dune liste de proprits qui vont dnir le formulaire.
Reprez celle qui sappelle Text. droite, vous devriez trouver la valeur Form1. En lieu et place de Form1, saisissez MaFentre. Appuyez sur la touche [] : le titre du formulaire dans le designer change ; vous lisez dsormais MaFentre. La fentre des proprits permet, entre autres, de modier le comportement des fentres, par exemple leurs titres, leurs couleurs de fond, etc. Nous y reviendrons au chapitre Dialoguer avec un ordinateur. Lespace de travail est maintenant congur pour le projet en cours et une fentre porte le nom souhait.
22 LE GUIDE COMPLET
crire un programme
Chapitre 1
Cliquez gauche sur le bouton nomm Bote outils. Le menu suivant saffiche alors :
Cette bote outils regroupe tous les lments dont vous avez besoin pour construire une application : des boutons, des zones de saisie de texte, des cadres pour placer des images, etc. Pour dcouvrir les possibilits de cette bote, cliquez sur le menu Tous les Windows Forms. Une liste droulante apparat. Elle donne le choix entre plusieurs outils, appels "contrles". Trouvez celui qui sappelle Button. Effectuez un glisser-dposer vers la fentre dans le designer. Votre fentre ressemble alors ceci :
LE GUIDE COMPLET 23
Chapitre 1
Premiers pas
Faites de mme avec le contrle appel TextBox. Vous avez maintenant une fentre qui ressemble celle-ci :
24 LE GUIDE COMPLET
Mieux comprendre
Chapitre 1
Votre fentre est lance, comme tout autre programme, et dispose de son icne dans la barre des tches de Windows. Vous pouvez cliquer sur le bouton, entrer du texte dans la TextBox, mais rien dautre. Pour aller plus loin, fermez la fentre en cliquant sur la croix. Visual Basic Express 2005 revient automatiquement en mode Dveloppement. Vous allez entrer vos premires instructions, pour donner un comportement la fentre. Double-cliquez sur le bouton de la fentre. Vous vous retrouvez sous un nouvel onglet, face ce texte :
Public Class Form1 Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click End Sub End Class
Entre les lignes Private Sub [] et End Sub, saisissez le texte suivant :
MessageBox.Show("Bonjour " + TextBox1.Text)
Cela fait, gnrez votre programme modi en appuyant sur [F5]. La fentre saffiche nouveau. Cette fois, entrez votre prnom dans la TextBox puis cliquez sur le bouton. Laffichage qui en rsulte est le suivant :
Une bote de dialogue est affiche ; elle contient le message "Bonjour" suivi de votre prnom. Cliquez sur OK et fermez la fentre de votre programme. Analysons maintenant ce que vous avez fait.
Chapitre 1
Premiers pas
Basic. Cest le point de dpart indispensable pour obtenir un espace de travail fonctionnel. Dans cet espace de travail, utiliserez le designer pour placer sur la fentre tout ce dont vous aurez besoin pour le programme. Dans ce premier exemple, vous avez plac une TextBox et un bouton. Une fois que la fentre contient tous les contrles ncessaires, dnissez le comportement de lapplication avec lditeur de code de Visual Basic Express. Cest le moment dentrer toutes les instructions que doit excuter lordinateur. Dans cet exemple, les seules instructions ncessaires sont celles qui sont excutes lors dun clic sur le bouton de la fentre principale. Comme chaque clic une seule instruction est excute, vous avez saisi une seule ligne dans lditeur de code, savoir :
MessageBox.Show("Bonjour " + TextBox1.Text)
Cette ligne permet dafficher ce que vous saisissez dans la TextBox aprs le texte "Bonjour". Mais pourquoi ce moment-l ? Tout simplement parce que vous avez plac ce texte aprs avoir cliqu sur le bouton dans le designer de Visual Basic. Par ce clic, lditeur a compris que vous vouliez modier le comportement de lapplication et, plus prcisment, ce quil se passe lorsque vous cliquez sur le bouton de la fentre. En fait, chaque contrle dispose dvnements, qui reprsentent un clic sur un bouton, un changement de texte dans une TextBox, etc. Lorsque vous dclenchez un vnement dans le designer, comme le clic sur le bouton dans cet exemple, vous tes automatiquement redirig vers la partie du code qui permet de modier le comportement de lapplication quand lvnement est lanc. Dans cet exemple, cela correspond au code :
Private Sub Button1_Click(ByVal sender As System .Object, ByVal e As System.EventArgs) Handles Button1.Click End Sub
Tout ce qui se trouve entre Private Sub et End Sub reprsente le code que le programme doit excuter lors de lvnement en question. tudions maintenant ce quil se passe lorsque vous lancez le programme, cest--dire lorsque vous appuyez sur la touche [F5]. Lors de la gnration du projet, le compilateur se charge de lire, ligne par ligne, ce que vous avez crit. Ensuite, il traduit le tout en langage
26 LE GUIDE COMPLET
Mieux comprendre
Chapitre 1
machine. Le rsultat est un chier excutable qui, par dfaut, est plac dans le rpertoire Mes documents\Visual Studio 2005\Projects\ MonPremierProjet\MonPremierProjet\bin\Debug. Ce chier porte le nom du projet et lextension .exe. Dans ce cas, il sagit du chier MonPremierProjet.exe. Une fois quil est gnr, vous pouvez le copier o bon vous semble et lexcuter dun double clic. Cest de cette manire que vous pourrez le partager avec vos amis, le distribuer sur Internet ou le sauvegarder sur un CD. Quand vous double-cliquez sur ce programme, vos instructions sont excutes. Les premires dentre elles ne sont pas les vtres puisque vous navez prcis de comportement que pour le clic sur le bouton. En fait, le programme commence toujours par les instructions de dessin de la fentre. Elles permettent laffichage dune fentre avec les boutons Fermer, Rduire et Agrandir. Cela fait, le programme dessine lintrieur de la fentre. Dans cet exemple, il place un bouton et une TextBox. Le programme est maintenant charg. Il attend une action de votre part pour ragir, ici un clic sur le bouton. Le programme enregistre le fait que vous cliquez sur le bouton, regarde sa liste dinstructions et voit quen cas de clic, il faut afficher une bote de dialogue contenant le message "Bonjour xxx", o xxx est le texte saisi dans la TextBox. Une fois la bote de dialogue affiche, le programme attend que vous cliquiez sur le bouton OK pour continuer et repasse la premire tape : il attend dautres instructions. Vous pouvez par exemple saisir un autre nom dans la TextBox ou encore quitter le programme en cliquant sur la petite croix en haut droite de la fentre. Dans ce chapitre, vous avez vu les principes fondamentaux de cration de projet, ddition de code et de lancement de programme. Voyons maintenant comment enrichir le contenu des projets par un code plus complet
LE GUIDE COMPLET 27
Dynamiser un programme
Dclarer une variable ........................................................................................................... Utiliser une variable .............................................................................................................. Les boolens ......................................................................................................................... Les nombres .......................................................................................................................... Les jeux de lettres ................................................................................................................ Convertir les types ...............................................................................................................
30 31 31 33 35 39
Chapitre 2
Dynamiser un programme
Le premier programme que vous avez cr dans le chapitre prcdent est complet, mais il ne ralise rien de rellement important ou dutile. Vous allez donc prsent donner ce programme une relle dynamique, grce lutilisation de variables. Quest-ce quune variable ? Il sagit tout simplement dun petit espace que vous rservez lintrieur de la mmoire de votre ordinateur pour y stocker une valeur dun type donn. Bien videmment, il nest pas utile de connatre le fonctionnement interne de votre machine pour utiliser des variables. En fait, la mmoire de la machine fonctionne exactement comme la vtre. Par exemple, pour mmoriser le numro de tlphone de Sylvie, votre cerveau alloue un petit espace dans lequel il stocke 06.12.34.56.78, et lassocie Sylvie en se rappelant quil sagit dun numro de tlphone. Pour stocker une variable dans la mmoire dun ordinateur, il faut raisonner de la mme manire, cest--dire quil faut lui donner un nom unique et indiquer son type (nombre, chane de caractres).
Avec ses deux lignes, vous prcisez lordinateur quil doit stocker une variable de type nombre entier. Vous lui donnez la valeur 100 et vous lappelez num. Examinons le contenu de ce code :
j j j j j
une variable. num : cest le nom de la variable. As : ce mot-cl permet de spcier le type de la variable utilise. Integer : il sagit du type nombre entier. num = 100 : cette opration affecte la variable num la valeur 100.
30 LE GUIDE COMPLET
Les boolens
Chapitre 2
Vous avez prsent dans le programme une variable nomme num qui contient la valeur 100. Cest aussi simple que cela. Voyons maintenant comment lutiliser.
Appuyez maintenant sur [F5]. Le programme se lance, avec une bote de dialogue qui donne la valeur de num, savoir 200. Ces deux lignes permettent dafficher la nouvelle valeur de num, laquelle vous avez ajout 100. Lopration ToString permet de transformer un type nombre en chane de caractres en vue de son affichage. Il existe un grand nombre doprations possible utilisant les variables. Il est maintenant temps de se familiariser avec les diffrents types de variables. Parmi ceux-ci existent les boolens, qui permettent de raisonner sous forme de conditions, les nombres entiers et dcimaux, qui permettent deffectuer des calculs, et les caractres et chanes de caractres, qui permettent de manipuler du texte. Chacun de ces types est incompatible avec les autres et vous ne pourrez donc pas additionner un nombre avec du texte par exemple. Comme vous lavez vu plus haut, il est possible de convertir un type en un autre laide de mthodes dj existantes. Cest le cas de num.ToString, qui transforme le nombre num en chane de caractres. Voici le dtail de chaque type de variable et de ce quil permet.
Chapitre 2
Dynamiser un programme
courant comme tant gal 0. Elle est la base de llectronique et de linformatique. Dans une rexion de programmation, dclarer une variable boolenne permet de ragir selon certains tats. Dans chaque variable boolenne dclare, on peut stocker un tat, par exemple si une porte est ouverte ou non. Un boolen ne peut prendre que deux valeurs : "vrai" ou "faux". Voici pour la mise en pratique :
1 Ouvrez un nouveau projet avec Visual Basic Express et nommez-le ProjetBool. Puis, dans le designer, placez-vous dans lditeur de code en double-cliquant sur la fentre. 2 lendroit du curseur, saisissez le code Dim monBoo As Boolean, ce qui a pour effet de dclarer une variable de type boolenne, de nom monBoo. 3 Retournez la ligne et saisissez monBoo =. Lorsque vous entrez le caractre =, lditeur de texte vous propose dattribuer une valeur au boolen. Pour cet exemple, choisissez True. 4 Ajoutez la ligne MessageBox.Show(monBoo.ToString). 5 Lancez le programme en appuyant sur [F5].
Lutilisation de telles variables permet de raliser des tests dans les applications. Pour votre premire application, il aurait par exemple t
32 LE GUIDE COMPLET
Les nombres
Chapitre 2
pertinent dutiliser un boolen pour vrier que lutilisateur a bien entr son prnom avant dappuyer sur le bouton OK. Vous verrez comment faire cela aux chapitres Contrler un programme et Dialoguer avec un ordinateur.
Cela fait, la variable nomme MaVariable possde la valeur 5. Initialisez maintenant une nouvelle variable de type entier :
Dim MaVariable2 As Integer MaVariable2 = 3
Pour tester les oprations possibles entre ces deux variables, vous allez initialiser une troisime variable de type entier, qui permettra de stocker le rsultat dune opration :
Dim MonResultat As Integer MonResultat = MaVariable + MaVariable2
Ici les deux valeurs sont additionnes. Libre vous de changer le caractre + pour *, qui ralise la multiplication des deux valeurs, ou encore /, qui ralise une division.
LE GUIDE COMPLET 33
Chapitre 2
Dynamiser un programme
Pour tester cet exemple, crez un nouveau projet dans Visual Studio Express, puis double-cliquez sur la fentre dans le designer. Une fois dans lditeur de code, saisissez les instructions prcdentes. Lancez le programme avec [F5].
34 LE GUIDE COMPLET
Chapitre 2
Lorsque vous dclarez des variables, il nest pas utile de prciser le type si vous faites tout de suite linitialisation. Lorsque le programme sera compil, le compilateur va automatiquement reconnatre le type de variable. Par exemple, Dim x = 42 est quivalent Dim x As Integer suivi de x = 42.
Notez que les caractres sont initialiss laide dune valeur entre apostrophes. Cest le cas du f dans cet exemple. Les variables de type caractre peuvent tre utiles dans le cadre de travaux sur les mots, par exemple si vous souhaitez vrier que la premire lettre dun mot est une majuscule. Cela est possible laide doutils proposs dans Visual Basic Express. Tout cela sera dtaill au chapitre Contrler un programme.
Les chanes
Plusieurs caractres mis les uns aprs les autres forment une chane de caractres. Ces chanes sont trs utilises en programmation dans la mesure o il faut souvent demander lutilisateur dun programme de
LE GUIDE COMPLET 35
Chapitre 2
Dynamiser un programme
saisir des donnes. Sil faut traiter ces donnes sous forme de texte, les chanes de caractres entrent en jeu. Pour dclarer une chane de caractres, procdez de la manire suivante :
Dim S As String S = "Bonjour"
Subtilits
Notez que les chanes de caractres sont initialises entre guillemets ("), et les caractres entre apostrophes ().
Dans la mesure o lon travaille souvent sur des chanes de caractres en programmation, un bon nombre de traitements de base ont dj t mis au point. Ainsi, pour concatner deux chanes de caractres, il suffit de faire comme si vous les additionniez :
Dim S1 As String S1 = "Bonjour" Dim S2 As String S2 = " tout le monde" MessageBox.Show(S1+S2)
De nombreuses autres mthodes sont disponibles pour le travail sur des chanes. Par exemple, vous pouvez connatre le nombre de caractres dune chane grce lattribut length. Pour lutiliser, il suffit dajouter .length la n du nom dune variable de type chane :
Dim S As String S = "Bonjour" MessageBox.Show(S.Length.ToString)
36 LE GUIDE COMPLET
Chapitre 2
Pour convertir une chane de caractres en minuscules ou en majuscules, utilisez les fonctions ToLower et ToUpper, en ajoutant .ToUpper la n du nom de votre variable chane de caractres. Le code suivant stocke une chane convertie en minuscules dans une autre variable de type chane de caractres et laffiche :
Dim S As String S = "BONJOUR" Dim S2 As String S2 = S.ToLower MessageBox.Show(S2)
LE GUIDE COMPLET 37
Chapitre 2
Dynamiser un programme
Dans le designer, ajoutez la fentre en cours deux TextBox et un bouton de sorte que votre fentre ressemble ceci :
La premire TextBox est rserve la saisie du message, la seconde accueillira le message une fois crypt. Maintenant que le programme est dessin, il ne reste qu crire le processus de cryptage lorsque lon clique sur le bouton de lapplication. Pour cela, double-cliquez sur le bouton. Dans lditeur de code, lendroit o se trouve le curseur, ajoutez les lignes suivantes :
Dim s As String s = TextBox1.Text s = s.Replace("d", s = s.Replace("e", s = s.Replace("g", s = s.Replace("c", s = s.Replace("q", s = s.Replace("h", s = s.Replace("n", s = s.Replace("t", s = s.Replace("j", s = s.Replace("a", TextBox2.Text = s "3") "7") "1") "8") "2") "g") "d") "5") "6") "4")
38 LE GUIDE COMPLET
Chapitre 2
Ces lignes dinstruction ont pour effet de copier, dans un premier temps, le contenu de la premire TextBox dans une variable temporaire. Ensuite, tout le traitement va tre fait sur cette variable temporaire. Vous utiliserez la mthode Replace, disponible pour toutes les chanes. Elle permet dchanger deux caractres dans une chane. Une premire instruction remplacera toutes les lettres "d" de la phrase par des caractres "3", une seconde tous les "e" par des "7", etc. Toutes ces modications seront effectues au moment o vous cliquerez sur le bouton. Une fois le traitement ni, la phrase crypte apparatra dans la deuxime TextBox, situe sous le bouton. Ainsi, une phrase telle que "Jai lanc la cafetire" apparatra sous la forme : "64i l4d8 l4 84f75i7r7". Bien malin qui pourra retrouver le message dorigine ! Voyons prsent comment dcrypter le message. Rien de plus simple : il suffit de refaire la mme application, mais en inversant lordre des instructions. Rptez les deux premires tapes de ce projet, puis copiez les instructions suivantes aprs avoir double-cliqu sur le bouton. Appelez ce projet ProjDecrypt.
Dim s As String s = TextBox1.Text s = s.Replace("d", s = s.Replace("3", s = s.Replace("g", s = s.Replace("7", s = s.Replace("1", s = s.Replace("8", s = s.Replace("2", s = s.Replace("5", s = s.Replace("6", s = s.Replace("4", TextBox2.Text = s "n") "d") "h") "e") "g") "c") "q") "t") "j") "a")
LE GUIDE COMPLET 39
Chapitre 2
Dynamiser un programme
Si vous essayez de lancer le programme sans ajouter linstruction .ToString dans MessageBox.Show(x), une erreur surviendra et le programme ne se lancera pas.
Conversion de dcimaux
Dans ce cas, x sera gal au nombre 123 456. Il est ncessaire de raliser cette conversion si vous dsirez effectuer des oprations sur une saisie de lutilisateur par exemple. Rappelez-vous que loprateur + ne veut pas dire la mme chose selon que lon manipule des entiers ou des chanes de caractres. Examinons le code suivant :
Dim s As String s = "123" Dim s2 As String s2 = "456" MessageBox.Show(s+s2)
40 LE GUIDE COMPLET
Chapitre 2
Il naffichera pas 579 mais 123 456. Attention donc au type des variables. Pour additionner deux entiers dabord reprsents sous forme de chanes, vous devez les convertir puis les stocker part, comme le montre lexemple suivant :
Dim s As String s = "123" Dim s2 As String s2 = "456" Dim x As Integer x = Int32.Parse(s) Dim Y As Integer Y = Int32.Parse(s2) Dim Addi As Integer Addi = x+y
LE GUIDE COMPLET 41
Chapitre 3
Lorsque vous ne spciez aucune valeur dans lnumration, la valeur entire correspondante commence 0, et va en augmentant. Dans ce cas, Vert vaut donc 0, Jaune vaut 1, et Rouge vaut 2. Cependant, vous pouvez spcier des valeurs pour quelles soient plus pertinentes. Par exemple :
Public Enum VetementBas Pantalon = 1 Jeans = 2 Bermuda = 3 End Enum
44 LE GUIDE COMPLET
Les enregistrements
Chapitre 3
Vous pouvez ensuite affecter une valeur cette variable. Pour donner la variable une valeur de lnumration, il faut indiquer le type et la valeur en question, spars par un point :
haut = VetementHaut.Chemise
Nom
CEYLERE
Prnom
Jacques
ge
24
Dclarer un enregistrement
Pour cela, utilisez le mot-cl Structure et, dans le bloc de dclaration, indiquez les diffrentes composantes de lenregistrement :
Public Structure Personne Public String nom Public String prenom
LE GUIDE COMPLET 45
Chapitre 3
Chaque composante de lenregistrement est appele "champ". Ici, il y en a trois : le nom, le prnom, et lge, de type chane de caractres pour les deux premiers, et entier pour le dernier.
La deuxime ligne instancie la variable, cest--dire quelle cre en mmoire lespace ncessaire son utilisation. En effet, un enregistrement tant un regroupement de champs ventuellement de types diffrents et dont le nombre nest pas directement limit, sa taille nest pas xe. Linstanciation sert donc dterminer lespace exact ncessaire pour que vous puissiez utiliser cette variable compltement. Une fois quelle est instancie, tout lespace est cr, tous les champs sont accessibles par leur nom, prcd du nom de la variable et dun point. Vous pouvez alors les lire, leur affecter des valeurs, comme nimporte quelle variable :
moi.nom = "CEYLERE" moi.prenom = "Jacques" moi.age = 24 MessageBox.Show("Je suis " + moi.nom + " " + moi.prenom) MessageBox.Show("Jai " + moi.age + " ans.")
Un enregistrement est un type structur dont les champs peuvent tre de diffrents types. Cest pourquoi il nest pas ais dinitialiser directement un enregistrement pendant la dclaration. Des mcanismes permettent de le faire lors de linstanciation (nous y reviendrons). Pour linstant, on supposer que, pour initialiser un enregistrement, il faut initialiser chacun de ses champs juste aprs sa cration, ce qui peut savrer fastidieux si lenregistrement est consquent.
46 LE GUIDE COMPLET
Les tableaux
Chapitre 3
deux dimensions, on peut le reprsenter comme ayant des lignes et des colonnes. On lappelle alors "matrice".
trois dimensions, il aurait des lignes, des colonnes, plus une profondeur.
Dclarer un tableau
Pour dclarer un tableau, vous devez dnir un certain nombre de choses. La premire est le type des donnes qui seront lintrieur du tableau. En effet, un tableau dentiers nest pas pareil (en particulier il na pas la mme taille) quun tableau de caractres. De plus, il faut prciser sa taille, cest--dire le nombre dlments quil contiendra, et ce pour chacune des dimensions sil y en a plusieurs. Visual Basic .NET
LE GUIDE COMPLET 47
Chapitre 3
prsente une particularit ce niveau : il sagit de dnir, non pas la taille, mais lindice du dernier lment, sachant que les indices commencent 0.
Dclaration dun tableau simple de 9 chanes de caractres Dim courses(8) As String Dclaration dune matrice de 4 X 3 entiers Dim maMatrice(3, 2) As Integer
Un tableau est un type structure dont tous les lments sont du mme type. Il est possible dinitialiser le tableau la dclaration, et ainsi de se retrouver avec un tableau dont les valeurs sont dj dnies. Il suffit de donner la liste des lments entre accolades, spars par des virgules :
Dim maListe(4) As Integer = { 0, 0, 0, 0, 0 }
Cela est pratique lorsque le tableau nest pas trop grand, mais imaginez ce que cela donnerait avec un tableau de plusieurs centaines dlments, voire plusieurs milliers. Dans ce cas, il faut parcourir le tableau avec une boucle, dont nous dcrirons le fonctionnement ultrieurement. Voici un avant-got qui montre comment parcourir un tableau pour linitialiser. Il faut pour cela utiliser une variable de parcours et donner lindice de dpart (0) et lindice de n, que lon obtient grce la mthode getUpperBound :
Dim tableau(123) As Integer Dim i As Integer For i = 0 to tableau.GetUpperBound(0) tableau(i) = 23 Next
48 LE GUIDE COMPLET
Chapitre 3
Ici, vous dclarez un tableau de cent vingt-quatre lments valant tous 23.
Une vido possde un certain nombre dattributs qui lui sont propres, par exemple son nom, sa longueur, etc. Pour reprsenter une vido, vous pouvez donc utiliser un enregistrement dont les champs correspondent aux diffrents attributs.
Public Structure Video Public String nom Public Affichage type Public Integer longueur End Structure
Vous avez dni les lments fondamentaux de la bibliothque. Comme une bibliothque avec une seule vido a peu dintrt, vous allez crer un tableau de vidos pour quelle puisse en contenir plusieurs. Il suffit dutiliser les mthodes vues prcdemment :
Dim bibliotheque(5) As Video
Voila, vous avez dcrit tous les types dont vous avez besoin pour grer la liste de vidos. Vous pouvez maintenant dcrire chacune dentre elles, puis les mettre dans la bibliothque, que vous consulterez avant de visionner un lm :
Dim temps_modernes As Video temps_modernes = new Video() temps_modernes.nom = "Les temps modernes" temps_modernes.type = Monochrome
LE GUIDE COMPLET 49
Chapitre 3
temps_modernes.longueur = 89 bibliotheque(0) = temps_modernes Dim braveheart As Video braveheart = new Video() braveheart.nom = "Braveheart" braveheart.type = Couleur braveheart.longueur = 165 bibliotheque(1) = braveheart
Vous avez dcrit et ajout deux lms la bibliothque. Selon vos besoins, ajoutez de nouvelles vidos, ventuellement dautres attributs pour les dcrire, etc. Vous connaissez maintenant les diffrents types de variables, simples et structurs, qui vous permettront de dcrire vos donnes et de les utiliser. Vous verrez dans les chapitres suivants comment en faire un usage plus intressant et un peu moins simpliste
50 LE GUIDE COMPLET
Contrler un programme
Imposer des conditions ...................................................................................................... Faire les bons choix ............................................................................................................. Rpter des oprations ...................................................................................................... Bien dcouper un programme ..........................................................................................
52 54 56 61
Chapitre 4
Contrler un programme
Un programme nest pas quune suite directe de lectures et daffectations de variables, mme sil y a beaucoup de cela. De plus, si lon devait faire tout le reste la main, cela limiterait lintrt dun ordinateur et de sa puissance de calcul. Cest pourquoi vous allez voir dans ce chapitre comment structurer un programme et le contrler, cest--dire lui donner un certain comportement selon diffrents critres. Il sera question de conditions, de boucles, de fonctions, de procdures, etc.
Cette expression signie que si condition est vrai, alors InstructionsThen sera excut, et dans le cas contraire, le programme excutera InstructionsElse. condition peut tre de multiples natures, toutes valables partir du moment o le rsultat est une valeur boolenne. Ce peut tre : j une variable boolenne : If (il_pleut) ; j une expression comparative : If (3 + 2 == 5) ; j une fonction boolenne : If (il_fait_beau()). La partie Else de la condition est optionnelle. Si vous souhaitez excuter des instructions dans des conditions particulires, et ne rien faire dans le cas contraire, il vous suffit de retirer la partie Else. Cela donne :
If (condition) Then InstructionsThen End If
Ici,
si condition est vrai, le programme excutera InstructionsThen, mais dans le cas contraire, il continuera son
52 LE GUIDE COMPLET
Chapitre 4
excution normalement. Les parenthses autour de la condition ne sont pas obligatoires, mais il est fortement conseill de prendre lhabitude de les mettre. En effet, si la condition est assez longue, ou compose de plusieurs conditions, elles favorisent la comprhension.
VRAI
Programme IF
Instructions Then
FAUX
Instructions Else
La clause ElseIf existe dans lcriture des instructions conditionnelles pour imposer une condition dans le cas o la premire serait fausse. Exemple :
Dim il_fait_beau As Boolean Dim il_pleut As Boolean If (il_fait_beau) Then MessageBox.Show("Il faut prendre une casquette.") ElseIf (il_pleut) Then MessageBox.Show("Il faut prendre un parapluie.") EndIf
Ces lignes stipulent quil faut prendre une casquette sil fait beau, et sil pleut, que lon doit prendre un parapluie. Le fait dimposer la seconde condition fera quil ny aura rien de spcial en cas de grisaille. Si lon avait utilis un Else sans prciser la condition sur la pluie, le programme aurait dit de prendre un parapluie dans tous les cas, sauf par beau temps. Lorsque quune condition porte sur une variable avec plusieurs possibilits, il est possible dcrire une srie dexpressions conditionnelles correspondant ces diffrentes possibilits. On parle alors d"imbrication" :
Dim age As Integer If (age < 16) Then MessageBox.Show("Vous tes trop jeune pour travailler.") Else If (age > 64) Then MessageBox.Show("Vous ne pouvez plus travailler.") Else MessageBox.Show("Vous avez lge lgal pour travailler") EndIf EndIf
LE GUIDE COMPLET 53
Chapitre 4
Contrler un programme
On pourrait, dans ce cas, utiliser un ElseIf, mais cet exemple sert montrer le principe dimbrication. Attention, un excs dinstructions conditionnelles imbriques peut poser des problmes de comprhension. De plus, en termes de performances, ce nest gnralement pas la meilleure solution. utiliser donc avec prudence !
Cette expression signie que, selon les valeurs de variable, certaines instructions seront excutes. En particulier, si variable vaut Valeur1, le programme excutera Instructions1, si variable vaut Valeur2, Instructions2 sera excut, et si variable vaut une valeur non prise en charge dans lexpression, InstructionsDefault sera excut.
Case 1 Case 2 Programme Switc h Case 3 Case 4
Case 5
54 LE GUIDE COMPLET
Chapitre 4
Nimporte quel type simple peut tre utilis comme variable partir du moment o le type de la variable est cohrent avec les valeurs des diffrents cas. Ceci provoque une erreur :
Dim age As Integer Select Case age Case "mineur" Case "majeur" End Select
La variable est de type entier alors que les valeurs proposes sont des chanes de caractres. La comparaison ne pouvant tre faite, cette expression est fausse et provoque une erreur. Les numrations sont souvent combines avec les Select. En effet, du fait quelles ont un nombre ni de valeurs, gnralement signicatives, elles se prtent bien cette instruction. Exemple :
Public Enum Jour Lundi Mardi Mercredi Jeudi Vendredi Samedi Dimanche End Enum Dim jour As Jour Select Case jour Case Jour.Dimanche MessageBox.Show("Cest le week-end et les magasins sont ferms.") Case Jour.Samedi MessageBox.Show("Cest le week-end mais les magasins sont ouverts.") Default MessageBox.Show("Cest la semaine. Vous devez aller travailler.") End Select
Nous avons vu les principales instructions conditionnelles, qui permettent de faire telle ou telle chose dans telle ou telle situation, ce qui les rend plus intressants.
LE GUIDE COMPLET 55
Chapitre 4
Contrler un programme
Instructions de boucle
Les boucles non dterministes : le nombre ditrations (tours de boucle) est non dni lavance. Ce sont les boucles Tant que Faire. Les boucles dterministes : le nombre ditrations est connu car on spcie un tat de dpart et un tat darrt. Ce sont les boucles Pour Faire.
56 LE GUIDE COMPLET
Chapitre 4
La boucle commence avec le mot-cl While et se termine au niveau du End While. Instructions correspond aux instructions qui seront excutes lorsque lon passera dans cette boucle. Comme dans un If, condition_continuite est un test boolen qui fera que lon passe ou pas dans la boucle. Si sa valeur est vraie, on passera (ou repassera) dedans, et si elle est fausse, on la quittera et le programme continuera son excution normalement. Comme dans le If, condition_ continuite peut tre : j une variable boolenne : If (il_pleut) ; j une expression comparative : If (3 + 2 == 5) ; j une fonction boolenne : If (il_fait_beau()). Voici un exemple de boucle basique, savoir un compteur :
Dim compteur As Integer = 0 While (compteur < 100) compteur = compteur + 1 MessageBox.Show("Compteur = " + compteur) End While
Cet exemple compte de 0 99 et affiche la valeur courante dans une bote de dialogue. Examinons les principaux lments de cette boucle. Remarquez limportance de ltat de dpart. En effet, sil tait inconnu lentre dans la boucle, on ne pourrait tre sr de la bonne excution de cette dernire. Cest pourquoi on a initialis compteur. De cette manire, on est sr que la condition de continuit au dpart sera respecte et que la boucle sera donc excute. Lautre lment important est la modication de la variable de boucle :
compteur. La continuit en dpend directement. Lune des instructions de boucle modie compteur. Elle est indispensable au bon
fonctionnement de la boucle. Cest mme ici linstruction la plus importante. Imaginez ce quil se passerait si compteur nest pas modi :
1 2 3 4
On affiche sa valeur. On revient au dbut de la boucle. compteur vaut toujours 0. On entre de nouveau dans la boucle. On raffiche sa valeur, qui est toujours la mme dailleurs. Et lon revient au dbut. 5 compteur vaut encore 0. On entre une nouvelle fois dans la boucle, et ainsi de suite, sans n.
LE GUIDE COMPLET 57
Chapitre 4
Contrler un programme
On vient de crer une boucle innie qui affiche chaque fois 0 dans une bote de dialogue. Cest pourquoi il est indispensable de bien modier la variable de boucle pour garantir une sortie. Cependant, il ne faut pas la modier nimporte comment non plus, car cela pourrait provoquer une sortie inopine. Si vous utilisez la variable de boucle mauvais escient, vous pouvez provoquer des comportements non voulus du programme. Exemple :
Dim compteur As Integer = 0 While (compteur < 100) compteur = compteur + 1 If (compteur == 14) Then compteur = 25 End If MessageBox.Show("Compteur = " + compteur) End While
En ajoutant une instruction, on provoque un trou entre 14 et 25. Ici, cela est dtectable. Mais des modications peuvent tre moins videntes que celle-ci reprer. La rgle dor est de ne jamais utiliser une variable de boucle pour autre chose que compter le nombre ditrations et de toujours modier sa valeur chaque tour pour viter une boucle innie.
Si, une fois que Instructions est excut, condition_continuite est vrai, il y a un nouveau tour de boucle ; sinon, la boucle est termine et le programme continue son excution normalement. On retrouve exactement les mmes lments que dans la boucle Tant que Faire. Nous ny reviendrons pas. Pour bien comprendre la diffrence, considrez ces deux exemples :
Dim compteur As Integer = 0 While (compteur == 1) compteur = compteur + 1 MessageBox.Show("Compteur = " + compteur) End While Dim compteur As Integer = 0
58 LE GUIDE COMPLET
Chapitre 4
Dans les deux programmes, toutes les composantes sont les mmes : une boucle, avec la mme condition de continuit, les mmes instructions de boucle et les mmes tats initiaux. Dans le premier cas, compteur vaut 0 lorsquon entre dans la boucle. La premire condition ntant pas vrie, le programme ne passe pas dans la boucle. Dans le deuxime cas, compteur vaut galement 0. Le programme passe dans la boucle, change la valeur de compteur, et affiche "Compteur = 1". La condition de continuit est alors vrie. Le programme repasse donc dans la boucle. Le programme augmente compteur et affiche "Compteur = 2". La condition de continuit nest alors plus vrie, et le programme sort de la boucle. Dans le second cas, on effectue deux passages, alors que dans le premier, on nentre mme pas dans la boucle. Cest ce qui fait la diffrence entre les deux, alors que les conditions de continuit et les instructions de boucle sont les mmes. peu de choses prs, ces boucles sont identiques, mais il y a nanmoins quelques subtilits connatre pour viter les petits dsagrments.
Daprs cette construction, on voit que lon ne peut utiliser que des variables de boucle de type numrique. En effet, contrairement aux cas
LE GUIDE COMPLET 59
Chapitre 4
Contrler un programme
prcdents, il ny a pas de condition de continuit boolenne qui permettrait dutiliser nimporte quel type dexpression pour grer les passages dans la boucle. Celle-ci sexcutera jusqu ce que la variable de boucle atteigne sa valeur nale. Il nest pas ncessaire de la modier. Cest linstruction Next qui se charge de laugmenter. De cette manire, on ne risque pas de rencontrer le problme de boucle innie. Cest pourquoi il est recommand dutiliser tant que possible la boucle For, dont le comportement est moins hasardeux, justement cause de sa nature dterministe. Voici lquivalent de lexemple prcdent si lon utilise un For :
Dim compteur As Integer For compteur = 0 to 100 MessageBox.Show("Compteur = " + compteur) Next
Attention, toutes les valeurs entre les bornes (bornes comprises) seront utilises. En dautres termes, le programme fait ici 101 tours de boucle, de 0 100 compris. Dans les autres boucles, tant donn que la condition darrt est (compteur < 100), le programme naffiche pas "Compteur = 100", alors que, cette fois, il laffiche. Par dfaut, la variable de boucle augmente par pas de 1. Cependant, il est possible de laugmenter dun pas plus grand grce au mot-cl Step, qui permet de spcier une valeur de pas :
Dim compteur As Integer For compteur = 0 to 100 Step 2 MessageBox.Show("Compteur = " + compteur) Next
Ici, la variable de boucle augmente par pas de 2, et le programme affiche les nombres pairs entre 0 et 100. On peut aussi faire des boucles dcroissantes :
Dim compteur As Integer For compteur = 100 to 0 Step -1 MessageBox.Show("Compteur = " + compteur) Next
Dans cet exemple, laffichage des valeurs se fait dans lordre dcroissant, de 100 0. La boucle For est certes moins permissive et moins exible cause de labsence de condition de continuit boolenne, mais elle permet dviter des erreurs dutilisation cause dune condition mal crite. Il est recommand de privilgier son utilisation par rapport aux autres boucles.
60 LE GUIDE COMPLET
Chapitre 4
Le nom de la procdure sert lappeler partir dun autre endroit du programme. HelloWorld regroupe trois instructions, qui affichent chacune un mot de la phrase "Bonjour le monde" dans une bote de dialogue. On lappelle dans le programme tout simplement en indiquant son nom et des paramtres, sil y en a :
HelloWorld()
lendroit de votre programme o vous inscrivez ce nom, cest comme si vous rcriviez les instructions regroupes dans la procdure. Vous le pouvez lappeler autant de fois que ncessaire dans le programme.
LE GUIDE COMPLET 61
Chapitre 4
Contrler un programme
crire des procdures permet de gagner en comprhension et en temps, car vous navez pas besoin de rcrire toutes les instructions chaque fois. Ici, en un appel, vous avez rcrit lquivalent de trois instructions, mais les procdures peuvent tre beaucoup plus longues. Une fonction est une srie dinstructions regroupes, comme dans une procdure, mais elle permet de renvoyer une valeur de retour. Cette valeur peut tre utilise par le programme appelant comme si ctait une valeur normale. Voici comment dclarer une fonction :
Public Function HelloWorld() Dim resultat As String = "Bonjour le monde" Return (resultat) End Function
HelloWorld renvoie tout simplement la chane de caractres "Bonjour le monde". Vous ntes pas oblig de prciser le type de la valeur de retour mais vous pouvez le faire en ajoutant As et le type aprs le nom et les paramtres. Il est recommand de le prciser, car le code est plus clair. Cela aide la comprhension et permet de dtecter plus facilement les erreurs.
Public Function HelloWorld() As String Dim resultat As String = "Bonjour le monde" Return (resultat) End Function
Return est le mot-cl qui sert spcier que lon sort de la fonction en retournant la valeur de retour. On peut galement affecter la valeur de retour au nom de la fonction, comme ceci :
Public Function HelloWorld() As String Dim resultat As String = "Bonjour le monde" HelloWorld = resultat End Function
Les deux fonctions sont exactement les mmes et, bien que ce ne soit pas dune importance primordiale, mieux vaut le savoir pour comprendre des programmes crits par dautres. Vous pouvez appeler une fonction comme une procdure. Dans ce cas, la valeur de retour na pas deffet, mais les instructions de la fonction sont quand mme excutes :
HelloWorld()
62 LE GUIDE COMPLET
Chapitre 4
La fonction se contente de renvoyer une chane de caractres. Mais vous pouvez utiliser cette valeur de retour dans nimporte quelle partie du programme qui attend une valeur du mme type. Exemple :
MessageBox.Show(HelloWorld())
Par cet appel, le programme affiche une bote de dialogue contenant le message "Bonjour le monde", car Show attend une chane de caractres, et justement, HelloWorld en renvoie une.
Les paramtres
Lorsque lon dclare ou que lon appelle des fonctions ou des procdures, leur nom est toujours suivi de parenthses vides ou qui contiennent des paramtres. Les paramtres sont des variables, dont on rcupre la valeur lors de lappel de la fonction ou de la procdure. Il peut y en avoir un, plusieurs, ou aucun. Ils permettent de donner de la exibilit une fonction ou une procdure. En effet, tant donn que leur valeur exacte nest donne que lors de lappel, celle-ci peut varier et apporter du changement. la dclaration, il faut spcier leur type et leur nom. Voici un exemple de procdure avec des paramtres :
Public Sub QuiSuisJe(ByVal nom As String, ByVal prenom As String) MessageBox.Show("Je suis " + nom + " " + prenom) End Sub
Par contre, lorsque lon appelle des fonctions ou des procdures qui ont des paramtres, il faut mettre entre parenthses les valeurs de ces paramtres. On peut le faire soit par le biais de variable, ou dexpression constante, voire de fonction. En effet, une fonction peut tre un paramtre dune autre fonction, car elle retourne une valeur ; mais il faut que les types correspondent.
Dim mon_nom As String = "Martin" Dim mon_prenom As String = "Pierre" QuiSuisJe(mon_nom, mon_prenom) MessageBox.Show(Moi("Martin", "Pierre"))
LE GUIDE COMPLET 63
Chapitre 4
Contrler un programme
Le mot-cl ByVal qui gure dans la dclaration des paramtres indique quils sont transmis par valeur. Cela signie qu chaque fois quun paramtre est fourni, une copie des donnes est faite avant quelles soient transmises la fonction ou la procdure. Cela garantit quun changement sur la valeur transmise ne sera pas rpercut sur la variable originale. Il sagit du comportement par dfaut, ce qui rend ByVal optionnel. Modions un peu la procdure QuiSuisJe :
Public Sub QuiSuisJe(ByVal nom As String, ByVal prenom As String) MessageBox.Show("Je suis " + nom + " " + prenom) nom = "DOE" prenom = "John" End Sub
Aprs avoir affich le nom et le prnom, on les modie. On reprend le programme prcdent, avec une lgre modication :
Dim mon_nom As String = "Martin" Dim mon_prenom As String = "Pierre" QuiSuisJe(mon_nom, mon_prenom) MessageBox.Show(Moi(mon_nom, mon_prenom))
Au lieu dcrire des valeurs constantes dans la dernire instruction, on indique mon_nom et mon_prenom. Le programme affiche deux fois une bote de dialogue dans laquelle gure le texte "Je suis Martin Pierre", bien que les paramtres aient t modis dans la deuxime procdure QuiSuisJe. Cela est d au fait que ces paramtres ont t passs par valeur. La procdure a donc travaill sur une copie des variables mon_nom et mon_prenom et leurs valeurs originales nont donc pas t modies. Le passage de paramtres par valeur soppose au passage de paramtres par rfrence. Dans ce cas, la procdure ou la fonction ne travaille plus avec une copie de la variable passe en paramtre, mais directement avec celle-ci, plus prcisment avec son adresse mmoire. En dautres termes, si une modication est faite pendant la procdure ou la fonction, elle est conserve hors de celle-ci. manipuler avec une prudence donc ! Pour spcier un passage par rfrence, on utilise ByRef au lieu de ByVal. Appliquons cela la fonction QuiSuisJe :
Public Sub QuiSuisJe(ByRef nom As String, ByRef prenom As String) MessageBox.Show("Je suis " + nom + " " + prenom) nom = "DOE" prenom = "John" End Sub
64 LE GUIDE COMPLET
Chapitre 4
Si maintenant nous excutons le mme bout de programme que prcdemment, on obtient une premire bote de dialogue dans laquelle gure le texte "Je suis Martin Pierre", puis une deuxime contenant "Je suis DOE John". Le fait davoir pass les paramtres par rfrence et de les avoir modis dans la procdure provoque leur modication relle dans le reste du programme. Encore une fois, manipulez le passage de paramtres par rfrence avec prcaution.
Ici, resultat est une variable locale de la fonction addition. Elle ne peut tre utilise ailleurs dans le programme.
Dim somme As Integer somme = Addition(3, 5) MessageBox.Show("Somme = " + somme) MessageBox.Show("Resultat = " + resultat)
La troisime ligne affiche une bote de dialogue contenant "Somme = 8". On peut penser que resultat existe car cette variable est cre dans la fonction addition. Or, resultat est une variable locale de la fonction Addition. Elle nexiste donc pas pour le reste du programme. De ce fait, lutiliser hors de Addition provoque une erreur et il est impossible dexcuter la seconde instruction Show. Cela nous permet dintroduire la notion de porte. La porte correspond laccessibilit dune variable. La porte dune variable locale dune fonction ou dune procdure est simplement cette fonction ou cette procdure. Au-del, la variable nest pas utilisable. Il en est de mme
LE GUIDE COMPLET 65
Chapitre 4
Contrler un programme
pour les boucles. Une variable dclare dans une boucle nest utilisable que dans cette boucle :
Dim compteur As Integer For compteur = 1 to 100 Dim sauvegarde As Integer Sauvegarde = compteur Next MessageBox.Show("Sauvegarde = " + sauvegarde)
La variable sauvegarde tant dclare et utilise dans la boucle For, sa porte se limite cette boucle. Cest pourquoi linstruction Show de ce bout de programme provoque une erreur. sauvegarde tant utilise hors de sa porte, elle nest pas accessible. Cest comme si elle nexistait pas, on ne peut pas sen servir. En raison de la porte des variables, faites bien attention lendroit o vous les dclarez pour tre sr quelles existent au moment o vous vous en servez. Bien que ce principe puisse paratre subtil au premier abord, vous arriverez vite le matriser.
66 LE GUIDE COMPLET
Chapitre 5
Les boutons ou les TextBox, que vous avez utiliss dans les programmes prcdents, sont des contrles qui permettent une interaction avec lutilisateur. Dans ce chapitre, vous allez apprendre maximiser cette interaction, rendre vos programmes plus vivants, ajouter du contenu multimdia et naviguer sur le Web. Les possibilits sont sans n. Le principe est simple. Lorsque vous lancez Visual Basic, vous arrivez dans le designer de fentres. Ces fentres sont appeles "formulaires", car elles sont utilises pour capturer des informations de lutilisateur et lui donner des rponses en consquence. Dans les chapitres prcdents, vous avez par exemple double-cliqu sur un bouton pour vous placer dans ldition de code de lvnement correspondant au clic du bouton. La programmation dapplications pour Windows est fonde sur ce simple concept : un vnement, une rponse. Lutilisateur du programme clique sur un bouton ? Les instructions que vous avez prvues pour cet vnement sont excutes. Comme vous allez le voir, chaque contrle possde ses propres vnements.
68 LE GUIDE COMPLET
Chapitre 5
3 Dans la liste qui saffiche, descendez jusqu llment Text. 4 droite de Text, entrez le texte que vous voulez, par exemple MonBouton. 5 Validez avec []. Le changement est immdiat.
Vous savez maintenant manipuler les proprits dun contrle. Le principe est analogue quel que soit le type du contrle puisque tous disposent de la mme fentre de proprits. Attention toutefois, certaines proprits sont disponibles pour plusieurs contrles diffrents, mais ne modient pas la mme chose. Par exemple, la proprit Text que vous venez de manipuler change le texte dun bouton, mais si vous modiez cette mme proprit pour un formulaire, cest son titre qui est chang.
Les vnements
Chaque contrle possde son lot dvnements modiables de manire donner au programme le comportement souhait. Pour modier un vnement dun contrle, vous avez deux solutions. Vous avez dj vu la premire, qui consiste double-cliquer sur le contrle, ce qui place lditeur de texte dans un vnement par dfaut. Cest le cas du clic sur un bouton ou du changement de texte dune TextBox. En revanche, pour modier le comportement dun programme lorsque le pointeur de la souris quitte la zone dun bouton, il suffit daller dans la liste des vnements en cliquant sur licne en forme dclair de la fentre des proprits et de parcourir la liste. Affichons par exemple un message chaque fois que lutilisateur entre dans la zone dun bouton.
LE GUIDE COMPLET 69
Chapitre 5
1 Lancez Visual Basic Express et crez un nouveau projet. 2 Dans le designer de formulaires, ajoutez un bouton par glisserdposer. 3 Slectionnez le bouton en cliquant dessus puis appuyez sur [F4]. 4 Dans la fentre des proprits, modiez la proprit Text par Ne cliquez pas ici !. 5 Cliquez sur licne vnements de la fentre des proprits (le petit clair), puis cherchez lvnement MouseEnter. 6 Double-cliquez sur la case vide dans la colonne de droite qui correspond lvnement. 7 Une fois dans lditeur de code, ajoutez linstruction MessageBox.Show("NE PAS CLIQUER !"). 8 Lancez le programme avec [F5], puis passez la souris au-dessus du bouton, sans cliquer. Le rsultat est immdiat.
Le contrle Label
Dans la bote outils, faites glisser sur le formulaire le contrle nomm Label ("tiquette" en anglais). Il est couramment utilis pour spcier quoi correspond une zone de texte.
70 LE GUIDE COMPLET
Chapitre 5
Dans ce cas, nous utilisons un Label pour guider lutilisateur : en regardant la fentre, il sait tout de suite quil faut entrer un nom dans la TextBox. Pour modier le texte dun Label, il suffit de le slectionner en cliquant dessus puis, aprs avoir appuy sur [F4] pour afficher les proprits, de modier la proprit Text. Les proprits principales dun Label sont Text, qui reprsente le contenu du Label, et (Name), qui reprsente le nom du contrle pour le programme. Vous pouvez accder aux proprits dun contrle via la fentre des proprits, mais galement dans le code, ce qui permet de modier un contrle pendant que le programme sexcute. Voici un exemple :
1 Ouvrez un projet Visual Basic Express et ajoutez un bouton et un Label votre formulaire dans le designer. 2 Dans les proprits du Label, modiez le texte par Vous navez pas cliqu sur le bouton. 3 Modiez la proprit (Name) de ce Label par Label_Click. 4 Double-cliquez sur le bouton pour diter lvnement "clic". 5 Une fois dans lditeur de code, ajoutez linstruction
Label_Click.Text bouton". = "Vous avez cliqu sur le
LE GUIDE COMPLET 71
Chapitre 5
Le contrle Button
Ce contrle est lun des plus utiliss. Ds lors que lon veut un retour de lutilisateur, cela passe souvent par un clic sur un bouton. Lvnement le plus courant et le plus modi pour ce contrle est videmment le clic, mais vous pouvez changer le comportement associ au passage du curseur ou, linverse, lorsque lutilisateur quitte la zone du bouton sans cliquer dessus. Les proprits les plus utiles pour un bouton sont Text, qui reprsente le texte inscrit sur le bouton, et (Name), qui reprsente le nom du bouton pour le programme. Vous pouvez accder ces proprits (comme celles dun Label) directement depuis le code. Dans lexemple suivant, nous allons raliser un compteur de clics laide dun Button et dun Label.
72 LE GUIDE COMPLET
Chapitre 5
1 Ouvrez un nouveau projet Visual Basic Express, puis ajoutez un bouton et un Label au formulaire. 2 Double-cliquez sur le bouton pour diter le code de lvnement "clic". 3 Ajoutez les instructions suivantes :
Dim i As Integer i = Int32.Parse(Label1.Text) i = i + 1 Label1.Text = i.ToString
4 Lancez le programme avec [F5] puis cliquez sur le bouton. Le texte du Label est modi en fonction du nombre de clics effectus.
Le contrle ListBox
Ce contrle permet de proposer une liste lutilisateur. Pour lutiliser, faites-le glisser sur le formulaire. Avec une ListBox, vous allez raliser un rpertoire tlphonique. Une fois le contrle ListBox ajout au formulaire, slectionnez-le en cliquant dessus, puis appuyez sur [F4] pour visualiser les proprits. En face de la proprit Items, linscription Collection apparat. Une collection est un ensemble de valeurs. Vous allez diter cette collection avec loutil appropri. Pour cela, cliquez sur licne dcore de trois points de suspension, droite de la mention Collection.
LE GUIDE COMPLET 73
Chapitre 5
Dans la fentre qui apparat, entrez un nom et un numro de tlphone, spars par un espace, en effectuant un retour la ligne entre chaque saisie.
Cliquez ensuite sur le bouton OK de lditeur, puis lancez le programme avec [F5]. La fentre saffiche et la ListBox prsente les noms et numros saisis.
Maintenant, il serait interessant dajouter des lments la ListBox. Pour cela, introduisez un bouton et une TextBox dans le formulaire principal. Double-cliquez sur le bouton, puis ajoutez le code suivant dans lditeur :
ListBox1.Items.Add(TextBox1.Text)
74 LE GUIDE COMPLET
Chapitre 5
Cette instruction ajoute la collection dobjets de la ListBox le texte qui est saisi dans la TextBox. Imaginons maintenant que vous vouliez effacer lune des entres de la ListBox. Cette opration est des plus simples. Fermez lapplication puis revenez au designer. Ajoutez votre formulaire un deuxime bouton, qui servira effacer une entre. Dans les proprits du bouton, modiez le texte pour quil affiche "Suppression". Double-cliquez ensuite sur ce deuxime bouton pour entrer dans lditeur de code lendroit du code excut lors dun clic sur ce bouton. Entrez alors linstruction suivante :
ListBox1.Items.Remove(ListBox1.SelectedItem)
Cette ligne spcie au programme quil faut retirer de la collection dobjets de la ListBox lobjet qui est slectionn au moment du clic (ListBox1.SelectedItem). Lancez ensuite le programme avec [F5] et testez la suppression via le nouveau bouton. Vous savez maintenant comment ajouter et supprimer des objets dans une ListBox.
Renommer les contrles
Vous pouvez simplier ldition dun programme en renommant les contrles laide de leur proprit name. En renommant par exemple Label1 en MaLabel, vous pourrez modier sa proprit Text dans le code en saisissant MaLabel.text.
LE GUIDE COMPLET 75
Chapitre 5
Dans cet diteur, slectionnez Ressource locale puis cliquez sur le bouton Importer. Parcourez ensuite votre disque dur a la recherche dune image qui vous plat, puis double-cliquez dessus. Limage saffiche dans la PictureBox. Mais si cette image est plus grande que la bote insre dans le formulaire, elle ne sera pas entirement affiche. Pour remdier cela, dans la fentre des proprits, descendez dans la liste jusqu trouver la proprit SizeMode, puis changez-la pour la valeur StretchImage, qui permet dajuster automatiquement la taille de limage la taille de la PictureBox. Lancez maintenant le programme avec la touche [F5]. La fentre principale se lance et contient limage que vous avez slectionne. Cependant, si vous devez diter le code du programme chaque fois que vous voulez changer limage affiche, cest contraignant. Ne serait-il pas pratique davoir un bouton un peu spcial, qui permette de slectionner un chier et de le traiter en consquence ? Le contrle OpenFileDialog est justement fait pour cela. Il est un peu particulier en ce sens quil permet un utilisateur de choisir un chier en parcourant le disque dur et de traiter le chier en question. Faites glisser un contrle OpenFileDialog de la bote outils vers le formulaire. Vous pouvez constater quil ne sajoute pas au formulaire, comme les autres contrles, mais quil va se nicher en dessous.
76 LE GUIDE COMPLET
Chapitre 5
En fait, ce contrle ne se manipule pas directement, mais au travers dautres contrles, comme un bouton par exemple. Pour illustrer le fonctionnement, ajoutez un bouton votre application puis doublecliquez dessus pour afficher le code de lvnement "clic". Ajoutez la ligne dinstruction OpenFileDialog1.ShowDialog(). Ensuite, lancez votre programme en appuyant sur la touche [F5]. Une fois le programme lanc, cliquez sur le bouton. Une bote de dialogue qui vous propose de choisir un chier saffiche.
LE GUIDE COMPLET 77
Chapitre 5
Toutefois, lorsque vous slectionnez un chier laide de cette bote de dialogue, il ne se passe rien. Pour remdier cela, ajoutez le code suivant lvnement "clic" :
PictureBox1.Image = Image.FromFile(OpenFileDialog1 .FileName)
Cette ligne demande simplement la PictureBox de changer limage en en construisant une partir dun chier slectionn via la bote de dialogue gnre par le contrle OpenFileDialog. Lancez le programme pour vrier que tout fonctionne et admirez le fruit de votre programmation. Vous disposez maintenant dune visionneuse dimage, par exemple pour regarder les clichs issus dun appareil photo numrique branch votre ordinateur. Mais ne serait-il pas intressant de choisir les chiers dans le rpertoire Mes Images au lieu de chercher dans le rpertoire partir duquel vous lancez lapplication ? Ce serait un plus indniable. Pour cela, il existe la proprit InitialDirectory du contrle OpenFileDialog. Elle ne peut pas tre directement modie dans la fentre des proprits. Vous devez intervenir sur le code. Pour cela, double-cliquez sur le formulaire pour diter le code lanc lors du chargement de la fentre. Une fois dans lditeur de code, saisissez cette instruction :
OpenFileDialog1.InitialDirectory = Environment .SpecialFolder.MyPictures
Elle permet dditer le rpertoire par dfaut dans lequel chercher les images et de spcier que ce rpertoire sera Mes Images, cr par Windows pour chaque utilisateur de lordinateur. Il existe galement le mme genre de raccourci pour le rpertoire Mes Documents, Ma Musique, le Bureau, etc.
78 LE GUIDE COMPLET
Chapitre 5
Vous tes maintenant capable de slectionner un chier laide dune bote de dialogue.
Le contrle WebBrowser
Le contrle WebBrowser permet de dvelopper en un temps record des applications sappuyant sur la puissance du Web. Grce lui, vous pouvez disposer dun navigateur Internet lintrieur de votre application. Vous allez vous en servir pour dvelopper rapidement un navigateur Internet personnalis. Ouvrez un nouveau projet avec Visual Basic Express. Une fois dans le designer, ajoutez une TextBox dont vous changerez la proprit (name) en address, puis un contrle WebBrowser que vous placerez sur le formulaire.
Redimensionner un formulaire
Nhsitez pas redimensionner le formulaire laide de la souris en plaant le curseur sur lun des coins et en bougeant la souris tout en maintenant le bouton gauche enfonc.
LE GUIDE COMPLET 79
Chapitre 5
Ajoutez un bouton droite de la TextBox puis changez la proprit Text du bouton par Go. Modiez le code de lvnement "clic" en doublecliquant sur ce dernier et ajoutez linstruction suivante :
WebBrowser1.Navigate(address.Text)
Lancez votre programme en appuyant sur [F5]. Saisissez une adresse dans la TextBox puis cliquez sur le bouton GO. Vous avez maintenant votre propre navigateur.
Vous avez, en 5 minutes, ralis une application fonctionnelle, dune qualit quasiment gale celle dune application professionnelle. Est-il encore possible de dire que la programmation est rserve une lite dinformaticiens ?
80 LE GUIDE COMPLET
Chapitre 5
Commencez par crer un nouveau projet avec Visual Basic Express. Puis, dans lditeur de formulaire, ajoutez deux boutons, un contrle TextBox et les contrles FontDialog et ColorDialog. Comme le contrle OpenFileDialog que vous avez manipul prcdemment, ces deux derniers contrles ne viennent pas sajouter au formulaire, mais juste en dessous. Il faudra donc utiliser les deux boutons pour faire le lien entre les contrles et leur utilisation. Renommez le texte dun des boutons en Police et le texte du second bouton en Couleur. Double-cliquez sur le bouton Police et ajoutez les instructions suivantes au code de lvnement "clic" :
FontDialog1.ShowDialog() TextBox1.Font = FontDialog1.Font
Revenez lditeur de formulaire. Double-cliquez sur le bouton Couleur pour diter lvnement "clic". Ajoutez les instructions suivantes :
ColorDialog1.ShowDialog() TextBox1.ForeColor = ColorDialog1.Color
Lancez le programme avec la touche [F5], saisissez du texte dans la TextBox, puis utilisez les deux boutons pour modier la couleur et la police du texte. Les instructions se limitent ici appliquer une police au texte slectionne via la bote de dialogue Font. Quand vous cliquez sur OK, la police choisie remplace celle de la TextBox. Quand vous cliquez sur lautre bouton, il se passe exactement la mme chose, mais la couleur slectionne dans la bote de dialogue Couleurs sapplique au premier plan de la TextBox, savoir au texte.
Soyez professionnel !
Pour donner un look plus professionnel cet diteur de texte, slectionnez la TextBox dun simple clic, puis cliquez sur son petit triangle en haut droite. Cochez la case Multiline. Il est maintenant possible de modier la hauteur en nombre de lignes de cette TextBox.
Vous pouvez appliquer un changement de couleur tous les lments de votre formulaire. Par exemple, vous pouvez accorder la couleur de fond de lapplication avec la couleur de texte que vous venez de slectionner en ajoutant la ligne suivante lvnement appropri :
Me.BackColor = ColorDialog1.Color
LE GUIDE COMPLET 81
Chapitre 5
appliquez ici la couleur larrire-plan de la fentre. Ainsi, le texte que vous allez saisir sera de la mme couleur. La mthode de changement de couleur fonctionne avec nimporte quel contrle disposant dune proprit Color. Pour vrier que le contrle en possde une, il suffit de regarder dans la liste de la fentre des proprits. La deuxime mthode consiste saisir le nom du contrle dans lditeur de code, suivi dun point, puis dappuyer sur les touches [Ctrl]+[Barre}d'espace] pour lister toutes les proprits et mthodes des contrles.
Le contrle TreeView
Si vous vous tes dj servi de lExplorateur de chiers Windows, vous avez d remarquer que les rpertoires se prsentent sous la forme dune arborescence. Il est possible dajouter ce style darborescence dans vos programmes laide du contrle TreeView. Il permet dorganiser des donnes sous forme de nuds hirarchiques. Le nud de premier niveau sappelle "nud racine" et les nuds de niveaux infrieurs sont les ls du nud racine, chaque nud ls pouvant lui-mme servir de nud racine. Un exemple sera certainement plus parlant.
puis affichez la fentre des proprits en appuyant sur [F4]. Lune des proprits sappelle Nodes. Comme la collection Items du contrle ListBox, il sagit dune collection de valeurs, qui vont reprsenter cette
82 LE GUIDE COMPLET
Chapitre 5
fois des nuds de larborescence. Comme pour la ListBox, vous pouvez diter la collection de nuds graphiquement, en cliquant sur les trois points de suspension droite de Nodes, dans la fentre des proprits. Cliquez sur le bouton Ajouter une racine pour ajouter un premier nud au TreeView. Une fois ce nud ajout, vous pouvez lui adjoindre soit des enfants, soit une autre racine. Mais encore une fois, vous pouvez modier un TreeView avec le code de lapplication. Lobjectif ici est de crer une bibliothque de lms. En ce sens, ajoutez votre application trois TextBox et deux boutons.
Nommez le premier bouton Ajout Catgorie et le second Ajout Film. Il faut maintenant modier les vnements "clic" pour que les boutons ajoutent chacun une catgorie un niveau de hirarchie diffrent. Double-cliquez sur le bouton Ajout Catgorie de manire vous placer dans lditeur de code, puis recopiez linstruction suivante :
TreeView1.Nodes.Add(TextBox1.Text)
Cette instruction ajoute un nud au niveau hirarchique le plus haut du TreeView. Double-cliquez sur le bouton Ajout Film et, une fois dans lditeur de code, saisissez linstruction suivante :
TreeView1.SelectedNode.Nodes.Add(textbox2.Text)
LE GUIDE COMPLET 83
Chapitre 5
Cette ligne ajoute un nud en considrant le nud slectionn comme racine dun arbre. Lancez maintenant lapplication en appuyant sur [F5]. Entrez une catgorie dans la premire TextBox puis cliquez sur le bouton Ajout Catgorie. Slectionnez ensuite le nud que vous venez dajouter, puis saisissez un titre de lm dans la deuxime TextBox. Cliquez ensuite sur le deuxime bouton et le nom du lm viendra sajouter la hirarchie.
Le contrle ComboBox
Ce contrle permet dviter bon nombre de saisies rptes en proposant une liste droulante de choix possibles. Vous allez tester son utilit en remplaant le bouton Ajout Catgorie de la bibliothque de lms par une ComboBox. Crez un nouveau projet et ajoutez au formulaire les contrles suivants : un TreeView, deux Label, une TextBox, une ComboBox et un bouton. Nommez le premier Label Catgories et placez-le au-dessus de la ComboBox. Nommez le deuxime Label Film et placez-le au-dessus de la TextBox. Placez le bouton juste en dessous.
84 LE GUIDE COMPLET
Chapitre 5
Slectionnez maintenant la ComboBox et affichez ses proprits en appuyant sur [F4]. Dans la liste, vous retrouvez une proprit Items ditable, comme pour la ListBox. Le fonctionnement de ces deux contrles est par bien des points similaire. Pour diter le contenu de la ComboBox, cliquez sur les trois points de suspension droite de la proprit Items. Une fentre saffiche alors.
Ajoutez des catgories de lms, une par ligne, et appuyez sur OK. Votre liste de genres est garde dans la collection Items de la ComboBox. Vous allez maintenant modier le code de lvnement "clic" du bouton pour ajouter un lm la liste.
LE GUIDE COMPLET 85
Chapitre 5
Cette portion de code dclare une variable de type TreeNode (nud dun arbre) et fait en sorte que le texte affich sur le TreeView soit celui de la catgorie choisie dans la ComboBox. Ensuite est ajout, en tant que nud enfant du nud n, un nud qui porte le nom du lm que lon va saisir dans la TextBox.
86 LE GUIDE COMPLET
Les formulaires
Chapitre 5
formulaires au projet. Pour ajouter un formulaire, cliquez du bouton droit dans lExplorateur de solutions situ au-dessus de la fentre des proprits, puis cliquez sur Ajouter/Nouvel lment. Dans la liste de choix qui est alors propose, choisissez Formulaire Windows (Windows Form). Un nouvel onglet, nomm Form2.vb, est alors ajout au projet. Les manipulations possibles sur ce nouveau formulaire sont exactement les mmes que sur le formulaire qui est ajout par dfaut la cration dun nouveau projet. Pour illustrer ce principe, reprenez la bibliothque de lms dveloppe prcdemment et amliorez la saisie de lms en utilisant un deuxime formulaire. Crez un nouveau projet puis, comme pour le projet prcdent, ajoutez un contrle de type TreeView, une TextBox et deux boutons. Ajoutez une TextBox avec un bouton Ajout Catgorie. Ajoutez un deuxime bouton que vous nommerez Ajout Film. Ajoutez maintenant un nouveau formulaire au projet grce la mthode dcrite prcdemment. Dans le designer, slectionnez longlet du nouveau formulaire et ajoutez-y deux boutons et une TextBox. gauche de la TextBox, ajoutez un Label Film. Slectionnez le premier bouton, puis affichez les proprits en appuyant sur [F4]. Dans la proprit Text, inscrivez OK. Changez le texte du deuxime bouton par Annuler. Il faut maintenant faire en sorte que, lorsque lutilisateur clique sur le bouton OK, les informations du lm sajoutent larborescence. Modiez le code de lvnement "clic" du bouton Ajout Catgorie sur le formulaire 1. Recopiez le code suivant :
TreeView1.Nodes.Add(TextBox1.Text)
Cela permet de crer un nud de catgorie. Modiez ensuite le code de lvnement "clic" du bouton Ajout Film. Insrez les instructions suivantes :
Dim Form_ajout As Form2 Form_ajout = New Form2 Form_ajout.ShowDialog()
Il sagit ici de dclarer une variable qui soit de type Form2, Form2 tant le formulaire que vous avez ajout votre projet. De cette manire, un
LE GUIDE COMPLET 87
Chapitre 5
clic sur le bouton Ajout Film ouvre une nouvelle fentre avec le contenu du formulaire 2. Il faut maintenant modier les vnements "clic" du deuxime formulaire pour ajouter un lm dans la catgorie slectionne. Pour le bouton OK, saisissez le code suivant :
Form1.TreeView1.SelectedNode.Nodes.Add(TextBox1.Text) Me.Dispose()
De cette manire, un clic sur le bouton OK ajoute le lm la catgorie slectionne, et un clic sur le bouton Annuler ferme le formulaire. La mthode Dispose ferme le formulaire et efface toute trace de ce dernier dans la mmoire de lordinateur. Aprs lexcution de la mthode Dispose, il est impossible daccder au contenu du formulaire.
88 LE GUIDE COMPLET
Penser lutilisateur
Les menus .............................................................................................................................. 91 Crer un lien homme-machine ....................................................................................... 105 Attention aux pirates ! ....................................................................................................... 115
Chapitre 6
Penser lutilisateur
Lorsque vous utilisez un programme, il est toujours plus agrable de se trouver face une interface claire, o chaque bouton semble tre lendroit o vous vous attendez le trouver, o tous les menus portent des noms clairs et prcis et qui vous apportent directement linformation que vous cherchez. Maintenant que vous connaissez toutes les bases de la programmation, vous tes capable de raliser peu prs nimporte quel logiciel, aussi compliqu soit-il. Cest comme en cuisine : mme la plus complique des pices montes demande les mmes ingrdients que le gteau au yaourt. La suite de ce livre va vous apprendre faire la diffrence entre un bon et un mauvais programme. la question "Quest-ce quun bon programme ?", nimporte quelle personne serait tente de rpondre "Un programme qui marche" et cest une erreur. Fonctionner est la premire chose demander un programme, la deuxime est de fournir un rsultat en un temps minime. Le but de ce chapitre est de vous apprendre vous placer du ct dveloppeur et du ct utilisateur nal. Dans le monde de lentreprise, celui qui dveloppe des logiciels de gestion pour diffrents clients et qui en fait le minimum pour les satisfaire au plus vite et dvelopper davantage de projets fait une grande erreur. Que se passe-t-il lorsque le client nest pas satisfait ?. Le dveloppeur passe deux fois plus de temps reprendre le projet et le modier quil ne laurait fait sil stait plac du ct utilisateur directement. Pour bien faire, il faut rchir trois points :
j j j
Le menu est la partie de lapplication qui sert raliser les actions les plus courantes. Il sagit en gnral dune barre situe juste sous la barre de titre de la fentre. Cette barre de menus doit tre classique et le plus claire possible. Personne na envie de se perdre dans une hirarchie de menus et de sous-menus pour trouver imprimer une carte de vux. Pour cela, Visual Basic met votre disposition des outils rellement pratiques. Linterface, cest le formulaire Windows. Cest ce que voit lutilisateur lorsquil lance le programme. Il est donc de bon ton de la soigner. En effet, si le premier contact est russi, 75 % du travail est fait, le
90 LE GUIDE COMPLET
Les menus
Chapitre 6
programme va plaire. Il faut pour cela rchir lorganisation dune part, qui doit rester logique et fonctionnelle, et au graphisme dautre part, qui doit rendre lapplication agrable regarder. Pour arriver un rsultat beau et fonctionnel, vous allez apprendre rendre un formulaire transparent, lorganiser, et mettre en application un tas de petites astuces pour donner une application un look professionnel. Les retours des utilisateurs, cest--dire ce quils entrent dans le programme sous forme de valeurs, doivent faire lobjet dune attention particulire de votre part. Imaginez quun utilisateur du programme dannuaire veuille fournir lge dune personne. Si au lieu dentrer 32 dans la TextBox destine recueillir lge, il saisit trente deux ans ? Le programme va alors se fermer et lutilisateur ne saura pas ce quil a fait de mal. Le deuxime problme relve de la scurit. Comment garantir la scurit des donnes dun utilisateur ? Comment vrier les saisies et dterminer si un utilisateur malveillant essaie de contourner la scurit de lapplication ? Toutes ces questions trouveront une rponse dans ce chapitre.
2 Cliquez sur cette che : un menu saffiche. Ignorez les options, part celle qui propose Insrez les lments standard (voir Figure 6.2).
LE GUIDE COMPLET 91
Chapitre 6
Penser lutilisateur
92 LE GUIDE COMPLET
Les menus
Chapitre 6
3 Cliquez dessus : la barre de menus contient tous les lments courants dune application Windows, savoir les menus Fichier, Edition, Outils et Aide.
Pour le moment, vous avez tous les menus de premier niveau. Si vous cliquez sur chacun des lments qui viennent dtre ajouts, vous verrez quun sous-menu apparat, vous laissant le choix dautres lments. Ainsi, le menu Aide a pour sous-menus Index, Recherche, propos, qui sont les lments de base dun menu Aide. Faites le test. Lancez une application que vous utilisez tous les jours, comme votre logiciel de messagerie ou votre traitement de texte. Regardez la barre de menus. Elle contient les mme lments que ceux que vous venez dajouter. Compilez lapplication avec la touche [F5], puis cliquez sur lun des boutons du menu : il ne se passe rien. Cest normal : pour linstant, vous avez simplement ajout un squelette de menus lapplication. Maintenant, vous allez lui ajouter des muscles pour quelle puisse tre pleinement fonctionnelle.
4 Revenez dans lditeur de formulaire, puis cliquez droite du menu Help. Vous pouvez ajouter votre propre menu. Dans la zone de saisie, entrez Texte. Vous allez ajouter un menu permettant le contrle du texte dune TextBox.
Pour cela, vous allez avoir besoin dune TextBox. Ajoutez au formulaire un contrle RichTextBox en la faisant glisser depuis la bote outils.
LE GUIDE COMPLET 93
Chapitre 6
Penser lutilisateur
RichTextBox
Cest une TextBox enrichie dun lot de fonctionnalits utiles, par exemple la possibilit deffectuer un traitement sur une slection de texte.
5 Une fois arriv ce rsultat, cliquez sur le menu Texte que vous avez insr, puis ajoutez-lui un sous-menu en remplissant la case situe juste dessous. Appelez ce sous-menu Gras.
94 LE GUIDE COMPLET
Les menus
Chapitre 6
6 Double-cliquez sur le sous-menu que vous avez cr, ce qui va vous transporter dans le code au niveau de lvnement "clic sur le sous-menu". cet endroit, ajoutez cette ligne de code :
RichTextBox1.SelectionFont = New Font(RichTextBox1 .SelectionFont, FontStyle.Bold)
Ce code agit directement sur le texte slectionn dans la RichTextBox et lui applique un style de police gras.
7 Lancez lapplication en appuyant sur la touche [F5], puis entrez du texte dans la RichTextBox. Ensuite, slectionnez-en une partie et cliquez sur le menu Texte puis sur le sous-menu Gras.
Le texte slectionn vient de passer en gras, mais pas le reste du texte. Pour vrier que vous avez bien saisi le concept de menu, ajoutez des sous-menus au menu Texte pour donner un style italique ou soulign.
LE GUIDE COMPLET 95
Chapitre 6
Penser lutilisateur
Partez de ceci :
96 LE GUIDE COMPLET
Les menus
Chapitre 6
ToolStrip
Cest une bote outils qui propose plusieurs options permettant de grer les icnes de la barre doutils ainsi que sa position.
1 Cliquez sur la petite che blanche en haut droite du ToolStrip puis sur Insrer les lments standard.
Comme prcdemment, cette action insre les lments les plus couramment utiliss : Ouvrir un fichier, Sauvegarder un fichier, etc.
LE GUIDE COMPLET 97
Chapitre 6
Penser lutilisateur
Il existe un deuxime moyen qui permet plus de contrle sur la barre doutils. Une fois le ToolStrip ajout, dans la fentre des proprits, une collection Items permet dditer les boutons de la barre.
2 Cliquez sur Collection puis sur licne dcore de trois points de suspension juste ct.
Dans cet diteur gurent droite les boutons dj ajouts par Visual Basic aprs le clic sur Insrer les lments standard. Pour ajouter un lment, il faut utiliser le bouton Ajouter en haut gauche de lditeur. gauche de ce bouton se trouve une liste de choix permettant de
98 LE GUIDE COMPLET
Les menus
Chapitre 6
slectionner llment ajouter lapplication. Pour le moment, ajoutez un bouton, que vous renommerez par G.
1 Dans lditeur, slectionnez le bouton que vous venez dajouter, puis cherchez dans la liste des proprits droite, la proprit appele DisplayStyle et changez sa valeur en Text.
2 Ensuite, cherchez la proprit Text et changez la valeur en G. Vous avez maintenant un bouton qui dispose dun style rellement professionnel.
LE GUIDE COMPLET 99
Chapitre 6
Penser lutilisateur
3 Revenez maintenant dans le designer, puis double-cliquez sur les boutons pour ajouter du code au niveau de leur vnement "clic".
Pour le bouton "gras", ajoutez la ligne suivante :
RichTextBox1.SelectionFont = New Font(RichTextBox1 .SelectionFont, FontStyle.Bold)
4 Lancez le programme en appuyant sur la touche [F5], saisissez du texte dans la RichTextBox, puis slectionnez une partie du texte. Utilisez lun des boutons et admirez le rsultat.
Les menus
Chapitre 6
Vous avez maintenant une petite application de traitement de texte qui permet de modier le style du texte saisi. Vous allez modier les boutons standard pour quils ouvrent un document.
1 Double-cliquez sur licne de louverture de chier dans le ToolStrip aprs avoir ajout des lments standard. Vous devriez tre dans la partie ddition du code. Ajoutez les lignes suivantes :
If (OpenFileDialog1.ShowDialog() = Windows.Forms .DialogResult.OK) Then RichTextBox1.Text = _ System.IO.File.ReadAllText(OpenFileDialog1.FileName) End If
Dans Visual Basic Express, vous ne pouvez pas entrer dinstructions sur plusieurs lignes moins de terminer la ligne prolonger par un caractre de soulignement. Ainsi vous pouvez manipuler plus facilement de longues instructions.
La premire ligne permet de tester si lutilisateur a bien valid avec le bouton OK dans la bote de dialogue de slection de chier. La deuxime ligne permet de rcuprer le contenu textuel du chier choisi dans la bote de dialogue (OpenFileDialiog1.Filename). Petit problme : cette mthode ne permet de lire quun document de texte, enregistr avec le Bloc-notes de Windows. Pour charger un document de type Richt Text Format, qui est un format beaucoup plus standard, vous pouvez utiliser la mthode LoadFile de la RichTextBox.
Cela chargera directement un chier dans la zone ddition de texte de la RichTextBox. Autre avantage de cette mthode : elle permet de garder le formatage du texte. Par exemple, si dans un diteur de type Wordpad ou Microsoft Word, vous avez du texte en gras, le texte en gras sera charg par la RichTextBox.
Chapitre 6
Penser lutilisateur
Maintenant que vous avez un moyen douvrir les documents au format RTF, vous allez implmenter une fonction de sauvegarde de ces documents. Ajoutez au formulaire un contrle de type SaveFileDialog.
3 Double-cliquez sur licne en forme de disquette du ToolStrip de manire vous placer dans ldition de code de lvnement "clic" du bouton et copiez les lignes suivantes :
SaveFileDialog1.Filter = "Fichiers RTF(*.rtf)|.rtf" If (SaveFileDialog1.ShowDialog() = Windows.Forms .DialogResult.OK)_ Then RichTextBox1.SaveFile(SaveFileDialog1.FileName) End If
La premire ligne permet de spcier le ltre appliquer pour trouver les chiers sauvegarder. Dans ce cas, il sagit des chiers RTF. Vous appliquez donc un ltre de type *.rtf. Sur la deuxime ligne, vous vriez que lutilisateur a bien cliqu sur le bouton OK de la bote de dialogue. Sil choisit le bouton Annuler, vous neffectuez pas la sauvegarde. Via la troisime ligne, vous allez effectuer la sauvegarde. Pour cela, vous utilisez la mthode SaveFile de la RichTextBox, qui prend en paramtre un chemin vers un chier, qui est ici donn par le rsultat de la bote de dialogue SaveFileDialog ajoute prcdemment. Vous avez maintenant un petit diteur de texte, qui permet ldition, louverture et la sauvegarde de chiers. Vous allez ajouter un systme de copier/coller. Parmi les boutons standard du ToolStrip se trouvent les trois boutons classiques de couper, copier et coller.
Cela aura pour effet de copier le texte slectionn dans le Presse-papiers Windows.
5 Placez-vous maintenant dans le code de lvnement "clic" du bouton Coller pour ajouter la ligne suivante :
RichTextBox1.Paste()
Cela aura pour effet de copier le contenu du Presse-papiers l o se trouve le curseur dans la RichTextBox. Attention toutefois, si vous
Les menus
Chapitre 6
cliquez sur Coller alors que du texte est slectionn, seul le texte slectionn sera remplac. Pour terminer la petite application, ajoutez une fonction Couper pour copier un texte slectionn et le supprimer de la RichTextBox.
6 Double-cliquez sur le bouton Couper du ToolStrip dans le designer, puis une fois dans le code, ajoutez la ligne suivante :
RichTextBox1.Cut()
Cette instruction va couper le texte, cest--dire le supprimer de la RichTextBox et placer le contenu de la slection dans le Presse-papiers en vue dune rutilisation ultrieure. Lancez maintenant le programme en appuyant sur la touche [F5] et testez les nouvelles fonctionnalits. Il reste maintenant trois boutons auxquels vous navez pas ajout de fonctionnalits. Nouveau est le premier des boutons standard du ToolStrip. Il permet normalement douvrir un nouveau document du type par dfaut de lapplication. Dans cet exemple, vous allez vous contenter de vider le contenu de la RichTextBox pour repartir sur un document "frais".
7 Double-cliquez sur le bouton Nouveau dans le designer de formulaire puis ajoutez le code suivant une fois dans lditeur.
RichTextBox1.Clear()
Maintenant, lorsque vous cliquez sur licne Nouveau, vous videz la RichTextBox. Il reste les boutons Imprimer et Aide. Limpression ntant pas possible directement partir de la RichTextBox, vous allez supprimer le bouton. Pour supprimer un bouton dun ToolStrip, vous avez deux solutions. La premire consiste slectionner le bouton en cliquant dessus dans le designer puis appuyer sur la touche [Suppr]. La deuxime consiste lancer lditeur de collection de lobjet ToolStrip, chercher le bouton qui correspond au bouton Imprimer dans la liste des lments du ToolStrip et cliquer sur licne reprsentant une croix droite de la liste des lments. Il reste le bouton daide. Pour sa gestion, vous allez charger une aide au format HTML (le format classique des aides Windows et des sites Internet). Vous pourrez au choix charger un chier local ou une adresse
Chapitre 6
Penser lutilisateur
Internet. Double-cliquez sur le bouton Aide ajout au ToolStrip et ajoutez la ligne suivante dans lditeur :
Help.ShowHelp(ToolStrip1, "c:\help.htm")
Cette instruction va charger un chier HTML qui se situe la racine du disque dur principal et ouvrir un navigateur qui pointera directement sur cette page. Si vous ne matrisez pas HTML, voici un exemple que vous pouvez recopier dans un document texte :
<HTML> <HEAD> <TITLE>Page daide de MonApplication<TITLE> </HEAD> <BODY> Pour le moment, aucune aide nest disponible. </BODY> </HTML>
Maintenant lapplication ddition de texte est complte. Il ne reste plus qu diter les diffrents menus pour reprendre les fonctionnalits qui y sont dcrites et supprimer celles qui ne sont pas implmentes. prsent, les menus nont plus de secret pour vous. Voyons maintenant les lments qui donnent aux applications un look professionnel et les
104 LE GUIDE COMPLET
Chapitre 6
erreurs ne pas commettre pour ne pas noyer lutilisateur dans une interface inutilisable au quotidien.
tre clair
Cette premire directive est double, il sagit dune part de ne pas surcharger le visuel de lutilisateur, par exemple de ne pas multiplier les boutons ou encore de privilgier les titres courts tel que "Imprimer" plutt que "Lancer limpression de la feuille en cours". Vous venez de voir comment utiliser les menus, donnez-leur des noms clairs et concis. Toute la justesse dune bonne interface tient en lquilibre entre les fonctions visibles et les fonctions qui le sont moins. Si vous dveloppez un programme destin un environnement sous Windows, la plupart des utilisateurs sont dj "formats" par les logiciels quils emploient tous les jours. Leur premier rexe lorsquils chercheront une fonctionnalit sera daller voir au mme endroit que dans leur programme habituel. Cest pourquoi dans la plupart des applications Windows, la commande Quitter est situe dans le menu Fichier. Cest une sorte de convention entendue, rien nest crit nulle part, mais vous risquez de dboussoler lutilisateur si vous ne la respectez pas.
Organiser
Le deuxime conseil suivre est de garder une bonne organisation, de prfrence par thmes. Que viendrait faire un bouton Imprimer dans un groupe de boutons destins aux modes de visualisation dune image ? Rien. Pour cela, Visual Basic met votre disposition plusieurs niveaux de menus, dicnes de lancement rapide via les ToolStrip. Il existe
Chapitre 6
Penser lutilisateur
galement dautres manires dharmoniser programmes que vous allez voir ci-aprs.
linterface
de
vos
Nhsitez pas multiplier les formulaires Windows. Dans lide de regrouper les lments dune mme famille, sil faut par exemple saisir des informations, mieux vaut le faire dans une fentre spare de la fentre principale. Pour la saisie des informations dune personne (un nom, un prnom, une adresse e-mail et un numro de tlphone), mieux vaut utiliser un deuxime formulaire et le relier un bouton Ajouter une entre sur le premier formulaire. Noubliez jamais quun projet peut contenir plusieurs formulaires et quils peuvent tre relis entre eux de manire simple. Vous verrez comment procder dans lexemple suivant.
Faire du beau
Il convient en matire de graphisme daborder lide de "belle interface". Lors de llaboration dun programme, restez dans les limites du dveloppement professionnel, traditionnellement beaucoup de gris, trs peu de fantaisie, etc. Vous pouvez cependant essayer de faire la diffrence avec les autres programmes gris laide deffets de transparence, jouer sur lopacit, les formes, la couleur, sans toutefois tomber dans lexcs dune application fond rose aves des boutons verts. La fentre de proprits des contrles Windows propose un lot de proprits destines ces effets. Vous allez les mettre prot ds maintenant.
La transparence
Un bon moyen de surprendre les utilisateurs est de jouer sur la forme de lapplication. Pour cela, ne changez pas directement la forme du formulaire dans le designer. Rusez. Vous allez en fait dclarer au formulaire quune couleur est utilise comme couleur de transparence puis afficher une image en arrire-plan pour rendre le formulaire transparent. Ouvrez un diteur dimage, comme Microsoft Paint et appliquez quelques touches de bleu primaire au formulaire. Si vous tes en manque dinspiration, vous pouvez reprendre ce modle :
Chapitre 6
Une fois que vous avez ni de modeler limage de fond, enregistrez-la au format Bitmap, (extension .bmp).
1 Crez un nouveau projet dans Visual Basic et slectionnez le formulaire dans le designer en cliquant dessus. Dans la fentre des proprits, cherchez la proprit BackgroundImage. Cliquez sur la case droite de celle-ci puis sur Importer dans le gestionnaire dimages.
Chapitre 6
Penser lutilisateur
2 Slectionnez limage que vous venez denregistrer puis cliquez sur OK.
Normalement limage saffiche sur la forme, mais peut-tre pas correctement du fait de sa taille trop leve. Juste en dessous de la proprit BackgroundImage, se situe la proprit BackgroundImageLayout. Elle permet de modier la manire dont limage est affiche sur le formulaire. Changez la valeur en cliquant sur la case ddition de la proprit, puis slectionnez Stretch ou tirer. Limage sadapte au formulaire. Il reste rendre le carr bleu transparent.
3 Pour cela, descendez dans la fentre des proprits et cherchez la proprit TransparencyKey.
TransparencyKey
La cl de transparence est un code qui permet de dnir sur le formulaire une couleur qui ne saffichera pas, ou plutt qui sera compltement transparente.
Modiez sa valeur pour obtenir un bleu primaire utilis pour limage de fond. Pour cela, cliquez et modiez le texte par Bleu. Lancez maintenant le programme en appuyant sur la touche [F5]. Dplacez la fentre un peu partout sur votre cran. Vous pouvez voir travers le formulaire lendroit o il est bleu.
Chapitre 6
Lopacit
La transparence pose ici un problme. En effet, il nexiste aucune graduation. Ou bien une partie du formulaire est transparent, ou bien elle ne lest pas. Pour avoir une graduation, il faut recourir la proprit Opacity du formulaire. Dans cet exemple, vous allez ajouter un contrle TrackBar pour modier lopacit du formulaire principal. Avec la proprit Opacity, lintgralit du formulaire devient plus transparent. Dans lexemple prcdent, si un bouton avait t plac sur le formulaire lendroit o ce dernier est transparent, il aurait t visible pleinement sans aucun effet. Avec une modication de lopacit, tous les contrles deviennent moins opaques.
1 Crez un nouveau projet dans Visual Studio. 2 Cliquez sur le formulaire. Dans la bote des proprits, cherchez la valeur Opacity droite de la proprit. 3 Modiez la valeur en inscrivant 50 dans la case prvue.
Cela aura pour effet de rduire de moiti la transparence de la fentre. Lancez le programme en appuyant sur la touche [F5] et admirez le rsultat.
Chapitre 6
Penser lutilisateur
Vous allez maintenant graduer cette opacit. Revenez au designer en fermant le test de lapplication.
Chapitre 6
au designer de Visual Studio et cliquez sur la TrackBar. Dans la fentre des proprits, affichez les vnements en cliquant sur licne en forme dclair, puis dans la liste, cherchez lvnement nomm ValueChanged. Double-cliquez sur la case droite du nom, ce qui vous place dans lditeur de code, lendroit des instructions effectues lors de cet vnement. Recopiez cette ligne :
Me.Opacity = TrackBar1.Value/10
Lancez ensuite le programme en appuyant sur [F5]. Bougez maintenant le curseur de la TrackBar : lopacit de la fentre est modie en temps rel.
La ligne de code entre dans lvnement est facile comprendre : chaque fois que la valeur de lopacit de la TrackBar change, elle est enregistre dans la variable dnissant lopacit de la fentre et de ses contrles. Elle est divise par 10 car elle doit tre comprise en 0 et 1, la proprit Opacity attendant une variable de type Double.
Chapitre 6
Penser lutilisateur
la fentre principale saffiche la taille que vous lui avez donne dans le designer. Mais que se passe-t-il si vous la redimensionnez pour quelle occupe tout lcran ? Faites le test. Dans le designer de formulaire de Visual Studio, ajoutez plusieurs contrles de type bouton, une PictureBox, et lancez-le. Cliquez sur le bouton dagrandissement de la fentre. Que se passe-t-il ? Les contrles ne se repositionnent pas directement sur le formulaire et lapplication parat "dsordonne". Pour remdier cela, il faut avoir recours lancrage des contrles. Lancrage revient prciser de manire relative quels endroits doivent saccrocher les contrles dans le dessin. Pour ce faire, il faut dcouper le formulaire en zones. Il existe un moyen simple de procder. Vous allez utiliser le contrle TableLayout. Faites glisser un TableLayout sur une forme dans un nouveau projet. Le TableLayout est en fait une grille dans laquelle vous allez pouvoir placer les diffrents contrles. Quand la fentre est redimensionne, la grille lest aussi et les contrles gardent leur place. Par dfaut, la grille est divise en quatre, deux lignes et deux colonnes. Vous pouvez diter le nombre de lignes et de colonnes en cliquant sur le contrle puis sur la petite che blanche en haut droite. Saffichent alors des options ddition de lignes et de colonnes.
Il reste maintenant travailler sur le positionnement des contrles dans les diffrentes parties de la grille. Ajoutez un bouton dans lune des parties. Le bouton va par dfaut se caler en haut gauche de la grille.
112 LE GUIDE COMPLET
Chapitre 6
Cela est directement li la proprit Anchor du bouton. Cliquez sur la case droite de la proprit Anchor.
Vous pouvez indiquer par rapport quelle partie du contrle parent doit tre plac un contrle. Si vous grisez la case haute, le contrle sera plac au milieu et en haut. Si vous grisez le bas, le contrle sera plac en bas. Si le haut et le bas sont griss, le contrle sera centr. Testez sur le bouton. Modiez la proprit Anchor et lancez le programme pour observer les changements.
Anchor
La proprit Anchor permet de dnir les bords du formulaire par rapport auxquels le contrle doit tre centr.
Ajoutez une PictureBox dans lune des cases de la grille. Dans la fentre des proprits, cherchez la proprit Dock et cliquez sur la case de droite.
Les diffrents choix possibles permettent pour le haut, le bas, la droite et la gauche de bloquer lalignement du contrle. Si vous choisissez de le centrer, le contrle va prendre toute la place disponible du contrle parent. Dans le cas de la PictureBox, il sagit de la case du TableLayout dans lequel vous lavez place. Si vous ne mettez pas de TableLayout, le contrle parent se trouve tre le formulaire lui-mme. Donc si vous choisissez de le centrer, le contrle va remplir tout le formulaire.
Chapitre 6
Penser lutilisateur
Docking
Le docking permet de garder la relativit de la position, par exemple le fait dtre coll au bord droit mme si le formulaire est redimensionn.
Les derniers lments qui peuvent servir pour redimensionner, garder les proportions, grouper les contrles sont les contrles GroupBox et Panel.
GroupBox
Le contrle GroupBox permet de regrouper des contrles, tout comme le contrle Panel, la diffrence que, pour la GroupBox, les contrles sont entours dun liser n et dune lgende. En outre, lorsque vous regroupez des choix laide de contrle de type RadioButton, ils peuvent tre slectionns de manire exclusive.
Dans cet exemple, il suffit dajouter un formulaire un Panel et une GroupBox. Pour le Panel, il faut modier la proprit Anchor haut et droite, et pour la GroupBox bas et gauche. Pour le Panel, les proprits
114 LE GUIDE COMPLET
Chapitre 6
Dock des boutons ont t modies pour droite sur le bouton 2, gauche pour le bouton 1 et bas pour le bouton 3. Remarquez comment ils se placent dans le Panel.
Reproduisez le mme exemple dans un nouveau projet. En lanant le programme, remarquez que les RadioButton sont indpendants les un des autres. Si vous ajoutez une deuxime GroupBox, vous pouvez raliser un deuxime groupe de RadioButton indpendants, ce qui est impossible sils ne sont pas regroups.
Chapitre 6
Penser lutilisateur
lutilisateur, il faut placer une information sur linterface, ou mme rduire les possibilits de saisie un ensemble de valeurs. Pour comprendre cela, prenez un nouveau projet. Sur le formulaire principal, ajoutez une TextBox et un contrle Button. Dans le code de lvnement "clic" du bouton, ajoutez le code suivant :
MessageBox.Show(Int32.Parse(TextBox1.Text).ToString)
Lancez maintenant lapplication, entrez ce que vous voulez dans la TextBox et cliquez sur le bouton. Vous vous retrouvez alors face une erreur.
Lorsque le code essaie de transformer le contenu de la TextBox en texte, il se retrouve bloqu par le fait que le texte nest pas sous forme numrique. Le programme sarrte donc de fonctionner. Pensez donc tre le plus explicite possible quant aux saisies des utilisateurs. Il existe toujours un jeu du chat et de la souris entre le dveloppeur dune application et ceux qui lutilisent de faon malveillante. chaque fois quun dveloppeur protge une information, quelquun va chercher dcouvrir cette information. Pour linstant, vous allez vous contenter de restreindre lutilisation de lapplication aux personnes disposant dun mot de passe.
1 Dans lExplorateur de solutions, cliquez du bouton droit sur le nom du projet puis sur Ajouter, et enn sur Nouvel lment. 2 Dans les choix qui soffrent vous, slectionnez LoginForm.
Il sagit tout simplement dune fentre de type formulaire qui contient dj tous les lments ncessaires pour identier un utilisateur.
Chapitre 6
En double-cliquant sur le bouton OK du LoginForm dans le designer, vous allez pouvoir modier le code excut lors dun clic sur le bouton OK du LoginForm.
Cela prcise au LoginForm que, si le texte entr dans le champ Password est cafetiere, lutilisateur a donn le bon mot de passe et est alors autoris utiliser le programme. Maintenant il faut que vous utilisiez ce LoginForm au moment o le programme se charge pour que lutilisateur ne puisse pas utiliser le programme avant de stre authenti. Pour cela, dans le designer, double-cliquez sur la fentre principale du programme.
Chapitre 6
Penser lutilisateur
De cette manire, avant que la fentre principale du programme napparaisse, le formulaire didentication sera charg en premier et ne chargera le formulaire principal que si le mot de passe est le bon. Il reste encore un petit problme rgler. En effet, si vous cliquez sur le bouton Cancel du LoginForm, vous avez accs au formulaire principal mme si le mot de passe nest pas le bon. Auriez-vous pens vrier le comportement du bouton Annuler ? Cela fait partie des tests de scurit faire imprativement lors de tout dveloppement. Il faut toujours tre sr de la faon dont va ragir lapplication lorsque lutilisateur fera tout et nimporte quoi.
Cette ligne terminera lexcution du programme. Vous avez maintenant une bonne ide de ce quil faut faire pour scuriser laccs au programme. Vous pouvez transformer le programme en une vritable forteresse en multipliant les mesures de scurit. La seule limite est votre imagination. La plupart des livres qui traitent de la scurit informatique commencent tous par la mme ligne : "naccordez aucune conance aux utilisateurs". Il faut bien sr trouver un juste milieu : la scurit ne doit jamais tre contraignante. Aussi ne tombez pas dans les travers consistant demander quinze mots de passe un utilisateur. Il risquerait dtre frustr et dabandonner le programme.
Chapitre 7
Dans tous les programmes que vous avez raliss jusque-l, lors de la fermeture du programme, toutes les informations saisies sont effaces, ce qui est gnant. Heureusement, il existe des moyens de sauvegarder des donnes une fois lexcution dun programme termine. Vous allez voir deux mthodes : la premire repose sur des chiers de sauvegarde ; la deuxime, fonde sur les bases de donnes, est plus complte mais plus longue mettre en place.
Chapitre 7
programme par un nombre entier. Voici un exemple de tableau que vous pourriez obtenir :
Tableau 7.1 : Rexion autour des recettes
Donne Nombre de personnes Temps de prparation Nom de la recette Catgorie de plats Recette
Cette reprsentation va servir tablir ce que sera une table dans la base de donnes. Une table est une partie de la base qui va contenir des informations. Ce que vous venez de faire sappelle la modlisation de la base de donnes. En effet, une base de donnes est organise sous forme de tables. Dans la table des recettes par exemple, chaque recette va reprsenter une entre. Une fois en mmoire, la table consistera en un tableau dont chaque ligne sera une entre. Une fois rempli, le tableau se prsentera comme ceci pour le programme :
Tableau 7.2 : Table des recettes
Nombre de personnes 4 2
En quoi cette organisation sous forme de tableau fait-elle gagner du temps ? Si vous avez deux recettes, cela ne sert rien car la quantit dinformations nest pas importante. Si vous avez deux mille recettes trier, une base de donnes va vous permettre de retrouver la recette que vous cherchez parmi les deux mille disponibles, et ce en moins dune seconde, grce un langage spcique de requtes. Rassurez-vous, il nest pas question que vous appreniez le langage des bases de donnes pour le moment. Visual Basic se charge de traduire pour vous. Pour le moment, retenez ce principe : de manire optimiser le programme laide dune base de donnes, il faut dabord rchir lorganisation de
LE GUIDE COMPLET 121
Chapitre 7
la base, puis remplir la base laide de donnes sous forme de tableau et enn crer une requte de manire retrouver rapidement les informations de la base. Si vous vous sentez lgrement perdu, rien de grave, nous claircirons tout cela par la pratique dans un instant. Maintenant que vous connaissez les deux mthodes possibles pour sauvegarder des donnes, passez la pratique. Vous allez crer cet utilitaire de gestion de recettes.
Rapidit
Les bases de donnes tant des chiers organiss, il est souvent plus rapide de rechercher une information dans de telles structures de donnes que dans un chier sur un disque.
2 Dans le designer de formulaires, ajoutez au formulaire par dfaut un contrle MenuStrip puis placez dessus les lments standard.
122 LE GUIDE COMPLET
Chapitre 7
3 Dans le formulaire, ajoutez trois Label et quatre TextBox. Dans la fentre des proprits, changez les proprits Name des TextBox en nombrepers, tempsprep, titre et recette.
La premire va contenir le nombre de personnes pour lequel est prvue la recette, la deuxime le temps de prparation, et les deux autres respectivement le titre et le corps de la recette.
Chapitre 7
Tout nest pas ni. Pour sauvegarder les donnes, vous allez utiliser des chiers contenant du texte sous cette forme :
Nombre de personnes Temps de prparation Titre Corps de la recette sur plusieurs lignes
De cette manire, vous stockerez une information importante par ligne, et il sera ais de retrouver automatiquement toutes les informations ncessaires quand vous aurez besoin douvrir le chier contenant la recette. Il sagit maintenant que le programme sauvegarde la recette dans un chier.
Chapitre 7
Vous prcisez en premire ligne le type de chier sauvegarder. En prcisant TXT, vous dsignez un chier texte qui sera rutilisable dans nimporte quelle application. Le test conditionnel permet de vrier que lutilisateur a bien cliqu sur le bouton OK de la bote de dialogue de sauvegarde de chier. Une fois que vous tes sr quun chier a bien t slectionn, vous exploitez une nouvelle notion, que sont les ux. Un peu la manire dun tuyaux, un ux permet de faire passer de linformation dun point un autre, comme une rivire permet un bateau de naviguer dune ville un autre. Vous utilisez ici un objet de type StreamWriter, que lon peut traduire par "ux dcriture". Vous faites passer de linformation dun point A un point B en lcrivant une fois arriv au point B. Dans ce cas, le point A reprsente chacune des TextBox que vous allez remplir, et le point B reprsente le chier darrive dans lequel vous voulez enregistrer la recette.
Cration du chier
Lors de la cration du chier, il faut vrier la place quil va prendre sur le disque dur. Si lespace disque nest pas suffisant, vous devrez grer lerreur.
Vous initialisez le point B (votre chier) en rcuprant dans la bote de dialogue de sauvegarde le rsultat de la slection de lutilisateur, en loccurrence le chier quil a choisi. Ensuite, vous utilisez la mthode WriteLine du ux dcriture pour ajouter, ligne par ligne, le contenu des diffrentes TextBox du formulaire. La dernire ligne est un peu particulire. Il sagit en effet de vider compltement le ux dcriture, de manire ne perdre aucune
LE GUIDE COMPLET 125
Chapitre 7
information lintrieur. Cette action a pour but de tout faire arriver au point B, un peu comme si lon essayait de transfrer de leau dune bouteille dans un seau. Le ush permet de secouer la bouteille pour ne laisser aucune goutte lintrieur. La diffrence est que le ux dcriture fonctionne comme une bouteille dans laquelle leau peut rester accroche. Il faut donc secouer pour la faire tomber. Si vous enlevez la ligne sw.Flush(), aucune partie du texte ne sera crite dans le chier.
Flush
Le ush est laction de vider compltement un ux dcriture. Cette opration permet rellement de terminer lcriture de donnes.
Comme vous pouvez le voir, lcriture dans un chier est trs simple et se fait grce un ux dcriture. Pour rendre cette application plus agrable utiliser, reprenez les consignes du chapitre Penser lutilisateur en matire de design dinterface. Il faut supprimer les menus inutiles et faire en sorte que le redimensionnement du formulaire principal ne dplace pas les lments quil contient. Amusez-vous entrer quelques recettes de manire disposer dun rpertoire contenant une dizaine de chiers. Passons maintenant la lecture des chiers de recette et leur chargement dans lapplication.
Lire un fichier
Chapitre 7
2 Dans le designer de formulaires, ajoutez au formulaire principal un contrle MenuStrip ainsi que trois contrles Label et une TextBox. Dans la fentre des proprits de la TextBox, changez la proprit ReadOnly en la mettant la valeur True, an de rendre la TextBox non ditable. En effet, vous voulez uniquement lire les informations contenues dans un chier.
3 Maintenant que vous avez le prototype, modiez le nom des contrles pour arriver ce que vous voulez. Les contrles Label vont contenir chacun une des informations de la recette, savoir le titre, le nombre de personnes pour lequel la recette est prvue et le temps de prparation. 4 Ajoutez maintenant un contrle de type OpenFileDialog qui va permettre de slectionner les recettes.
Chapitre 7
Il faut passer aux instructions. Comme pour lcriture dans un chier, la lecture dun chier passe par lutilisation de ux. La diffrence cette fois est que le ux va dans lautre sens, savoir dune ressource (votre chier) vers votre programme. Le fonctionnement est le mme, seul le nom va changer. Vous allez en effet utiliser un objet de type StreamReader, et non un StreamWriter. Dans cet exemple, nous avons renomm les Label en fonction des informations quils allaient recevoir.
5 Dans le contrle MenuStrip, cliquez sur le menu Fichier pour faire apparatre les sous-menus et double-cliquez sur Ouvrir.
Lire un fichier
Chapitre 7
Comme dans lexemple prcdent, vous utilisez le premier test de comparaison pour vrier que lutilisateur a bien cliqu sur le bouton OK de la bote de dialogue. Ensuite, vous dclarez un nouveau ux de lecture, qui sera initialis avec le contenu du chier slectionn dans la bote de dialogue douverture de chier. Vous lisez ensuite les trois premires lignes, qui vont respectivement contenir le titre, le nombre de personnes prvu et le temps de prparation. Une fois que ces trois lignes sont lues, il suffit de lire le chier jusqu la n pour avoir le corps de la recette. Pour commencer la collection de recettes, voici celle du clafoutis aux cerises :
Le clafoutis aux cerises
Pour 6/8 personnes, temps de prparation : 10 minutes. Ingrdients : 700 g de cerises bien mres 2 ufs + 2 jaunes dufs 5 cuilleres soupe de farine (100 g) 5 cuilleres soupe de sucre roux (100 g) 1/4 de litre de lait (25 cl) 60 g de beurre 1 pince de sel 1 cuillere caf dextrait de vanille 1 sachet de sucre vanill (facultatif)
Chapitre 7
Prparation : Lavez et queutez les cerises. Allumez votre four thermostat 6/7 (180/200 C). Dans un plat tarte, mettez le beurre puis enfournez-le. Battez les ufs en omelette, ajoutez la pince de sel ainsi que le sucre. Mlangez bien (au fouet ou au robot). Ajoutez lextrait de vanille, mlangez et jetez la farine en pluie. Mlangez bien jusqu obtenir un liquide pais et onctueux. Sortez le beurre fondu du four, ajoutez-le au liquide puis ajoutez le lait tout en remuant. Une fois que vous avez mlang, ajoutez les cerises la prparation. Avec un essuie-tout, talez le beurre rest dans le plat pour le graisser, puis ajoutez la prparation. Ajoutez quelques noisettes de beurre par-dessus. Enfournez 45 mn (jusqu ce que le dessus commence bien dorer). Ds la sortie du four, saupoudrez de sucre vanill. Servez tide.
Utilisez maintenant le programme dentre de recettes pour sauvegarder cette recette de clafoutis dans un chier, puis lancez le programme de lecture de recette pour rcuprer le contenu du chier. En cliquant sur Ouvrir puis en slectionnant le chier de la recette de clafoutis, vous obtenez le rsultat suivant :
Chapitre 7
Vous remarquez un petit problme ? La recette nest pas du tout mise en page et le texte est difficilement lisible du fait quil ny a aucun retour la ligne. Pour remdier cela, il suffit de remplacer le contrle TextBox par une RichTextBox, offrant beaucoup plus de fonctionnalits. Pour en savoir plus ce sujet, lisez le chapitre Penser lutilisateur.
1 Commencez par crer un nouveau projet de type application Windows dans Visual Basic Express. 2 Une fois dans le designer de formulaires, cliquez du bouton droit sur le nom du projet dans lExplorateur de solutions puis cliquez sur Ajouter un nouvel objet. 3 Choisissez Base de donnes SQL (SQL Database).
Chapitre 7
4 Une fois la base slectionne, donnez-lui le nom recettes.mdf puis cliquez sur le bouton Ajouter. LAssistant de conguration de source de donnes saffiche.
Chapitre 7
5 Ignorez cet Assistant et cliquez sur Annuler. LExplorateur ressemble maintenant la capture suivante, avec le formulaire principal et la base de donnes.
Une base de donnes est une sorte de classeur dans lequel vous pouvez loisir incorporer des feuilles que lon appelle "tables" et qui permettent dorganiser les donnes. Il faut maintenant rchir la structure de ces tables et la manire dont vous allez organiser les donnes. Le but ici est de ne pas rpter les donnes plusieurs fois dans le cas o vous auriez plusieurs tables. Le programme tant plutt simple, vous avez besoin dune seule table que vous allez reprsenter sous forme de tableau, comme dcrit en introduction. Un point important est que cette base de donnes est compltement indpendante de Visual Basic Express ou du langage Visual Basic, comme vous allez le voir maintenant. Il faut prsent ajouter une table la base. gauche de linterface de Visual Basic, un nouvel onglet est apparu, nomm Explorateur de bases.
Chapitre 7
7 Cliquez du bouton droit sur le dossier Tables puis slectionnez Ajouter une nouvelle table.
la place du designer de formulaires saffiche un tableau trois colonnes, la premire indiquant le nom de la colonne dans la table, la seconde le type de donnes que va contenir cette colonne et la troisime une bote cocher pour spcier si oui ou non vous voulez que cette valeur puisse tre nulle.
8 Vous allez vous conformer au schma de table spci en introduction : une premire colonne de la table reprsentera le nombre de personnes pour lequel la recette est prvue, une deuxime colonne le temps ncessaire, une troisime le nom de la recette, une quatrime la catgorie de plats et une cinquime le corps de la recette. Vous allez donc commencer par entrer les
134 LE GUIDE COMPLET
Chapitre 7
spcications de la premire colonne, savoir le nombre de personnes. Dans la case Column Name, entrez la valeur NbPers. Dans la colonne DataType, vous navez rien entrer ; vous devez faire une slection parmi une liste de types possibles. Pour symboliser un nombre entier simple, utilisez numeric(18,0). Le tableau sagrandit en ajoutant automatiquement une seconde colonne remplir. Remplissez les lignes suivantes comme vous venez de le faire, en ajoutant une ligne TempPrep de type ntext, une ligne Titre de type ntext, une ligne CatPlat de type Text, et une ligne CorpsRec de type text. La diffrence entre les types text et ntext rside dans la longueur admissible des donnes que lon peut entrer dans chaque case.
9 Sauvegardez maintenant la table que vous venez de crer en appuyant sur les touches [Ctrl]+[S].
LE GUIDE COMPLET 135
Chapitre 7
10 Un nom vous est alors demand pour la sauvegarde de la table. Entrez MaTable puis cliquez sur le bouton OK.
La table sajoute alors dans lExplorateur de bases.
Vous allez maintenant ajouter des valeurs dans la table partir de Visual Basic. Dans lExplorateur de solutions, cliquez du bouton droit sur la table que vous venez dajouter puis slectionnez Afficher les donnes de la table. Le designer montre alors un tableau qui reprsente la table, les colonnes tant celles que vous venez dentrer (voir Figure 7.16). Ajoutez sur la premire ligne les informations de la recette du clafoutis. Pour le nombre de personnes, faites attention entrer un nombre entier pour respecter le format de type numeric. Vous tes en effet moins libre que lors de lutilisation des chiers. Mais comme vous le verrez plus tard, cela permet de faciliter les recherches. Libre vous dajouter dautres lignes pour reprsenter dautres recettes. Une fois que vous avez ajout les recettes que vous voulez, passez la section suivante.
136 LE GUIDE COMPLET
Chapitre 7
1 Cliquez sur longlet Sources de donnes, qui saffiche la place de lExplorateur de solutions.
Chapitre 7
2 Cliquez sur le lien qui vous propose dajouter une source de donnes au projet. Choisissez Base de donnes et cliquez sur Suivant.
Chapitre 7
Lcran suivant permet de choisir la base de donnes utiliser comme source. Normalement, celle cre plus tt et nomme Recettes.mdf est dj slectionne.
4 Il vous est ensuite demand si vous voulez crer ce quon appelle une chane de connexion. Rpondez oui cette question. Crer une chane de connexion permet de stocker quelque part dans le programme un lien qui pointe vers la source de donnes. Ainsi, si jamais la source de donnes change dendroit, il suffira dditer le lien dans la conguration de lapplication au lieu de reprendre toute la conguration de la base de donnes. Vous gagnerez ainsi un temps prcieux. Rpondez donc par laffirmative puis cliquez sur Suivant. 5 Il vous est ensuite demand quelles donnes de la source vous voulez reprendre. Vous voulez afficher vos recettes. Il faut donc reprendre toutes les informations de la table. Cliquez donc sur les botes de choix, comme indiqu sur lcran suivant :
Chapitre 7
Le DataSet est un jeu de donnes qui fera pour vous le lien entre la base et les donnes recherches. Vous pouvez lditer tout moment dans la fentre des sources de donnes.
partir de maintenant, dans la fentre qui montre les sources de donnes, lorsque vous cliquez sur le nom de la table, vous verrez apparatre sur la droite une icne de liste droulante qui propose deux choix : DataGridView ou Details. Ces deux choix concernent la reprsentation des donnes de la base sur le formulaire. Pour un premier exemple, choisissez DataGridView et faites glisser le nom de la table vers le formulaire. Un tableau est ajout au formulaire, ainsi que des contrles de navigation et un contrle MaTableBindingSource, qui est le
Chapitre 7
lien physique entre le formulaire et la table. Voyons maintenant comment utiliser tout cela. Lancez une premire fois lapplication.
La ligne relative au clafoutis saffiche bien en premire ligne. Observez les boutons situs dans la barre doutils en haut de la fentre dapplication. Ils servent naviguer parmi les enregistrements de la base de donnes. Cliquez sur le signe + situ parmi les outils. Une ligne est alors ajoute au tableau, vous permettant dinsrer un enregistrement dans la base. Ajoutez une salade par exemple. Cliquez sur licne en forme de disquette droite de la barre doutils pour enregistrer les changements. Quittez lapplication. De retour dans Visual Basic, appuyez une nouvelle fois sur la touche [F5] pour relancer le programme. Vous serez du en constatant que la modication na pas t prise en compte et que la base de donnes ne contient que la ligne relative au clafoutis.
Chapitre 7
1 Revenez dans Visual Basic, dans le designer de formulaires. 2 Cliquez sur la base de donnes dans lExplorateur de solutions, de manire afficher ses proprits. 3 Dans la liste des proprits, cherchez celle qui se nomme Copie vers le rpertoire de destination. Par dfaut, sa valeur est Toujours. 4 Changez cette valeur par Ne pas copier.
Cela fait, si vous lancez le programme, une erreur survient lors du lancement. Linitialisation de la base est impossible. En utilisant cette mthode, il faudra toujours penser copier la base de donnes dans le rpertoire dexcution du programme. Normalement, la base est compose de deux chiers, lun portant lextension .mdf et lautre lextension .ldf. Ils sont tous deux stocks la racine du projet. Par dfaut, ce rpertoire est Mes Documents\Visual Studio 2005\Projets\Nom du projet\Nom du projet.
5 Copiez ces deux chiers dans le rpertoire Bin\debug\ du rpertoire de projet. 6 Si vous avez chang la proprit dans lditeur de proprits de la base du designer de formulaires, vous avez ni. Relancez maintenant le programme et tentez une modication en ajoutant une valeur.
Chapitre 7
8 Retournez maintenant dans le designer de formulaires. 9 Nous avons nonc plus haut deux manires dafficher les donnes dune base de donnes. Or vous nen avez utilis quune. Supprimez du formulaire le DataGridView, mais pas les outils de navigation. Dans la fentre des sources de donnes, cliquez sur le nom de la table, puis changez dans la liste droulante la valeur de reprsentation en slectionnant Details. La reprsentation se fera sous la forme dun lot de contrles, comme lorsque vous lisez partir dun chier. En cliquant sur chacun des champs de la table, vous pouvez voir quils disposent de la mme petite icne de choix qui permet de slectionner le type de contrle qui les reprsentera. Choisissez TextBox pour chacun des contrles pour le moment. 10 Dans le designer de formulaires, arrangez les contrles comme bon vous semble, puis gnrez le projet en appuyant sur [F5].
Chapitre 7
Chaque champ est rempli avec la valeur associe dans la base. Utilisez les ches droite et gauche situes dans la barre de menus pour naviguer dans les ches de recette. Comme vous lavez fait dans le tableau, vous pouvez ajouter une entre en cliquant sur le bouton + de la barre doutils et enregistrer les changements dans la base.
Chapitre 8
Un jour ou lautre, vous devrez faire face des bogues ou des erreurs de programmation. Il nexiste pas de programmeur qui na jamais fait une seule erreur. Forcment, vous en ferez, mais il ne faut pas vous dcourager pour autant. Le tout est de les prvoir et de les liminer pour une utilisation relle du programme. Vous allez voir dans ce chapitre les diffrents lments qui vous permettront de retrouver et dliminer ces erreurs. En ce sens, vous utiliserez des exceptions. Elles permettent de dtecter les erreurs lors de la programmation et deffectuer des oprations en consquence. Si elles nont pas toutes t recenses lors de cette tape, vous apprendrez les dtecter lors de la phase de dbogage, et aussi crer des traces crites du droulement du programme, de sorte que vous pourrez le contrler a posteriori. Nous nirons par quelques habitudes de programmation prendre, savoir insrer des commentaires et rdiger la documentation, qui permettront de minimiser ces problmes.
Le programme va dire que lon est majeur, alors quen fait, lge donn nest pas valable. En effet, il nexiste pas dge ngatif. Une solution est de prvoir ce cas. On peut par exemple considrer quun ge est valide sil est compris entre 0 et 130 (pour ceux et celles qui ont une grande esprance de vie !). Voici le bout de programme corrig :
Dim age As Integer age = -1 If (age < 0 || age > 130) Then MessageBox.Show("Lge donn nest pas valide") ElseIf (age < 18) Then MessageBox.Show("Vous tes mineur") Else
La prvention maximale
MessageBox.Show("Vous tes majeur") EndIf EndIf
Chapitre 8
Maintenant le programme vrie si lge donn est valide et donne une rponse juste, alors que dans le cas prcdent, il a donn une rponse fausse. Il sagit l dune manire de minimiser les erreurs, simple et relativement efficace. Cependant, Visual Basic .NET intgre des mcanismes plus puissants pour cette tche : les exceptions.
description de lexception qui a t leve. StackTrace : donne des informations concernant la fonction qui a provoqu lexception, le dossier, le chier, et mme la ligne correspondante.
Voici le fonctionnement de base dune exception : Lorsquil y a une erreur dexcution, cest--dire une erreur qui na pas t dtecte la programmation, une exception correspondant lerreur
LE GUIDE COMPLET 147
Chapitre 8
est leve. Le programme sarrte. En ralit, il ne sarrte pas vraiment, mais disons que les instructions normales ne sont plus excutes. Il va se drouler jusqu trouver une structure capable de grer lexception, savoir un bloc catch (nous y reviendrons). Sil nest pas dans la fonction en cours, le programme va continuer dans les fonctions suivantes pour voir si un tel bloc existe. Sil nexiste pas, il y a un gestionnaire par dfaut, qui affiche le type de lexception, dventuelles informations supplmentaires, et lapplication se termine. Il se prsente comme ceci :
Gnralement, il ne faut pas utiliser le gestionnaire par dfaut. Cest pourquoi vous allez apprendre crer et utiliser des structures de gestion dexceptions.
La prvention maximale
Try Instructions_a_evaluer Catch exception As type_de_lexception Instructions_de_gestion_des_exceptions Finally Instructions_toujours_executees End Try
Chapitre 8
Dans le bloc Try, il faut mettre les instructions valuer pour vrier le droulement du programme. Le bloc sera excut et, si aucune exception na t leve, le programme continuera normalement. Cest dans le bloc Catch que les exceptions sont traites. Ici vous pouvez afficher les messages, ventuellement les crire dans des chiers texte (vous verrez plus loin les journaux dvnements), modier les donnes en consquence, etc. Dans cette partie, il est intressant dutiliser les proprits Message et StackTrace dcrites prcdemment. Il peut y avoir plusieurs blocs Catch. Dans ce cas, on parle de traitement sur plusieurs niveaux. On va du plus spcialis au plus gnral :
Try Instructions_a_evaluer Catch exception1 As type_de_lexception1 Instructions_de_gestion_des_exceptions1 Catch exception2 As type_de_lexception2 Instructions_de_gestion_des_exceptions2 Catch exception3 As type_de_lexception3 Instructions_de_gestion_des_exceptions3 Finally Instructions_toujours_executees End Try
Dans le bloc Finally, insrez des instructions excuter dans tous les cas, quune exception ait t leve ou non. Ce bloc est facultatif. La plupart du temps, des instructions excuter dans tous les cas lont dj t par ailleurs dans le programme.
Chapitre 8
Dim resultat As Integer resultat = dividende / diviseur MessageBox.Show("Rsultat = " + resultat) Catch exception As_ System.DivideByZeroException MessageBox.Show(exception.Message) MessageBox.Show(exception.StackTrace) diviseur = 1 Catch exception As System.Exception MessageBox.Show(_ "Il y a eu une exception dordre gnral"_ ) Finally Dim resultat As Integer desultat = dividende / diviseur MessageBox.Show("Rsultat final = " + resultat) End Try
Le but de ce programme est dtablir une division par zro, ce qui permettra de voir comment fonctionnent les exceptions et comment en tirer le meilleur parti. Tout dabord, on est oblig dutiliser des variables pour provoquer cette erreur. On naurait pas pu crire directement resultat = 12 / 0 car le compilateur aurait directement provoqu une erreur, visible dans Visual Studio :
De plus, dividende et diviseur tant utiliss dans plusieurs blocs, on ne peut pas se contenter de les mettre dans le bloc Try, cause de la porte des variables. Dans le bloc Try, la division de dividende par diviseur, valant respectivement 12 et 0, va lever une exception de division par zro, qui va court-circuiter linstruction cense afficher le rsultat de lopration. Un bloc Catch suit. Le programme peut donc traiter lexception. Comme il sagit effectivement dune division par zro, elle sera traite au premier niveau. On affiche le message de lexception :
La prvention maximale
Chapitre 8
On modie diviseur tant donn que lon va lutiliser ensuite dans le programme. Il ne faudra pas que la mme erreur se produise, cest pourquoi il faut changer sa valeur. Cette exception ayant t traite au premier niveau, il nest pas ncessaire de passer au dernier niveau de Catch. Le programme va donc au bloc Finally. Dans ce dernier bloc, la mme division est refaite, alors que diviseur a t modi. Lopration se passe sans encombre et le programme est en mesure dafficher le rsultat de cette division. ce moment, une exception a t leve, elle a t traite, et le programme peut donc continuer normalement, partir du End Try. travers cet exemple, vous avez pu voir une utilisation la fois basique et efficace des exceptions. Apprenez bien crire vos programmes en utilisant ce systme, car il se rvle efficace pour la gestion des erreurs, surtout quand il est associ dautres lments, comme les journaux dvnements que vous allez voir ci-aprs. La gestion des exceptions peut aller beaucoup plus loin, par exemple avec le redclenchement dexceptions en cascade, mais cela nentre pas dans le cadre de cet ouvrage. Matriser laspect simple des exceptions permet damliorer la qualit des programmes, et avec la pratique, vous viterez de nombreux plantages.
Chapitre 8
Dans ce morceau de programme, on considre que dividende et diviseur ne sont pas des variables dclares explicitement, mais issues dun chier texte de cette forme :
Ce chier texte donne les valeurs de dividende et diviseur. Le programme peut tre excut et avoir le mme comportement que si lon
Chapitre 8
avait dni directement les variables, dans la mesure o les valeurs entres sont correctes. Pour savoir comment enregistrer des donnes dans un chier texte, reportez-vous au chapitre Enregistrer des donnes. Imaginez quun petit malin remplace des valeurs correctes de
dividende et diviseur par des chanes de caractres non
numriques.
Lopration resultat = dividende / diviseur ne peut se faire. Lerreur provoque ntant pas une division par zro, elle est traite en tant quexception gnrale et le programme affiche tout simplement un message ce sujet. Bien que lerreur soit traite, les informations ne sont pas particulirement pertinentes. De plus, une fois ce traitement excut, on na plus de trace du droulement du programme. Pour pallier cette insuffisance, on utilise des journaux dvnements. Ils permettent de conserver des traces de lexcution du programme (de son comportement). Il est possible ainsi de les examiner a posteriori et de corriger le programme en consquence, pour le rendre de plus en plus robuste.
Chapitre 8
programme. Les programmeurs, pour leurs codes les plus sensibles, appliquent une politique de journaux dvnements, quils pourront utiliser pour rgler des problmes ou des litiges. Par exemple, toutes vos oprations bancaires sont stockes de cette manire. Les logiciels utiliss par les banques ont en place un systme de logs qui leur permet de suivre vos oprations. Ainsi, quand vous appelez pour demander des prcisions, ils peuvent savoir ce quil sest pass. Les logs sont importants partir du moment o les traitements sont sensibles. Mme sils ne le sont pas, il est quand mme bon davoir un tel systme, car il est gage de abilit et offre des possibilits de suivi de manire simple et efficace. La cration de ces journaux passe par lutilisation des classes Debug et Trace de la bibliothque de classes .NET. Il nest pas ncessaire de connatre les subtilits de la programmation objet pour pouvoir les utiliser. La programmation objet est traite au chapitre Passer au niveau suprieur. Ces classes existent dans lespace de noms Diagnostics. Cest pourquoi, pour pouvoir les utiliser sans avoir donner le chemin complet chaque fois, il faut ajouter Diagnostics lensemble des espaces de noms du projet. Ce faisant, vous aurez galement accs aux autres classes utilises pour la cration des journaux. Insrez donc cette ligne au dbut du projet :
Using System.Diagnostics
Write : permet dcrire un texte sans condition spciale. WriteLine : crit un texte et termine celui-ci par un retour la
Chapitre 8
j j
avoir passer par le mcanisme de Flush que nous expliquerons un peu plus loin. WriteIf : crit un texte seulement si une certaine condition boolenne est vrie. WriteIfLine : crit un texte si la condition boolenne passe en paramtre est vraie. Comme WriteLine, cette fonction permet dcrire effectivement le texte sans passer par le Flush. Assert : crit un message si une certaine condition boolenne est fausse. De plus, le message en question apparat dans une bote de dialogue. Fail : crit un message et laffiche dans une bote de dialogue. Cette fonction est utilise dans les cas dchec et derreur exclusivement.
Voici maintenant comment les utiliser (on considre que les variables du programme prcdent existent) :
j
On crit que lopration est impossible si le diviseur est gal zro. On ajoute galement un retour la ligne :
Trace.WriteIfLine(diviseur == 0, "Opration impossible : diviseur nul")
Chapitre 8
j
Il y a eu un chec. On donne lexplication et on linscrit. Par exemple, si les oprandes ne sont pas des nombres :
Trace.Fail("Les oprateurs de lopration ne sont pas valides")
Ces oprations permettent dcrire les messages dans les journaux, de manire garder des traces du programme. Il est recommand dutiliser les mthodes qui intgrent les retours la ligne, telles WriteLine et WriteIfLine, pour ne pas avoir se proccuper du problme du Flush. La plus importante est WriteLine. En effet, vous pouvez grer les conditions vous-mme :
If (diviseur == 0) Trace.WriteLine("Lopration ne peut tre faite _ car le diviseur est nul")
Le fait dafficher une bote de dialogue avec Assert ou Fail peut tre intressant pour la comprhension. Mais de la mme manire, vous pouvez grer la condition vous-mme. Ce qui suit est quivalent lcriture prcdente. Cependant, une bote de dialogue vous prviendra de ce quil sest pass.
If (diviseur == 0) Trace.Fail("Lopration ne peut tre faite car le diviseur est nul")
Vous connaissez prsent les mthodes qui permettent dcrire les journaux dvnements. Il faut maintenant voir o elles vont les crire. Cest l quapparat la notion dcouteur, cest--dire la cible dcriture des logs.
Les couteurs
Les fonctions vues prcdemment permettent dcrire les informations que vous voulez concernant le droulement du programme. La question est maintenant de savoir o crire ces traces. Cest en fait dans ce que lon appelle des couteurs quelles seront crites. Il y a trois types dcouteurs :
j Lcouteur
par dfaut : pris en charge par la classe DefaultTraceListener, il permet dcrire dans la console.
Cela vous intresse moyennement, car cest quivalent un simple affichage, comme le font les fonctions de la classe Console. Vous perdez une grande partie de lintrt des journaux de traces.
Chapitre 8
cest lune des possibilits les plus intressantes, et celle que nous allons traiter dailleurs. Elle est la fois, simple, pratique et efficace. Il faut pour cela utiliser la classe TextWriterTraceListener. Les journaux dvnements : nous avons par abus de langage utilis le terme "journaux dvnements" pour parler des traces de manire gnrale. Mais cette appellation est cense tre rserve aux traces dont lcouteur est un EventLogTraceListener. Cela permet de travailler avec un objet EventLog, dont les possibilits sont plus tendues quun simple chier texte. Mais dans le cadre de cet ouvrage, cela ne sera pas ncessaire. Le chier texte permet dj un grand nombre de possibilits et offre une stabilit importante.
Chapitre 8
Dans le cas de la cration de journaux, on peut utiliser la mthode Flush des classes Trace et Debug aprs avoir crit les informations dans le log :
Trace.Write("Message crire") Trace.Flush()
Bien que lon nait pas insr de retour la ligne, le message sera crit directement et le buffer sera vid, car on a explicitement fait appel la fonction Flush. Cette mthode est certes efficace, mais aussi contraignante, car elle oblige faire un appel la fonction Flush chaque fois que lon crit un message. Heureusement, les classes Debug et Trace ont un attribut boolen AutoFlush qui permet de raliser automatiquement lappel Flush aprs chaque criture. Il suffit de le dnir true pour que le Flush soit automatique et que les messages soient crits directement chaque fois.
Debug.AutoFlush = true Debug.Write("Message de Debug 1") Debug.Write("Message de Debug 2")
Attention, Write ncrit pas de caractres supplmentaires aprs le message, donc la sortie sera la suivante :
Message de Debug 1Message de Debug 2
Voila lessentiel du fonctionnement du Flush et des buffers. Vous comprenez maintenant lintrt dutiliser les fonctions comme WriteLine, et vous savez pourquoi certaines critures que vous commandez ne sont pas affiches tout de suite.
Si vous navez pas utilis du tout Trace ou si vous vous tes juste content dcrire des messages, il prendra lcouteur par dfaut. De ce fait, le message saffichera dans Visual Studio (dans la mesure o vous avez bien gr les Flush, mais ici vous faites un WriteLine, donc il ny a pas de problme).
Chapitre 8
1 Tout dabord, assurez-vous quun chier texte existe pour ces oprations. Vous pouvez soit en crer un, soit en ouvrir un qui existe dj et, ce moment-l, dcidez si vous prfrez lcraser ou y ajouter les nouveaux messages. 2 Ensuite, crez lcouteur correspondant. Il suffit dinstancier un objet TextWriterTraceListener dont la cible sera le chier texte prcdemment prpar. 3 Enn, dites aux classes Debug et Trace que lcouteur quelles doivent utiliser maintenant est le TextWriterTraceListener que vous venez de crer. Pour cela, ajoutez cet couteur la collection Listeners des classes Debug et Trace (qui reprsente leurs couteurs), grce la mthode Add.
Chapitre 8
Ouverture du chier texte. Il est cr sil nexiste pas. Sil existe, il est cras.
monLog = New("c:\Projet\monFichierLog.txt", System.IO .FileMode.OpenOrCreate)
Voici la mthode pour ajouter les messages un chier existant (faites lune ou lautre, mais pas les deux) :
monLog = New("c:\Projet\monFichierLog.txt", System.IO .FileMode.Append)
j
Une fois ces diverses oprations effectues, les traces de Debug et Trace seront marques dans le chier texte spci. Attention toutefois bien grer les Flush, car cela pourrait provoquer des parasites dans les logs. Nous ne verrons pas ici lcriture dans les vrais journaux dvnements avec les EventLog. Mais avec une bonne matrise de lcriture de messages dinformation dans des chiers texte, vous serez dj en mesure damliorer grandement la qualit et la stabilit de vos applications. Lutilisation de tels chiers texte dans des applications sensibles ou des projets mondialement connus montre que cest un systme largement utilis, car efficace. Il ne tient maintenant qu vous de les remplir dinformations pertinentes. Date, valeur des variables, utilisateur qui a provoqu lopration, poste de travail, les possibilits ne manquent pas. vous de voir celles qui vous seront les plus utiles.
Ne pas se perdre
Chapitre 8
Lancez ensuite le programme en faisant appel cette procdure travers un bouton ou nimporte quel autre contrle. Vous remarquerez que la seule ligne tre excute par le programme est celle du milieu ; les autres sont ignores et ne servent que de repre au dveloppeur. Elles se distinguent par leur couleur verte dans lditeur de code de Visual Basic.
Chapitre 9
Avec les acquis des chapitres prcdents, vous tes en mesure de crer un grand nombre dapplications et daffter vos talents de programmeur. Cest en forgeant quon devient forgeron, et cest par beaucoup de pratique que vous allez progresser et comprendre les subtilits de la programmation. Cependant, il est important dtoffer votre bagage thorique. Dans ce chapitre, vous allez voir des concepts un peu plus avancs, que vous avez peut-tre utiliss sans le savoir. Jusqu prsent, vous avez manipul des objets, des classes, sans forcment savoir ce que cela reprsentait rellement, ou pourquoi il fallait les utiliser de telle ou telle manire. Dans ce chapitre, nous expliquerons les principes de la programmation oriente objet, ainsi que les possibilits quelle offre en termes de programmation, de comprhension ou de scurit. Ensuite, nous examinerons la vie des donnes. Quand apparaissent-elles, o sont-elles stockes, quand disparaissent-elles ? Le fait de manipuler les objets et tous les mcanismes qui sy rapportent permet de les structurer de manire intelligente pour former des morceaux de programme dont les fonctionnalits sont intressantes. Ce sont les modles de conception, ou encore design patterns. Au cours de ce chapitre, vous en dcouvrirez quelques-uns et en implmenterez. La bonne qualit dun programme passe aussi par les habitudes du programmeur. Jusquici, vous avez utilis implicitement certaines conventions. Mais il est important de bien les dcrire, pour que vous les utilisiez correctement, et surtout, en sachant pourquoi. Cest ce que nous exposerons la n de ce chapitre.
Chapitre 9
Une question demeure : quest-ce quun objet ? vrai dire, la relle question se poser est : quest ce quune classe ? Une classe est un modle dobjet. Cette rponse nest pas fausse. Mais si lon utilise les classes pour dnir les objets et que, pour dnir les objets, on utilise les classes, on tourne en rond. En ralit, une classe est un concept, cest--dire lensemble des lments qui vont dnir quelque chose de concret. Prenons un exemple, utilis dans le monde de linformatique pour dcrire ce que sont les objets et les classes : un vhicule. Comment dcrire un vhicule ? Par son nombre de roues, son moteur, sa marque, son modle, son anne de mise en circulation, sa puissance, le type mine. Les possibilits sont nombreuses. Une classe est le regroupement de tous les lments qui dcrivent une voiture. Cest un peu comme le tableau des caractristiques techniques, ceci prs que celui-ci serait vide. Il ny aurait que les lignes avec les diffrents critres. Lobjet est le vhicule concret. Le vtre, celui du voisin, celui gar devant votre portail et qui vous bouche la sortie. Ils ont chacun leurs caractristiques. Si lon reprend lanalogie avec le tableau des caractristiques techniques dun vhicule, un objet correspondrait une colonne dans laquelle gureraient les valeurs des critres (les lments de la classe) qui dcrivent ce vhicule. En programmation, les objets peuvent tre des exceptions, des connexions des bases de donnes, des boutons, des formulaires, etc. Il sagit de structures de programmation contenant les donnes et les traitements ncessaires leur fonctionnement, autrement appels "membres".
Chapitre 9
Chapitre 9
Mthode pour tuner le moteur Public Sub gonflerMoteur(ByVal cvGagnes As Integer) Me.puissance = Me.puissance + cvGagnes End Sub End Class
Remarquez la prsence des mots-cls Private et Public devant les attributs et les mthodes. Ils dnissent le degr dencapsulation du membre.
Encapsulation
Lencapsulation est lun des mcanismes de la programmation oriente objet. Ce principe permet de sparer dans le programme linterface et limplmentation. Par "interface", on entend ce qui est visible par le monde extrieur. Lobjet sera amen tre en relation avec dautres objets. Par exemple, un vhicule va tre en relation avec un conducteur ou avec un autre vhicule, avec une contravention. De cette manire, on garantit plus ou moins que, tant que cette interface nest pas modie, les interactions avec lextrieur restent valables. Limplmentation correspond ce quil se passe lintrieur, cest--dire le fonctionnement interne de lobjet. Celui-ci na pas besoin dtre connu de lextrieur pour permettre lobjet de bien fonctionner. Plus que cela, vous navez pas forcment envie que le reste du monde puisse accder vos secrets de fabrication. Cela est un peu imag, mais permet dexpliquer les concepts dinterface et dimplmentation. En ce qui concerne la voiture, linterface serait le fait quelle roule. Limplmentation serait le fonctionnement du moteur lintrieur. Pour faire rouler la voiture, on na pas besoin de savoir comment cela se passe en interne. De plus, les constructeurs nont pas intrt divulguer les secrets de construction de leurs moteurs. Pour le programme informatique, il en est de mme. Il y a plusieurs degrs dencapsulation, appels "modicateurs daccs" :
j Priv
: traduit par le mot-cl Private, ce modicateur empche tout lment qui ne fait pas partie de la classe en cours daccder au membre. Dun point de vue de la scurit, il est recommand
LE GUIDE COMPLET 167
Chapitre 9
de mettre tous les attributs en priv pour viter toute modication intempestive. Public : traduit par le mot-cl Public, ce modicateur autorise laccs au membre de nimporte o et par nimporte qui. En termes de scurit, il ne convient pas aux attributs, mais pour les mthodes, cest gnralement le modicateur daccs ad hoc. Protg : traduit par le mot-cl Protected, ce modicateur autorise les classes qui drivent de la classe en cours daccder au membre. Cela intervient lors de lhritage, qui est un autre mcanisme important de la programmation objet (nous y reviendrons plus loin). Interne : traduit par le mot-cl Friend, ce modicateur limite laccs au membre exclusivement aux types du mme assemblage. Lassemblage correspond en fait au programme. Son utilisation est subtile et nentre pas le cadre de cet ouvrage. Mais sachez quil existe. Interne protg : cumule les possibilits daccs de Friend et de Protected. Le membre est accessible soit aux types de lassemblage, soit aux classes qui hritent de la classe en cours.
Les modicateurs les plus importants et les plus utiles sont Public et Private. Il sera question de Protected lorsque nous aborderons lhritage. Voyons un peu les diffrences entre les attributs Public et Private et comment en tirer le meilleur parti. Voici deux classes et quelques membres :
Class Voiture Attribut anne de mise en circulation Public anneeCirculation As Integer End Class Class Personne Tentative de modification de lanne de mise en circulation Public Sub frauderVoiture(laVoiture As Voiture) laVoiture.anneeCirculation = laVoiture.anneeCirculation + 5 End Sub End Class
La mthode frauderVoiture traduit lintention dune personne daugmenter lanne de mise en circulation du vhicule pour simuler le fait que celui-ci est plus rcent. Dun point de la programmation, il ny pas derreur : le programme se compilera et sexcutera sans souci. Il
Chapitre 9
sera alors possible de modier la date de mise en circulation dune voiture sans problme. Pas trs scurisant nest-ce pas ? Cest pourquoi il est recommand, dans la mesure du possible, de dnir les attributs comme privs, de manire que lextrieur ne puisse pas provoquer de comportement non autoriss. Essayons de remdier ce problme :
Class Voiture Marque et modle Private marque As String Attribut anne de mise en circulation Private anneeCirculation As Integer End Class Class Personne Tentative de modification de lanne de mise en circulation Public Sub frauderVoiture(laVoiture As Voiture) laVoiture.anneeCirculation = laVoiture.anneeCirculation + 5 End Sub Passer une annonce de vente Public Sub vendreVoiture(laVoiture As Voiture) Dim texteAnnonce As String texteAnnonce = "Vends voiture " & laVoiture.marque texteAnnonce = texteAnnonce & " immatricule en " texteAnnonce = texteAnnonce & Voiture.anneeCirculation MessageBox.Show(textAnnonce) End Sub End Class
Le problme prcdent est rgl. La mthode frauderVoiture ne peut plus fonctionner, car elle na plus accs au membre anneeCirculation, celui-ci tant maintenant priv. Cela provoquera une erreur la compilation. On ne peut accder au membre car celui-ci est priv.
Chapitre 9
La fonction vendreVoiture pose un autre problme. En effet, il est impossible de construire le texte de lannonce, tant donn que la personne na pas accs la marque de la voiture ni lanne de mise en circulation. Les attributs ne sont plus du tout visibles de lextrieur, et perdent alors leur intrt. Pour remdier ce problme, on utilise des mthodes publiques, qui manipulent les donnes et qui sont accessibles de lextrieur. De cette manire, laccs aux attributs est permis, mais vous gardez un contrle sur ce que peut faire lextrieur.
Class Voiture Marque et mthode daccs Private marque As String Public Function getMarque() As String getMarque = Me.marque End Function Attribut anne de mise en circulation Private anneeCirculation As Integer Mthode pour accder la date de mise en circulation Public Function getAnneeCircu() As Integer getAnneeCircu = Me.anneeCircu End Function End Class Class Personne Tentative de modification de lanne de mise en circulation Public Sub frauderVoiture(laVoiture As Voiture) laVoiture.anneeCirculation = laVoiture.anneeCirculation + 5 End Sub Passer une annonce de vente Public Sub vendreVoiture(laVoiture As Voiture) Dim texteAnnonce As String texteAnnonce = "Vends voiture " & laVoiture.getMarque() texteAnnonce = texteAnnonce & " immatricule en " texteAnnonce = texteAnnonce & laVoiture.getAnneeCircu() MessageBox.Show(textAnnonce) End Sub End Class
Ainsi, les attributs sont bien protgs car ils sont privs. Cependant, on peut les utiliser quand mme grce aux mthodes getMarque et getAnneeCircu. Ces deux mthodes publiques correspondent linterface de la classe Voiture, et le reste son implmentation.
Chapitre 9
Chapitre 9
Pour changer les valeurs des attributs, il faut faire comme suit :
maVoiture.setAnneeCircu(2002) maVoiture.setMarque("LAMARQUETROPBIEN")
Grce aux accesseurs, vous pouvez manipuler vos attributs avec un maximum de scurit, tout en les laissant privs pour quils ne soient pas directement manipulables de lextrieur. Les proprits permettent dautomatiser ce principe sans passer par des mthodes spciques. Elles permettent de manipuler les attributs, comme les accesseurs, sauf que pour lextrieur, elles apparaissent comme des attributs (attributs lextrieur, mthodes lintrieur). Les proprits combinent la simplicit de lutilisation directe des attributs, et la scurit des mthodes, tout en laissant les attributs privs. Pour illustrer les proprits, remplaons les accesseurs de la marque de la voiture par un quivalent avec une proprit :
Class Voiture Marque et mthode daccs Private __marque As String Proprit pour grer la marque Public Property Marque() As String Accesseur de lecture Get Return Me.__marque End Get Accesseur dcriture Set(ByVal Value As String) Me.__marque = Value End Set End Property [] End Class
Dtaillons ce bout de code. La dnition de la proprit se fait entre Public Property et End Property. Il faut quune proprit soit publique. Sinon on ne peut pas y accder, ce qui na aucun intrt. Remarquez que lon a ajout __ devant le nom de lattribut. En effet, il ne faut pas que celui-ci ait le mme nom que la proprit. Par convention, on donne la proprit le nom le plus explicite, tant donn que cest elle qui sera accessible de lextrieur, et lon marque le nom de lattribut par des caractres (gnralement des underscores _) au dbut ou la n.
Chapitre 9
Dans la proprit, on dnit les accesseurs. Ils ont le mme rle que les mthodes vues prcdemment, getMarque et setMarque. Leur dnition se fait entre Get et End Get pour laccesseur en lecture, et entre Set et End Set pour laccesseur en criture. Le Set a un paramtre. Son utilisation se fait sous la forme dune affectation, cest--dire une instruction de la forme a = b. Le paramtre Value correspond en fait llment droite du gal (=), la nouvelle valeur. Il est possible de dnir des proprits en lecture seule ou en criture seule. Pour la lecture seule, il faut spcier ReadOnly sur lattribut et la proprit, et ncrire que laccesseur Get. Pour lcriture seule, il faut marquer lattribut et la proprit comme WriteOnly, et ncrire que laccesseur Set.
Class Voiture Marque et mthode daccs Private ReadOnly __marque As String Proprit en lecture seule pour obtenir la marque Public Property ReadOnly Marque() As String Accesseur de lecture Get Return Me.__marque End Get Pas daccesseur en criture End Property Attribut de puissance, criture seule Private WriteOnly __puissance As Integer Proprit pour la puissance, criture seule Public WriteOnly Property Puissance() As Integer Pas daccesseur en lecture Accesseur en criture Set(ByVal Value As Integer) Me.__puissance = Value End Set End Property End Class
Le passage en criture ou lecture simple est simple. Ainsi, lutilisation des proprits permet de combiner lintrt de passer par des mthodes, cest--dire de pouvoir approfondir le traitement, tout en gardant une simplicit dutilisation. En effet, les proprits sutilisent comme des champs :
MessageBox.Show("Je possde une : " & maVoiture.Marque) maVoiture.Puissance = 150 MessageBox.Show("Jai tent lamlioration _ de ma voiture 150 CV")
Chapitre 9
La plupart des mcanismes qui ont t expliqus jusque-l concernent les objets, cest--dire des instances des classes que vous avez dnies. Cependant, certains lments sont parfois communs toutes les instances des classes. Cest pourquoi il est possible de les dnir au niveau de la classe, et non plus de lobjet. Ce sera le sujet de la section suivante.
On est oblig de spcier pour chacune des voitures quelle a quatre roues :
Chapitre 9
Cela est rptitif pour une information que lon va retrouver tout le temps. Imaginez si le nombre de voitures est particulirement grand. On ne sen sort plus. Il est plus judicieux alors de dnir le nombre de roues comme un membre partag par tous les objets de cette classe. Pour cela, on utilise le mot-cl Shared.
Public Class Voiture Public Shared nbreRoue As Integer = 4 End Class
De cette manire, on sait davance que toutes les voitures qui vont tre cres auront un nombre de roues gal quatre. Le fait que ce soit un membre partag nimpose plus lexistence dun objet.
Chapitre 9
Maintenant ce nest plus ncessaire. On peut accder au membre concern tout simplement en appelant la classe.
MessageBox.Show("Une voiture a " & _ Voiture.nbreRoue & " roues.")
Il nest plus ncessaire de donner linformation pour chacune des voitures pour obtenir le mme rsultat. De plus, si les voitures taient un jour dotes de six roues au lieu de quatre, il ne serait pas ncessaire dappliquer une modication toutes les voitures existantes. Il suffirait de changer le membre partag et la modication affecterait lensemble des voitures existantes :
176 LE GUIDE COMPLET
Chapitre 9
Attention, on ne peut pas accder un membre partag dans un contexte non partag, et vice versa.
Public Class Voiture Public Shared nbreRoue As Integer = 4 Public marque As String End Class
On provoquerait une erreur en voulant accder un membre non partag en passant par la classe :
Voiture.marque = "LAMARQUETROPBIEN"
Le compilateur le signalerait.
partag
partag
LE GUIDE COMPLET 177
Chapitre 9
Lorsque lon dcrit une classe, il y a toujours des lments qui sont particuliers un objet donn et dautres qui valent pour tous. Ce principe, intressant et pratique, nest pas difficile matriser. Il faut juste avoir les ides claires sur ce qui est partag par tous, et ce qui est spcique. Ensuite, ce nest quune question dhabitude.
Ces deux fonctions ont le mme nom. De plus, elles travaillent sur les mmes types de variables, savoir des entiers. Cependant, elles nont pas la mme signature. En effet, lune a deux paramtres entiers, alors que lautre nen a quun seul. Leur signature est diffrente. Le compilateur et le programme sauront faire la diffrence lorsquun appel sera fait la premire ou la deuxime mthode.
Appel la premire fonction afficheAddition(3, 4) Appel la deuxime fonction afficheAddition(6)
Chapitre 9
Lorsque vous appelez vos fonctions, le programme analyse le nombre mais galement le type des paramtres que vous utilisez. partir de l, il vrie sil connat des fonctions dont la signature correspond, et il peut alors les excuter. Nous avons donn un exemple par rapport au nombre de paramtres. Leur type est tout aussi important :
Public Sub afficheAddition(ByVal nbre1 As Integer, ByVal nbre2 As Integer) MessageBox.Show(nbre1 + nbre2) End Sub Public Sub afficheAddition(ByVal nbre1 As Double, ByVal nbre2 As Double) MessageBox.Show(nbre1 + 3) End Sub
Vous avez ici les deux mmes fonctions, sauf que lune travaille sur des entiers, et lautre sur des nombres dcimaux. Le programme saura galement faire la distinction selon les types des paramtres.
Appel la deuxime fonction afficheAddition(4.25, 14.3685) Appel la premire fonction afficheAddition(47, 857)
Chapitre 9
En ce qui concerne lcriture, les mthodes surcharges sont tout simplement des mthodes et elles respectent les mmes rgles. Vous crivez la classe normalement, avec ses attributs et ses mthodes, sauf quil y aura des moments o certaines auront le mme nom :
Public Class Additionneur Private retenue As Integer Private Function effectueAddition(ByVal nb1 As Integer, _ ByVal nb2 As Integer) As Integer effectueAddition = nb1 + nb2 End Function Private Function effectueAddition(ByVal nb1 As Double, _ ByVal nb2 As Double) As Double effectueAddition = nb1 + nb2 End Function End Class
Le polymorphisme
Dans la programmation oriente objet, le polymorphisme est sans conteste le mcanisme le plus subtil. Cest galement le plus puissant. Il permet de donner au programme une cohrence et une souplesse, et ce de manire propre et intelligente. Le polymorphisme permet de mettre en relation des classes diffrentes, de manire quelles puissent interagir entre elles, tout en garantissant que les oprations effectues ont un sens et quelles ne vont pas provoquer des rsultats impossibles ou totalement absurdes. Il existe deux types de polymorphismes :
j Le polymorphisme dinterface
: une interface est un contrat de comportement. Elle prsente un ensemble de membres quune classe devra dnir et implmenter pour pouvoir tre utilis dans ce cadre spcique. Par exemple, une interface Transporteur spciera que pour pouvoir tre utilis comme un vhicule transporteur, un vhicule devra implmenter des mthodes de prise de passagers, de desserte de passagers, et de transfert dun
Chapitre 9
point un autre. Le vhicule qui devra tre considr comme un transporteur inclura dans son implmentation lensemble de ces comportements. Il aura alors accs aux diffrents membres qui concernent les transporteurs. Le polymorphisme dhritage : lhritage donne une classe un certain nombre de fonctionnalits provenant dune autre classe. On dit alors que la premire est une sous-classe de la deuxime, une classe hrite. Elle peut alors utiliser les membres de la classe dorigine sans avoir les rimplmenter ni les rcrire. Vous avez l un cas de spcialisation. Par exemple, considrez une classe Losange. Une classe Carre pourrait hriter de Losange, car cest une spcialisation de celle-ci. En effet, un carr est un losange, sauf quil possde quatre angles droits. Il ny aurait alors pas rednir les quatre cts dun carr, tant donn quils existent dans un losange.
Le polymorphisme dinterface
Comme nous lavons dit, une interface est un contrat de comportement. Cest en quelque sorte une garantie que si une classe implmente comme il faut cette interface, elle aura le comportement adquat lorsquon lutilisera dans les bonnes conditions. Une interface se contente de donner la liste des membres implmenter. Elle nimpose aucune contrainte sur la manire dont est faite cette implmentation. De plus, il ny a pas de limite au nombre de classes qui limplmente. Linterface dnit juste un comportement. Elle nagit pas elle-mme. Elle permet juste de mettre en relation diffrents lments. Il peut y avoir plusieurs classes qui implmentent une interface, une seule, voire aucune. En revanche, il ny a pas de limite au nombre dinterfaces quune classe implmente. Par exemple, un bateau peut avoir la fois un comportement de transporteur de passagers et un comportement de vhicule de course sil est puissant et lger. Il y a trois grandes tapes dans lutilisation dun polymorphisme dinterface :
Chapitre 9
j
j j
Tout dabord, il faut dnir linterface, cest--dire lensemble des membres que devront implmenter les classes pour tre considr en tant que tel. Ensuite, il faut implmenter ces membres dans les classes correspondantes. Ds lors, on peut utiliser linterface comme un intermdiaire entre les diffrents membres mettre en relation, sans se soucier de limplmentation. En effet, tant donn quils implmentent bien linterface en question, on peut tre sr de leur comportement.
La premire partie nest pas importante. Elle dnit simplement une personne reprsentant le passager que le vhicule devra transporter. Ensuite, linterface ITransporteur est dnie. Maintenant, pour quun vhicule soit considr comme un transporteur potentiel de passagers, il faudra que la classe implmente une mthode
182 LE GUIDE COMPLET
Chapitre 9
prendPassager, ayant pour paramtre une personne, une mthode deposePassager, avec le mme paramtre, et enn une mthode allerVers dont le paramtre est une chane de caractres reprsentant
la ville de destination. Cette partie est la plus simple dans lutilisation du polymorphisme dinterface. Voyons maintenant ce quil faut faire au niveau des classes qui veulent limplmenter.
Vous avez limplmentation de deux classes de vhicules, ayant chacune leurs spcicits. En effet, lavion doit grer son altitude, contrairement au bateau qui ne bouge pas en hauteur. Au niveau du bateau, on dit quil navigue, alors que lavion change de cap. Pour linstant, aucune dentre elles nimplmente linterface dnie prcdemment et aucune nest donc en mesure dtre en relation avec des lments relatifs aux transporteurs de personnes.
Chapitre 9
Limplmentation de linterface se passe en deux tapes : j Dabord, on prcise que la classe implmente linterface. j Puis, il faut crer une implmentation de chaque membre de linterface dans la classe. La partie relative linterface elle-mme est simple. Il suffit dutiliser le mot-cl Implements avec le nom de linterface :
Public Class Avion Implements ITransporteur Private altitude As Integer Private destination As String Public Sub decoller() Me.altitude = 10000 End Sub Public Sub atterrir() Me.altitude = 0 End Sub Public Sub changerCap(ByVal ville As String) Me.destination = ville End Sub End Class Public Class Bateau Implements ITransporteur Private destination As String Public Sub naviguer(ByVal ville As String) Me.destination = ville End Sub End Class
Si la classe implmente plusieurs interfaces, celles-ci sont spares par des virgules (on considre que les autres interfaces existent, mme si lon ne les utilise pas ici).
Public Class Avion Implements Itransporteur, IObjetVolant Private altitude As Integer [] End Class Public Class Bateau Implements Itransporteur, IObjetFlottant Private destination As String [] End Class
Chapitre 9
Maintenant que vous avez spci que les classes devaient implmenter linterface ITransporteur, il faut implmenter chacun des membres, savoir les mthodes prendsPassager, deposePassager, allerVers. Pour cela, on utilise galement le mot-cl Implements, et lon prcise quel membre de linterface le membre cr implmente. part cela, il sagit dune mthode classique. Attention, pour garantir un bon comportement, il peut tre ncessaire de modier le comportement du reste de la classe. Ici, on ajoutera un attribut passager de type Personne pour garder un comportement valable.
Public Class Avion Implements ITransporteur Private passagerABord As Personne Private altitude As Integer Private destination As String Public Sub decoller() Me.altitude = 10000 End Sub Public Sub atterrir() Me.altitude = 0 End Sub Public Sub changerCap(ByVal ville As String) Me.destination = ville End Sub Public Sub prendsPassager(passager As Personne) _ Implements ITransporteur.prendsPassager Me. passagerABord = passager End Sub Public Sub deposePassager(passager As Personne) _ Implements ITransporteur. deposePassager If (Me.passagerABord.nom = passager.nom) Me.passagerABord = "" EndIf End Sub Public Sub allerVers(ByVal ville As String) _ Implements ITransporteur.allerVers Me.decoller() Me.changerCap(ville) Me.atterrir() End Sub End Class
Chapitre 9
Public Class Bateau Implements Itransporteur Private passagerABord As Personne Private destination As String Public Sub naviguer(ByVal ville As String) Me.destination = ville End Sub Public Sub prendsPassager(passager As Personne) _ Implements ITransporteur.prendsPassager Me. passagerABord = passager End Sub Public Sub deposePassager(passager As Personne) _ Implements ITransporteur. deposePassager If (Me.passagerABord.nom = passager.nom) Me.passagerABord = "" EndIf End Sub Public Sub allerVers(ByVal ville As String) _ Implements ITransporteur.allerVers Me.naviguer(ville) End Sub End Class
Maintenant, les deux classes Bateau et Avion implmentent totalement linterface ITransporteur. Les implmentations se ressemblent. En ce qui concerne le passager, le code est identique. Concernant le transport vers la destination, la diffrence est que lavion doit dcoller et atterrir. Cela na pas dimportance. Comme nous lavons prcis, linterface force juste un comportement et nimpose aucune contrainte sur sa "ralisation". Les ralisations auraient pu tre identiques ou diffrentes, cela ne remet pas en question le fait que maintenant, Avion et Bateau sont considrs comme des ITransporteur.
Chapitre 9
tant donn que lon connat le comportement de toute classe qui implmente linterface ITransporteur, on peut utiliser cela pour dnir la fonction voyage :
Public Sub voyage(voyageur As Personne, _ ByVal transport As ITransporteur, _ ByVal ville As String) Transport.prendsPassager(voyageur) Transport.allerVers(ville) Transport.deposePassager(voyageur) End Sub
Pour pouvoir utiliser Avion et Bateau en tant que ITransporteur, il y a une petite opration supplmentaire raliser. Il faut convertir explicitement les objets en ITransporteur. Pour faire cela, on utilise la fonction de conversion CType :
Dim monAvion As New Avion() Dim monBateau As New Bateau() Dim monAvionTransporteur As ITransporteur Dim monBateauTransporteur As ITransporteur monBateauTransporteur = CType(ITransporteur, monBateau) monAvionTransporteur = CType(ITransporteur, monAvion)
Vous avez accompli toutes les tapes pour pouvoir utiliser Avion et Bateau comme des transporteurs de personnes. Maman veut aller New York en avion :
Dim maman As Personne() Dim monAvion As Avion() Dim transporteur As ITransporteur Dim ville As String ville = "New York" maman.nom = "Maman" transporteur = CType(ITransporteur, monAvion) voyage(maman, transporteur, ville)
Chapitre 9
Seules deux lignes ont t modies, et pourtant le moyen a totalement chang. Vous avez modi deux appels, tout en garantissant une cohrence et une abilit des oprations effectues. Cet exemple montre lintrt du polymorphisme dinterface. Cest un mcanisme subtil et bien pratique une fois matris.
Le polymorphisme dhritage
Le polymorphisme dhritage est le deuxime type de polymorphisme. Il permet de donner une classe certaines caractristiques et fonctionnalits dune classe existante. En quelque sorte, lhritage permet de spcialiser une classe de base. La classe spcialise est dite "drive" ou "tendue", ou encore appele "classe fille". La classe de base est dite "tendue", ou encore appele "classe mre". Par exemple, prenons une classe de base Avion. Un exemple dhritage possible serait une classe AvionDeLigne ou encore AvionDeChasse, qui possderaient les caractristiques dun avion, mais qui auraient leurs propres spcicits, par exemple une liste de passagers pour lavion de ligne, et une liste dquipements militaires pour lavion de chasse. Nous utiliserons cet exemple pour illustrer ce mcanisme important de la programmation oriente objet. Pour indiquer quune classe drive dun autre classe, il suffit dutiliser le mot-cl Inherits, suivi de la classe de base :
Public Class Avion Nous ne remplissons pas le contenu Nous le ferons au fur et mesure de la dcouverte de lhritage End Class Public Class AvionDeChasse Inherits Avion End Class
De cette manire, vous avez fait de la classe AvionDeChasse une spcialisation de la classe Avion. Contrairement au polymorphisme dinterface, o une classe pouvait implmenter plusieurs interfaces, une
Chapitre 9
classe ne peut driver que dune seule classe de base. Lorsque les deux types de polymorphismes sont utiliss, il faut dabord crire lhritage :
Public Class AvionDeChasse Inherits Avion Impliments ISupersonic End Class
Il est possible dindiquer quune classe nest pas drivable quand lhritage napporte aucune information supplmentaire pertinente. Driver une classe Cloture prsente peu dintrt : si vous avez des cltures en bois ou des haies, vous pouvez le prciser dans la classe Cloture par un attribut de type numration par exemple. Les fonctionnalits dune clture ne changent pas pour autant. Pour empcher la drivation, on utilise le mot-cl NotInheritable :
Public NotInheritable Class Cloture Il nest pas ncessaire de dtailler cette classe End Class Public Class ClotureHaie Inherits Cloture End Class
La classe Cloture ntant pas drivable, ClotureHaie ne pourra pas en hriter. Toute tentative de drivation provoquera une erreur.
Vous avez vu comment grer les hritages au niveau des classes, mais cela ne suffit pas. Il faut aussi le faire au niveau des membres.
Chapitre 9
Cela provoquera une erreur car, lattribut avionDeBase tant Private, il nest pas accessible dans la classe AvionDeChasse, mme si celle-ci drive de la classe Avion.
Lorsquil a t question de lencapsulation, nous avons parl du modicateur daccs Protected. Il permet de limiter laccs un membre exclusivement ses classes lles. Cest typiquement le modicateur daccs utilis dans les cas dhritage. Il permet de conserver laspect scuritaire en vitant un accs public. Grce lui, les
Chapitre 9
classes lles peuvent bncier de la fonctionnalit correspondante. Dans le code prcdent, lattribut nbreAilerons est Public, ce qui est dconseill.
Public Class Avion Protected vitesseMax As Integer Protected nbreAilerons As Integer Protected reserveKerozene As Integer Public Sub vitesseMaximum() Me.vitesseMax = 1000 MessageBox.Show(Me.vitesseMaximum) End End Class Public Class AvionDeChasse Inherits Avion Public Sub afficheMesMembresHerites MessageBox.Show(Me.nbreAilerons) MessageBox.Show(Me.vitesseMaximum) MessageBox.Show(Me.reserveKerozene) End Sub End Class
Les membres reserveKerozene et nbreAilerons tant maintenant protgs, la classe AvionDeChasse peut les utiliser directement. Il ny a alors plus derreur sur la mthode afficheMesMembresHerites. La fonction vitesseMaximum pousse lavion sa vitesse maximale. Comme elle est Public, AvionDeChasse en hrite et on peut lappeler :
Dim monChasseur As New AvionDeChasse monChasseur.vitesseMaximum()
Cela ne pose pas de problme en termes de programmation. Le compilateur ne dtecte pas derreur. lexcution, lattribut vitesseMax a une valeur de 1 000 et laffiche dans une bote de dialogue. Cest au niveau du sens quil y a un problme. Bien qutant un avion, un chasseur a une vitesse maximale bien suprieure celle dun avion de base, dun avion de ligne ou dun planeur. De plus, pour pouvoir atteindre celle-ci, lavion de chasse doit activer le mcanisme de post-combustion. Cest pourquoi limplmentation de la vitesse maximale dans la classe de base ne convient plus du tout pour la classe drive. Il faut donc la remplacer.
Chapitre 9
Pour cela, il faut dabord spcier dans la classe de base que ce membre est rednissable. On utilise en ce sens le mot-cl Overridable. Puis dans la classe drive, il faut rednir et rimplmenter cette mthode. Il faut prciser que la nouvelle mthode est une rednition de celle qui existait dans la classe de base. Cela se fait grce au mot-cl Overrides.
Public Class Avion Protected vitesseMax As Integer Protected nbreAilerons As Integer Protected reserveKerozene As Integer On dfinit cette mthode comme Overridable On pourra alors la redfinir dans les classes filles Public Overridable Sub vitesseMaximum() Me.vitesseMax = 1000 MessageBox.Show(Me.vitesseMaximum) End End Class Public Class AvionDeChasse Inherits Avion Activation de la post-combustion Public Sub postCombustion() Limplmentation nest pas ncessaire pour la comprhension End Sub Redfinition de la mthode vitesseMaximum Qui est une mthode Overridable de la classe de base Public Overrides Sub vitesseMaximum() Me.postCombustion() Me.vitesseMax = 2000 MessageBox.Show(Me.vitesseMax) End Sub Public Sub afficheMesMembresHerites MessageBox.Show(Me.nbreAilerons) MessageBox.Show(Me.vitesseMaximum) MessageBox.Show(Me.reserveKerozene) End Sub End Class
Cela vous permet de rednir un comportement dans la mesure o celui-ci est quivalent, cest--dire si la mthode en question a la mme signature. Si par exemple, il fallait prciser un paramtre pour la post-combustion, il ne serait plus possible de rednir ainsi la mthode vitesseMaximum.
Chapitre 9
Dans ce cas, il est prfrable de masquer la mthode de la classe de base. De cette manire, on peut crire une mthode qui a le mme nom, mais dont la signature est diffrente. Ce principe se rapproche un peu de la surcharge, mais il intervient entre des classes mres et des classes lles, et non pas sur une unique classe. Du ct de la classe mre, rien de ne change. On ne peut masquer que des mthodes Overridable. Cependant, au niveau de la classe lle, on utilisera le mot-cl Shadows, puis lon pourra rednir normalement la mthode, avec ventuellement une nouvelle signature, une valeur de retour diffrente, etc.
Public Class Avion Protected vitesseMax As Integer Protected nbreAilerons As Integer Protected reserveKerozene As Integer La mthode vitesseMaximum, redfinissable Public Overridable Sub vitesseMaximum() Me.vitesseMax = 1000 MessageBox.Show(Me.vitesseMaximum) End End Class Public Class AvionDeChasse Inherits Avion Activation de la post-combustion Public Sub postCombustion(ByVal force As Integer) Limplmentation nest pas ncessaire pour la comprhension End Sub Masquage de la mthode vitesseMaximum La signature est diffrente de celle de la classe mre Il y a un paramtre Public Shadows Sub vitesseMaximum(ByVal force As Integer) Me.postCombustion(force) Me.vitesseMax = 2000 MessageBox.Show(Me.vitesseMax) End Sub [] End Class
Bien que cela vous permette de vous adapter au fonctionnement des diffrentes classes, il y a un risque de problme :
Dim monAvion As New Avion() Dim monChasseur As New AvionDeChasse() monAvion.vitesseMaximum() monChasseur.vitesseMaximum()
Chapitre 9
Cela provoquera une erreur, car la fonction de base tant masque par la nouvelle, vitesseMaximum sans paramtre nexiste pas pour la classe AvionDeChasse.
Il faut donc faire attention lorsque vous utilisez des mthodes masques, car ce qui tait valable un moment ne lest plus du tout un autre. Le fait de masquer ou de rednir une mthode rednissable vous donne accs deux implmentations de cette mthode. Celle qui est utilise est gnralement celle de la classe lle, la plus basse dans la hirarchie. Cependant, vous pouvez accder limplmentation de la classe mre. Le mot-cl MyBase est une rfrence la classe mre et permet dappeler les membres de la classe de base :
Public Class AvionDeChasse Inherits Avion [] Public Sub vitesseMaximumMere() MyBase.vitesseMaximum() End Sub End Class
La
mthode vitesseMaximumMere excutera la mthode vitesseMaximum dans la classe de base, cest--dire quelle dnira lattribut vitesseMax 1 000 et laffichera dans une bote de dialogue.
Labstraction
Selon les composants que vous avez dcrire et que vous devez reprsenter, vous pouvez avoir besoin dune classe de base qui dcrit
Chapitre 9
une multitude de caractristiques communes, sans quun objet de cette classe puisse exister. Cela veut dire quune spcialisation est obligatoire. Prenons les avions par exemple. La classe de base dcrirait quun avion a des ailes, une vitesse maximale, un poids, une longueur, etc. Cependant, on peut considrer le concept davion trop gnral et avoir envie de forcer lutilisation dune spcialisation pour dnir les avions de chasse, les planeurs, les avions de ligne. Ce mcanisme est labstraction. Il empche la cration dobjets dune classe de base et force donc la drivation. Lobjet driv est considr comme une lle, avec toutes les possibilits vues prcdemment. Pour quune classe soit abstraite, il faut utiliser le mot-cl MustInherit :
Public MustInherit Avion Limplmentation nest pas ncessaire pour la comprhension End Class
Vous ne pouvez pas crer un avion de base car la classe est abstraite, sous peine dobtenir une erreur.
Labstraction de la classe vous force donc spcialiser cette classe. Une fois cela fait, la classe lle aura accs aux membres de la classe de base, comme dans un hritage classique. Dans une classe abstraite, il est possible de dnir des membres abstraits. Cela se rapproche des interfaces. Dans les interfaces, il faut que la classe implmente lensemble des membres de linterface. Pour les membres abstraits, le principe est le mme. Pour quune classe
Chapitre 9
puisse driver dune classe abstraite qui possde des membres abstraits, elle doit implmenter chacun de ces membres. Dans la classe abstraite, cela se prcise par le mot-cl MustOverride :
Public MustInherit Avion Limplmentation nest pas ncessaire pour la comprhension Public MustOverride vitesseMaximum() End Class
Pour pouvoir hriter de la classe Avion, une classe devra fournir une implmentation de vitesseMaximum :
Public Class AvionDeChasse Inherits Avion Activation de la post-combustion Public Sub postCombustion(ByVal force As Integer) Limplmentation nest pas ncessaire pour la comprhension End Sub On omet de redfinir la mthode vitesseMaximum End Class
Comme ce nest pas le cas ici, lhritage ne pourra se faire et vous obtiendrez une erreur.
Figure 9.20 : Instanciation dune classe lle sans rednir les membres
abstraits
Comme pour les membres dune interface, lensemble des membres abstraits doivent avoir une implmentation dans la classe lle :
Public Class AvionDeChasse Inherits Avion Activation de la post-combustion Public Sub postCombustion() Limplmentation nest pas ncessaire pour la comprhension End Sub
Chapitre 9
Implmentation de la mthode abstraite de la classe Avion Public Override Sub vitesseMaximum() Me.postCombustion() Me.vitesseMax = 2000 MessageBox.Show(Me.vitesseMax) End Sub [] End Class
Maintenant AvionDeChasse peut driver de la classe Avion, qui est abstraite. De cette manire, AvionDeChasse bncie de toutes les caractristiques de la classe Avion. Mais le fait que celle-ci soit abstraite garantit quil ne peut y avoir que des objets complets en termes dinformations et de fonctionnalits. Vous venez de voir les grandes principes de la programmation oriente objet. Spcialement en Visual Basic .NET, la programmation oriente objet (POO, prononcer "pou") est la base de tout. Cest pourquoi il est important de bien la comprendre et de bien la matriser. Le tout est de sentraner et de pratiquer.
Chapitre 9
Dans ce bout de programme, la boucle devrait faire dix tours et afficher les valeurs de X entre 1 et 10, et dix fois Y = 0. Enn une bote de dialogue devrait afficher X = 10 et Y = 0. Or, ce bout de programme provoque une erreur.
En effet, lors de laffichage nal de Y, la variable nest plus accessible. tant dnie dans la boucle, Y nest accessible que dans cette boucle. Sa porte, cest--dire son accessibilit, est limite ladite boucle. On dit que Y est une variable locale de cette boucle. Les variables locales sont gres dans la pile. La pile est une zone mmoire ddie lutilisation des variables locales. On peut la symboliser comme une vraie pile, compose de plusieurs petits blocs de mmoire que sont les variables :
Chapitre 9
Dans cette pile, ce qui va marquer laccessibilit des variables est un petit marqueur :
Elment indfin i
Emplacement actuel du marqueur mmoire
Quand vous dclarez une variable, un emplacement mmoire va tre utilis, et ce marqueur va tre dplac :
Dim X As Integer
Le programme pourra alors accder aux parties de la mmoire qui sont au-dessus de ce marqueur. X vient dtre dclare, elle est au-dessus du marqueur, on peut lutiliser. Cependant, vous navez pas donn X de valeur initiale. Entre sa dclaration et lentre dans la boucle, on ne sait pas ce que vaut X. Lorsque lon dclare des variables, le marqueur se dplace vers le bas, donnant ainsi laccs de nouvelles variables. Or, ce marqueur se dplace aussi vers le haut, bloquant ainsi laccs danciennes variables. Il se dplace essentiellement vers le haut lorsque lon sort dun bloc. En Visual Basic, on peut dire que la n dun bloc correspond un endroit o il y a un End.
Chapitre 9
Examinons le programme prcdent. On dclare X tout dabord. Un accs lui est donn dans la pile et le marqueur descend donc.
Va riabl e et valeur
On entre dans un nouveau bloc, la boucle For. La position du marqueur est enregistre pour que lon puisse y revenir quand on sortira de ce bloc.
Dim Y As Integer
Ensuite, on dclare Y. Encore une fois, le marqueur descend et un emplacement mmoire est cr pour Y :
Les traitements sont faits avec cet environnement. Lenvironnement est lensemble des points accessibles partir de l o lon est. Ces points peuvent tre des fonctions, des mthodes, des variables, etc. Enn, on quitte la boucle For. On quitte donc un bloc et le marqueur remonte lendroit enregistr lorsque lon est entr dans cette boucle.
Chapitre 9
Va riabl e et valeur
Figure 9.26 : Pile mmoire, aprs retour dans lancien bloc
Lemplacement mmoire correspondant Y tant maintenant en dessous du marqueur, il nest plus dans lenvironnement courant et nest donc plus accessible. Bien que Y ne soit pas accessible, son emplacement mmoire existe encore, avec sa valeur, tant que ltat de la pile na pas chang. Lenvironnement change souvent : lentre ou la sortie dune fonction, lentre et la sortie dune structure de contrle. La mmoire est en constants mouvements. Dsormais, vous devriez mieux comprendre les concepts de porte et daccessibilit. Cest un sujet vaste et intressant. Nous vous invitons lapprofondir pour dcouvrir justement les subtilits que nous nexposons pas ici.
Chapitre 9
Le tas manag est un gros espace de mmoire rserv au programme. Celuici pourra y stocker tous les objets ncessaires son excution. Lorsquune classe est instancie, le programme lui cre un espace mmoire dans le tas manag. Cela se fait grce au constructeur.
Dim monChasseur As New AvionDeChasse()
Le constructeur est la partie qui suit New. Cest une mthode qui a pour nom celui de la classe et lui seul permet dinstancier cette classe. Il existe un constructeur par dfaut. Cest pourquoi vous navez pas eu lindiquer lors de lcriture de la classe AvionDeChasse. Dans ce cas, il rserve juste lespace mmoire. Cependant, il est possible de rednir le constructeur, et ainsi de pouvoir faire un certain nombre doprations lors de linstanciation. Vous pouvez modier sa signature, en ajoutant des paramtres par exemple. Il se cre comme une mthode qui ne renvoie aucune valeur de retour et dont le nom est New. Appliquons cela lavion de chasse :
Public Class AvionDeChasse Nous ne gardons quune partie de la classe pour cette illustration Private vitesseMax As Integer Private nbreAilerons As Integer Private reserveKerozene As Integer Public Sub afficheKero() MessageBox.Show("Niveau kro : " & Me.reserveKerozene) End Sub Public Sub New(ByVal keroOriginal As Integer) Me.reserveKerozene = keroOriginal End Sub End Class
On rednit le constructeur en lui ajoutant un paramtre qui permettra dinitialiser son niveau de krosne linstanciation. Pour appeler ce constructeur, il suffira de tenir compte de la nouvelle signature, et donc dajouter ce paramtre :
Dim monChasseur As New AvionDeChasse(100) monChasseur.afficheKero()
Un objet AvionDeChasse a t cr avec un niveau de krosne valant 100. Cela est conrm par la bote de dialogue, qui affichera "Niveau kro : 100".
Chapitre 9
On dclare une fonction qui instancie un chasseur, puis on instancie un autre chasseur et lon fait appel cette fonction. la n du programme, en admettant quil continue aprs, on pourra toujours utiliser monChasseur1. monChasseur1 est donc rfrenc. Par contre monChasseur2 est instanci dans la fonction essaiDereferencement. Or, en sortant de cette fonction, on ne peut plus y accder. En effet, il a t dclar dans une fonction, et bien quil existe en mmoire dans le tas manag, sa porte ne peut aller au-del de la fonction essaiDereferencement. la n de ce bout de programme, vous ne pouvez plus atteindre monChasseur2, il est drfenc.
Chapitre 9
Le ramasse-miettes vrie les objets quil a en charge et dtermine ceux qui sont rfrencs et ceux qui ne le sont plus. tant donn que ceux qui sont drfrencs ne sont plus accessibles, garder leur espace mmoire est inutile. Celui-ci est alors libr pour permettre la cration de nouveaux objets.
Chapitre 9
Finalize tant rednie, la mthode siegeEjectable sera appele lorsque lobjet sera dtruit. Attention cependant, il y a quelques rgles respecter. Il ne faut pas appeler explicitement Finalize, ce sera fait par le ramasse-miettes. Si lon veut effectuer la libration de lobjet manuellement, il y a une manire valable doprer, dcrite ci-aprs. De plus, il ne faut pas quune exception soit leve. Si cest lobjet qui gre lexception, elle ne pourra pas tre rcupre, car celui-ci sera dtruit ; cela peut provoquer larrt du programme.
De plus, le ramasse-miettes libre la mmoire selon son bon vouloir. En rednissant la mthode, vous ne pouvez pas forcer son utilisation, qui se fera au moment o le ramasse-miettes laura dcid, par exemple quand un besoin de mmoire se fera sentir, ou alors si le nombre dobjets drfrencs est trop important. Si vous voulez forcer la libration, il faut passer par limplmentation dun modle de conception, le DisposeFinalize. Nous prsenterons les modles de conception plus loin dans ce chapitre, car nous verrons juste aprs comment grer la sauvegarde et le chargement de vos objets de manire efficace. Nous vous invitons donc laisser faire le ramassemiettes dans un premier temps, car quoique lon puisse en dire, celui-ci est efficace dans la gestion de la mmoire.
Chapitre 9
de sauvegarde et de chargement automatique. Vous pourrez en user et en abuser, tel point que cela deviendra vite le moyen privilgi pour la gestion de la sauvegarde de vos objets. Dans un premier temps, nous allons voir plus en dtail ce quest la srialisation et ses diffrents types. Nous prparerons galement une petite application de test. Puis nous tudierons de manire plus dtaille deux types de srialisations : binaires et XML.
Enregistre vos objets dans un format machine non lisible par lhomme. Cest la premire que nous allons voir. XML. Enregistre vos objets au format XML, standard, et lisible par lhomme. Nous ltudierons galement. SOAP. On peut grossirement dire quil sagit dune version amliore de la version XML. Cest en fait un peu plus que cela, mais nous ne ltudierons pas dans cet ouvrage.
An de vous prsenter cette technique, nous allons crer une petite application qui se fondera sur une classe que nous allons srialiser et dsrialiser, la classe Livre :
Chapitre 9
Chapitre 9
End Property Property ISBN() As Long Get Return mIsbn End Get Set(ByVal Value As Long) mIsbn = Value End Set End Property End Class
Cette classe dnit six attributs membres (titre, auteur, anne de parution, ISBN, nombre de pages, diteur) ainsi que les proprits (en lecture / criture) associes. Entrons maintenant dans le vif du sujet. Nous allons crer une lgre application pour manier ces mcanismes.
2 Cest un projet WindowsForms, et ProjetSerialisation semble tre un nom adquat (voir Figure 9.28). 3 Il faut ajouter maintenant au projet la classe Livre, qui sera le point central du projet (voir Figure 9.29, 9.30).
Chapitre 9
Chapitre 9
4 Crez maintenant une interface graphique, base de Label, de TextBox et de Bouton, an quelle ressemble quelque chose dans ce style :
Reportez-vous ce sujet au chapitre Dialoguer avec un ordinateur. Maintenant que la base du programme est faite, nous allons pouvoir attaquer en profondeur et voir en dtail comment manier srialisation et dsrialisation.
La srialisation binaire
La srialisation binaire est un type de srialisation qui transforme votre objet en chier binaire, cest--dire directement en code machine. Globalement, si vous essayez de lire, vous ny arriverez pas. En tout cas pas en entier.
Chapitre 9
Comme vous pouvez le constater, on ne comprend pas grand-chose, mais il est possible de discerner certaines chanes de caractres. En effet, que ce soit dans un programme ou dans un chier, le code machine est le mme... Mais ce nest pas vraiment lobjet de ce chapitre. Tout dabord, il faut savoir que, pour srialiser et dsrialiser, il faut un srialiseur, qui fait aussi la dsrialisation. Logique ! Le srialiseur binaire est fourni par le framework .Net, dans le namespace Binary. Il vous faudra donc inclure ce namespace dans votre code.
Imports System.Runtime.Serialization.Formatters.Binary
Enregistrement : srialisation
Une mthode de srialisation crit un chier partir dun objet. Elle prendra donc cet objet en paramtre, ici un Livre, et ne renverra rien. Mais nous allons quand mme lui faire renvoyer un boolen pour nous dire si lopration sest bien passe. Elle aura donc une signature comme ceci :
Private Function BinarySerialize(ByVal monLivre As Livre) As Boolean End Function
Comme nous allons crire dans un chier, il faut crer celui-ci, par exemple Livre.bin. Il nous faut donc galement ajouter le namespace IO. Reportez-vous ce sujet au chapitre Enregistrer des donnes, les chiers. Le srialiseur binaire est un BinaryFormatter qui possde un constructeur par dfaut. Nous pouvons donc enrichir notre mthode de srialisation avec ces nouveaux lments :
Private Function BinarySerialize(ByVal monLivre As Livre) As Boolean If monLivre Is Nothing Then Return False Dim stream As FileStream = New FileStream("Livre .bin", FileMode.Create) Return True End Function
Chapitre 9
Validit de lobjet
Attention ne pas oublier la vrication de la validit de lobjet (If monLivre Is Nothing Then Return False), sans quoi vous risquez de provoquer une exception de type NullReferenceException.
La dernire tape de cette mthode est la srialisation effective. Elle est ralise par le srialiseur et prendra comme paramtre le chier dans lequel crire, ainsi que lobjet srialiser :
serializer.Serialize(stream, monLivre)
Il ne faudra pas oublier de librer les ressources utilises pour le chier, par lappel la mthode Close. Au nal, la mthode de srialisation ressemblera ceci :
Private Function BinarySerialize(ByVal monLivre As Livre) As Boolean If monLivre Is Nothing Then Return False Dim stream As FileStream = _ New FileStream("Livre.bin", FileMode .Create) Dim serializer As New BinaryFormatter serializer.Serialize(stream, monLivre) stream.Close() Return True End Function
Liez maintenant cette mthode au bouton de sauvegarde de votre interface. Et en avant pour le test ! Dmarrez le projet et remplissez les diffrents champs avec les valeurs de votre choix.
Chapitre 9
Erreur de srialisation ! Votre programme ne peut plus continuer sexcuter, car lobjet que lon veut srialiser est linstance dune classe qui nest pas marque comme srialisable. Qu cela ne tienne ! Marquons-la srialisable en y ajoutant un attribut.
<Serializable()> _ Public Class Livre Private mTitre As String Private mAuteur As String Private mEditeur As String Private mAnneeDeParution As Integer Private mNbreDePages As Integer Private mIsbn As Long ReadOnly Property Titre() As String Get Return mTitre End Get Set(ByVal Value As String) mTitre = Value End Set End Property ReadOnly Property Auteur() As String Get Return mAuteur End Get Set(ByVal Value As String) mAuteur = Value End Set End Property
Chapitre 9
ReadOnly Property Editeur() As String Get Return mEditeur End Get Set(ByVal Value As String) mEditeur = Value End Set End Property Property AnneeDeParution() As Integer Get Return mAnneeDeParution End Get Set(ByVal Value As Integer) mAnneeDeParution = Value End Set End Property Property NombreDePage() As Integer Get Return mNbreDePages End Get Set(ByVal Value As Integer) mNbreDePages = Value End Set End Property Property ISBN() As Long Get Return mIsbn End Get Set(ByVal Value As Long) mIsbn = Value End Set End Property End Class
Vous pouvez maintenant ressayer. Et vous obtiendrez en sortie un chier Livre.bin qui contiendra ceci :
Chapitre 9
Nous remarquons que certaines chanes de caractres sont lisibles. Certaines ont t gnres pour les besoins du framework .Net (nom du projet, version...) et dautres sont les valeurs des attributs de votre objet. On peut y voir le titre, lauteur, lditeur, mais remarquez quon ne voit pas les chiffres. Les types numriques en code machine ne sont pas lisibles, contrairement aux chanes de caractres. Ils correspondent certains des petits carrs que vous voyez.
Chargement : dsrialisation
Lopration contraire la srialisation, qui permet la cration de votre objet pralablement enregistr via la srialisation, est la dsrialisation. En toute logique, vous pensez quelle se fait avec un dsrialiseur. Et vous avez raison de penser cela, sauf quelle se fait galement en utilisant le srialiseur. En revanche, une mthode de dsrialisation a une signature totalement diffrente. En effet, nous avons vu que la dsrialisation consistait utiliser un chier pour crer un objet, ici de type Livre. Et, comme nous savons quel chier aller chercher, cette mthode ne ncessite pas de paramtres. Voici donc la base de notre mthode de dsrialisation :
Imports System.Runtime.Serialization.Formatters.Binary Private Function BinaryDeserialize() As Livre Dim monLivre As Livre = Nothing Dim deserializer As New BinaryFormatter Return result End Function
De la mme manire que pour enregistrer, il va falloir ici grer un chier, sauf quon va louvrir et non le crer.
Fichier manquant
Attention bien vrier lexistence du chier, sans quoi une exception de type IOException peut arrter votre programme !
Private Function BinaryDeserialize() As Livre Dim fichier As String = "Livre.bin" Dim monLivre As Livre = Nothing If Not File.Exists(fichier) Then Return Nothing Dim deserializer As New BinaryFormatter
Chapitre 9
Il faut maintenant dsrialiser et cest encore plus facile que la srialisation. Le seul paramtre ncessaire est le chier lire. La mthode qui fait cela est Deserialize. L encore, il ne faudra pas oublier de librer les ressources du chier, sinon vous ne pourrez plus louvrir avec un autre programme tant que notre programme de test sera actif. La mthode nale ressemble ceci :
Private Function BinaryDeserialize() As Livre Dim fichier As String = "Livre.bin" Dim monLivre As Livre = Nothing If Not File.Exists(fichier) Then Return Nothing Dim deserializer As BinaryFormatter Dim stream As FileStream = New FileStream(fichier, FileMode.Open) monLivre = deserializer.Deserialize(stream) stream.Close() Return monLivre End Function
Maintenant, il vous suffit de charger sur votre interface graphique les informations rcupres partir de linstance de Livre charge pour vrier le chargement :
On retrouve bien notre objet pralablement enregistr. Quelque part, cest rassurant, nest-ce pas ? Comme vous le voyez, il est trs facile de charger et denregistrer des instances de classe grce la srialisation. Nhsitez surtout pas
216 LE GUIDE COMPLET
Chapitre 9
utiliser ces mthodes. Elles vous feront gagner un temps prcieux sur la gestion de vos donnes, temps que vous pourrez utiliser pour des choses de plus haut niveau. Voyons maintenant la srialisation XML, qui, lutilisation, sera quasiment identique notre srialisation binaire, mais qui aura un chier de sortie totalement diffrent.
La srialisation XML
Je ne reviendrai pas ici sur ce quest le XML mais, pour ceux qui auraient pris le livre en cours, il faut savoir que cest un langage balises permettant de dcrire des lments suivant une hirarchie donne. Reportez-vous ce sujet au chapitre Enregistrer des donnes, Sauvegarde et chier : le XML. Mais, comme rien ne vaut un exemple, voici un extrait de chier XML :
Vous remarquez que, contrairement au format binaire, le format XML est totalement lisible. A fortiori, il permet de savoir ce que lon fait. Nous verrons que cela pourra devenir un moyen de modier nos donnes la vole. De la mme manire que pour la srialisation et la dsrialisation binaire, il faut un srialiseur. Dans ce cas-l, il est dans le namespace Xml.Serialization. Il faut donc ajouter ce namespace au projet.
Imports System.Xml.Serialization
Chapitre 9
Enregistrement : srialisation
Le principe de srialisation, quil soit binaire, XML ou mme SOAP (que nous ne traiterons pas ici) reste toujours le mme : on cre un chier partir dun objet. Cest pourquoi la signature de notre mthode de srialisation ne va pas changer. Elle prendra toujours en paramtre un objet Livre et renverra toujours un boolen qui nous dira si lopration sest bien passe.
Private Function XMLSerialize(ByVal monLivre As Livre) As Boolean End Function
Jusque-l tout est identique, si ce nest le nom de la mthode. (Ceci dit, on aurait pu garder le mme nom, ce qui aurait t trs maladroit, car le nom ne correspondrait plus laction.) Une fois encore, nous allons crire dans un chier, exactement de la mme manire que pour la srialisation binaire, mais on va lui donner un autre nom. .xml tant le standard pour dnir un chier XML, nous lappelons Livre.xml.
Besoin de ressources
Nous noublierons pas de librer les ressources du chier ni de vrier la validit de lobjet que nous voulons srialiser.
Private Function XMLSerialize(ByVal monLivre As Livre) As Boolean If monLivre Is Nothing Then Return False Dim stream As FileStream = _ New FileStream("Livre.xml", FileMode.Create) stream.Close() Return True End Function
Il nous faut maintenant instancier un srialiseur. Cependant, dans le cas du srialiseur XML, il faut lui passer comme paramtre le type de lobjet que nous voulons srialiser, tout simplement en utilisant GetType. Lutilisation se fait ensuite de manire totalement identique un srialiseur binaire, avec comme paramtre le lien vers le chier et lobjet srialiser :
Private Function XMLSerialize(ByVal monLivre As Livre) As Boolean If monLivre Is Nothing Then Return False Dim stream As FileStream =
Chapitre 9
New FileStream("Livre.xml", FileMode .Create) Dim serializer As XmlSerializer = _ New XmlSerializer(GetType(Livre)) serializer.Serialize(stream, monLivre) stream.Close() Return True End Function
Nous obtiendrons donc un chier de sortie, au format XML, contenant les informations de notre objet, qui, lui, est totalement lisible.
Chargement : dsrialisation
Cette fois encore, la dsrialisation sera avec un objet srialiseur. Cela a au moins cet avantage quon linstancie de la mme manire. De plus, nous grerons galement un chier ouvrir, que lon prendra bien soin de refermer pour viter de laisser un lien qui empchera son utilisation par un autre programme. On noubliera pas non plus de vrier son existence pour viter des erreurs IOException. Voici la mthode de dsrialisation XML :
Private Function XMLDeserialize() As Livre Dim fichier As String = "Livre.xml" Dim monLivre As Livre = Nothing If Not File.Exists(fichier) Then Return Nothing Dim deserializer As XmlSerializer = _ New XmlSerializer(GetType(Livre)) Dim stream As FileStream = New FileStream(fichier, FileMode.Open) Dim result As Object = Nothing monLivre = deserializer.Deserialize(stream) stream.Close() Return monLivre End Function
Chapitre 9
Comme la mthode de dsrialisation est quasiment identique en binaire ou en XML, je ne vais pas dtailler une nouvelle fois les diffrents points de la mthode. Cependant, la srialisation XML a certaines particularits. Si vous chargez directement le chier pralablement enregistr, vous obtiendrez le mme objet que celui dorigine. Jusque-l, normal, nous pouvons vrier dans votre interface de chargement :
Maintenant, tant donn que le chier XML est lisible et modiable, essayez de changer certaines de ses valeurs :
Et, l, si vous tentez de recharger le mme chier, voici ce que vous obtiendrez dans votre interface :
Chapitre 9
Comme vous le voyez, les lments ont chang, prenant maintenant les valeurs contenues dans le chier XML. Quelque part, cest rassurant, car cela nous prouve que la dsrialisation fonctionne. Dun autre ct, cela ouvre normment de possibilits pour piloter des objets (et donc une application) partir de chiers. Par exemple, crons un objet MailSender, dont le but est denvoyer des courriers lectroniques. Ajoutons-lui des attributs "Nombre de message", "destinataire", "corps"... En le pilotant par srialisation et dsrialisation, il ny a mme plus besoin de modier notre programme pour faire changer son comportement. On le dnit dans le chier XML de srialisation et il sera mme de trouver les bonnes valeurs automatiquement. Je vous laisse le soin de crer un tel projet, cela pourrait tre un trs bon exercice de mise en pratique, pas trop difficile, concret et intressant. Modions quelque peu notre code. Pour des raisons de scurit, nous souhaiterions que certaines des proprits de notre classe Livre soient en lecture seule (par exemple le titre, lauteur et lditeur... Eh oui, on ne peut pas nous changer) :
ReadOnly Property Titre() As String Get Return mTitre End Get End Property ReadOnly Property Auteur() As String Get Return mAuteur End Get End Property ReadOnly Property Editeur() As String Get Return mEditeur End Get End Property
Maintenant, retentez un chargement et vous obtiendrez ceci : (voir Figure 9.42) Les champs dont les proprits taient en lecture seule napparaissent plus... En effet, cest une particularit de la srialisation XML. Elle se fonde sur les proprits et utilise les Get et les Set pour srialiser ou dsrialiser le cas chant. Alors que la srialisation binaire srialisera et dsrialisera les attributs directement, quelle que soit leur accessibilit.
Chapitre 9
Quoi quil en soit, quelle soit binaire ou XML, nhsitez pas user et abuser de la srialisation. Choisissez celle qui vous convient selon le besoin de votre application. Si vous devez modier des donnes la vole, prfrez la srialisation XML car elle est lisible par lhomme. En revanche, tant donn que cest du texte, elle sera moins performante et prendra plus de place en mmoire. Dun autre ct, la srialisation binaire est plus performante, et elle ne ncessite pas de dnir des proprits. Elle est plus adapte pour une utilisation directe qui ne demande pas de modication entre la sauvegarde et le chargement. Vous verrez, une fois acquise, la srialisation est un concept dont on ne peut plus du tout se passer tellement elle facilite la gestion de la sauvegarde et du chargement des donnes.
dans tout le programme et vous limplmenterez. Puis, vous tudierez quelques-uns des modles de conception les plus courants, ce qui vous donnera un point de dpart si vous voulez approfondir le sujet.
Chapitre 9
Le constructeur peut contenir dautres oprations effectuer, par rapport lutilisation de la classe. On cre ensuite linstance de la classe. La particularit du Singleton est que linstance est un attribut priv de cette classe. Celui-ci doit tre
LE GUIDE COMPLET 223
Chapitre 9
galement partag, car laccesseur sera galement partag pour tre accessible partir de la classe, et non dun objet. Il doit tre initialis Nothing. De cette manire, on saura sil existe ou pas. Sil vaut Nothing, cela signie quil nexiste pas. Sinon il existe :
Public Class Singleton Le constructeur est priv, on ne peut pas instancier la classe Private Sub New() End Sub Instance unique de la classe cest un attribut priv de celle-ci Private Shared instance As Singleton = Nothing End Class
Il faut ensuite implmenter laccesseur qui permettra de rcuprer cette instance. Si linstance nexiste pas, cest--dire si lattribut instance vaut Nothing, cet accesseur doit crer linstance. Il le pourra car il a accs au constructeur, mme si celui-ci est priv. Ensuite, il retournera linstance.
Public Class Singleton Le constructeur est priv, on ne peut pas instancier la classe Private Sub New() End Sub Instance unique de la classe cest un attribut priv de celle-ci Private Shared instance As Singleton = Nothing Laccesseur cre linstance si elle nexiste pas Puis il la retourne Public Shared Function getInstance() As Singleton If (Me.instance Is Nothing) Me.instance = New Singleton() End If Return Me.instance End Function End Class
Le Singleton est maintenant totalement dni. Pour pouvoir y avoir accs et lutiliser, il suffit dinvoquer la classe et de faire appel sa mthode getInstance :
Singleton.getInstance()
Chapitre 9
Bien quil existe, le Singleton ne fait rien pour linstant. On lui donne un nom, que lon va modier et rafficher, de manire vrier lunicit de linstance :
Public Class Singleton Le constructeur est priv, on ne peut pas instancier la classe Private Sub New() End Sub Instance unique de la classe cest un attribut priv de celle-ci Private Shared instance As Singleton = Nothing Laccesseur cre linstance si elle nexiste pas Puis il la retourne Public Shared Function getInstance() As Singleton If (Me.instance Is Nothing) Me.instance = New Singleton() End If Return Me.instance End Function Public nom As String = "Toto" End Class
Le Singleton sappelle Toto lorigine. On modie son nom que lon raffiche pour savoir si cela a affect la bonne personne :
MessageBox.Show("nom du singleton : " & _ Singleton.getInstance().nom) Singleton.getInstance().nom = "Bibi" MessageBox.Show("nom du singleton : " & _ Singleton.getInstance().nom)
La premire bote de dialogue affiche le nom dorigine, "Toto". Ensuite, on modie celui-ci. Daprs le principe du Singleton, il ny a quune instance. Par consquent, celui qui tout lheure sappelait Toto doit dappeler Bibi maintenant. On crit donc la mme instruction. Effectivement la seconde bote de dialogue conrme que le Singleton sappelle maintenant Bibi. Un modle de conception est une enveloppe pour des classes correspondant des problmatiques. Vous devrez les complter pour les adapter au contexte, en y ajoutant les attributs et les mthodes ncessaires. Sinon, vous pouvez utiliser les autres mcanismes de la programmation oriente objet. Par exemple, si vous faites de Singleton une classe mre dont dautres classes peuvent driver, ces
Chapitre 9
autres classes nauront galement quune seule instance. vous de voir comment ces modles sadaptent le mieux.
DisposeFinalize
Vous devriez pour linstant laisser le ramasse-miettes soccuper de la libration de la mmoire, car vous risqueriez dtre moins efficace que lui en tentant de forcer vous-mme la libration. Effectivement, librer la mmoire proprement nest pas chose aise. Limplmentation du modle DisposeFinalize permet de bien le faire. Il est compos de plusieurs lments : j Il faut tout dabord un attribut boolen pour dterminer si la destruction a t faite. j Puis, on doit avoir une fonction Dispose. Celle-ci fait appel une fonction surcharge prenant en paramtre un boolen. Ce boolen dtermine si cest vous qui avez forc la destruction de lobjet, ou si cest le ramasse-miettes. La fonction Dispose sans paramtre appelle la fonction Dispose avec le paramtre true, puis la fonction SuppressFinalize du ramasse-miettes. j Ensuite, il faut rednir la fonction Finalize. Elle appellera la fonction Dispose avec le paramtre false pour prvenir que cest le ramasse-miettes qui a lanc la destruction. Si la classe en cours est une classe lle, il faut librer la classe mre. j Dans la classe Dispose surcharge, selon le paramtre, le traitement de la libration des diffrents attributs devra tre faite. Si vous implmentez ce modle, vous pourrez alors dtruire vous-mme vos objets en faisant appel la mthode Dispose. Elle se chargera de librer la mmoire ddi lobjet et aux autres objets qui dpendent de lui.
226 LE GUIDE COMPLET
Chapitre 9
Iterator
Lorsque les projets sont relativement consquents, les structures de donnes complexes, il peut tre fastidieux de les parcourir dans leur globalit. En effet, on ne peut pas toujours se contenter dutiliser une simple boucle for, en partant du premier au dernier lment, comme dans les tableaux. Le modle Iterator permet justement de parcourir des classes structures complexes, comme si elles ntaient que de simples listes. De plus, utiliser ce modle permet de parcourir la structure, mais sans exposer son fonctionnement intrieur. Pour cela, on a besoin de trois lments : j Il faut une interface dnissant un itrateur. Cette interface contient au moins une mthode permettant daccder llment courant, ainsi quune mthode permettant daccder llment suivant. On peut complter cette interface en ajoutant la possibilit de supprimer llment en cours, mais lindispensable est de pouvoir accder llment en cours et au suivant. j Il faut une classe MonIterator adapte la structure qui implmente linterface Iterator. Cette classe saura parcourir la structure. j Dans la classe correspondant une structure, il faut une mthode qui cre et renvoie un itrateur capable de parcourir cette structure. Vous pourrez alors parcourir cette structure sans vous soucier de son fonctionnement, tant donn que litrateur est fait pour cela, et adapt ladite structure.
tat
Les comportements dun objet dpendent souvent dun certain tat, un moment donn. Un magasin par exemple est susceptible daccueillir des clients sil est dans un tat "ouvert". Sil est dans un tat "ferm", il ny a pas de clients dedans et les lumires sont teintes. La notion dtat dtermine donc un certain comportement de lobjet un moment donn. Le rle de ce modle est de symboliser cette notion dtat, sans toucher lobjet lui-mme. De cette manire, on ne rend pas les tats dpendant de lobjet. Si par exemple on doit ajouter ou supprimer des tats, il ne sera pas ncessaire de remodier totalement lobjet lui-mme.
LE GUIDE COMPLET 227
Chapitre 9
La mthode communment utilise pour ce problme est de dnir les tats comme des constantes (ETAT_OUVERT, ETAT_FERME), davoir un attribut symbolisant ltat en cours, et selon la valeur de cet attribut, de faire les oprations ad hoc. Si le nombre dtats est important, le code peut devenir confus. Le principe de ce modle est de dnir une interface correspondant un tat. Ensuite, chaque tat sera une classe implmentant cette interface. j Tout dabord, il faut crer linterface. Cette interface contiendra lensemble des mthodes en rapport avec lobjet, par exemple pour le magasin servirClient, rangerMateriel, etc., cest-dire lensemble des mthodes qui ont une dpendance par rapport un tat donn. j Ensuite, il faut crer les classes des diffrents tats et leur faire implmenter linterface. Par exemple, pour ltat magasinFerme, la classe retournera une exception, alors que pour magasinOuvert, elle effectuera lopration comme il faut. j Il faut enn dcrire le mcanisme de changement dtat, permettant de passer de lun lautre et de dnir un tat de dpart. De cette manire, vous fournissez lobjet un comportement qui dpend dun tat donn. Or, ce traitement est spar de lobjet lui-mme, ce qui permet de gagner en comprhension, en souplesse et en abilit. Ltude des modles de conception est bnque pour la comprhension des mcanismes de la programmation oriente objet. Nous en avons prsent ici trois qui sont relativement simples. Dautres sont plus complexes et il en existe une multitude, chacun adapt un problme donn. Nhsitez pas en utiliser, vos programmes seront de meilleure qualit.
Chapitre 9
La dclaration de la fonction, aligne gauche. Le contenu de la fonction, qui est dcal dune tabulation aprs la dclaration de celle-ci. ce niveau seront alignes toutes les instructions de la fonction, dont le If qui ouvre un nouveau bloc. Lintrieur des blocs du If et du Else, contenant les instructions daffichage.
Ce bout de programme reste comprhensible car il est petit. Mais il est beaucoup moins lisible ainsi. Cest pourquoi nous vous recommandons de bien indenter vos programmes.
Chapitre 9
Cette classe est claire, explicite et commente. Grce aux noms des diffrents lments, on comprend quoi ils correspondent. Vous pouvez vous reporter aux commentaires pour chercher des complments dinformation. Voici la mme classe, sans commentaire, avec des noms qui ne sont pas explicites du tout :
Public Class Ljopusd Private Sub New() End Sub Private Shared utjvqsd As Ljopusd = Nothing Public Shared Function oieurIqsg() As Ljopusd If (Me.utjvqsd Is Nothing) Me. utjvqsd = New Ljopusd() End If Return Me.utjvqsd End Function Public pisudgsglqjef As String = "Toto" End Class
Chapitre 9
On a du mal simaginer que cela est un Singleton. Pourtant, cest exactement la mme classe que la prcdente, avec un comportement identique. Do lintrt dtre explicite et de mettre des commentaires.
Ces deux fonctions effectuent une addition. Elles sont toutes les deux fausses au niveau du sens. Testez-les ainsi :
Dim res As Integer res = addition1(3, 4) + addition2(6, 9) MessageBox.Show("res = " & res)
Vous obtiendrez effectivement le bon rsultat car les deux erreurs sannulent. Pourtant les deux fonctions sont fausses. Cest pourquoi, il faut faire les tests des lments sparment :
MessageBox.Show("somme = " & addition1(3, 4)) MessageBox.Show("somme = " & addition2(6, 9))
Chapitre 9
De cette manire, vous vous rendrez compte que les deux fonctions sont fausses, et en plus vous pourrez comprendre lerreur.
Ici, il y a un gros problme au niveau du sens. On est considr mineur alors que lge nest pas valide du tout. Intgrez donc toujours un mcanisme de vrication de la validit des valeurs, et lorsquil y a un problme, dnissez un comportement particulier.
Dim age As Integer age = -1 If (age < 0 Or age > 130) Then MessageBox.Show("Lge donn nest pas valide") ElseIf (age < 18) Then MessageBox.Show("Vous tes mineur") Else MessageBox.Show("Vous tes majeur") EndIf
Chapitre 9
Idem pour les exceptions. Travaillez avec des exceptions sur plusieurs niveaux, de la plus spcialise la plus gnrale, et nomettez pas les cas derreur par dfaut :
Try Dim resultat As Integer resultat = dividende \ diviseur MessageBox.Show("Rsultat = " & resultat) Catch exc As System.DivideByZeroException MessageBox.Show(exc.Message) MessageBox.Show(exc.StackTrace) diviseur = 1 Catch exc As System.IllegalArgumentsException MessageBox.Show(exc.Message) MessageBox.Show(exc.StackTrace) MessageBox.Show("Les arguments ne sont pas valables") Catch exc As System.Exception MessageBox.Show("Il y a eu une exception dordre gnral") End Try
Les recommandations peuvent tre nombreuses, par exemple toujours crire une seule classe dans un mme chier. Mais si vous appliquez celles-ci la lettre, vos programmes seront ables et agrables utiliser. Par ailleurs, il vous sera plus facile de vous replonger dans votre code aprs de longs temps dinterruption.
Chapitre 9
programme. Cest pourquoi nous verrons dans un second temps comment modier ce mme programme, de manire le rendre rutilisable. Cest dans cet esprit quil vous faudra crer vos futurs programmes, car cela nenlve en rien les possibilits que vous avez prcdemment produites, mais en les rendant rutilisables vous leur donnez une valeur ajoute qui sera grandement apprcie par vos collaborateurs.
Chapitre 9
Crons ensuite le code principal de votre programme. Nous allons lui faire crer sept numros entre 1 et 49 que nous afficherons dans cette interface. Gnrer un nombre alatoire est trs facile grce au framework .Net. Il suffit dinstancier un objet de la classe Random et de faire appel la mthode Next. Cette dernire prend deux entiers en paramtres correspondant aux limites basse et haute. Dans notre cas, ces paramtres sont 1 et 49, les limites du Loto.
3 Double-cliquez sur le bouton an que Visual Studio cre la mthode destine grer lvnement du Click. Vous pourrez ensuite y mettre votre mthode.
Private Sub Button1_Click(ByVal sender As System .Object, _ ByVal e As System.EventArgs) Handles Button1.Click Dim generator As New Random() Dim number As Integer = generator.Next(1, 49) TextBox1.Text = number number = generator.Next(1, 49) TextBox2.Text = number number = generator.Next(1, 49) TextBox3.Text = number number = generator.Next(1, 49) TextBox4.Text = number number = generator.Next(1, 49) TextBox5.Text = number number = generator.Next(1, 49) TextBox6.Text = number number = generator.Next(1, 49)
Chapitre 9
Vous avez maintenant un programme capable de vous donner un tirage du loto. Si un nombre apparat plusieurs fois, cliquez de nouveau pour avoir un nouveau tirage.
De mon ct, jai galement une application. Pour linstant, elle ne fait pas grand-chose, mais je ne dsespre pas de pouvoir lenrichir.
Module Module1 Sub Main() Console.WriteLine("Bonjour le monde.") Console.ReadLine() End Sub End Module
ce stade, tout cela nest pas dune grande utilit. Jy inclurais bien la possibilit de gnrer un tirage du loto. De cette manire, quelquun qui utiliserait mon application pourrait voir "Bonjour le monde." mais galement voir le tirage du loto, qui pourrait lui amener la richesse. Cela tombe bien, vous avez ralis une application capable de faire ceci. Quel malheur, cest une application indpendante et je ne peux donc pas lintgrer mon projet personnel. Mon application est condamne afficher simplement "Bonjour le monde.".
Chapitre 9
Le gnrateur de tirage
Nous avons identi comme une grande partie de votre programme celle qui fait le calcul des tirages. Pour linstant, il nest aucunement question daffichage ici, donc, une bibliothque de classe nous permet de grer cette partie.
Chapitre 9
Puis il va falloir remplir cette classe an quelle fasse bien le traitement que lon veut. Cest l quon doit faire preuve dun peu de rexion pour savoir comment grer ceci. Tout dabord, posons-nous la question : "De quoi a-t-on besoin ?" Rponse : rien ! En effet, nous avons toutes les informations ncessaires. Notre but tant simplement de gnrer sept nombres compris entre 1 et 49. Nous naurons donc pas dattributs membres. Autre question, maintenant : "Que va-t-on faire ?" Notre but est de gnrer sept nombres que lon va pouvoir utiliser. Faisons donc une mthode qui renvoie une liste de nombres. Ce qui amne la question suivante : "Quels seront les paramtres de cette mthode ?" L encore, aucun. Nous savons que ces nombres seront compris entre 1 et 49. Dernire question pour complter la cration de la mthode : "A-t-on besoin dune instance particulire ?" Rponse : non. Cette mthode tant totalement utilitaire, elle ne possde aucune information pertinente que lon ait envie de garder. Dans ce cas, on peut la marquer Shared, ce qui nous permettra daccder la mthode sans avoir besoin dinstancier un objet de type NumberGenerator.
238 LE GUIDE COMPLET
Chapitre 9
Pour tre utilises par dautres, la classe et la mthode devront tre Public.
Nous avons maintenant fait le plus difficile. Le remplissage de la mthode est alors basique. Il vous suffit de crer le rsultat et de le remplir en utilisant ce que vous avez fait prcdemment dans lautre programme.
Public Shared Function GenerateNumbers() As List(Of Integer) Dim result As List(Of Integer) = New List(Of Integer)(7) Dim i As Integer Dim generator As Random = New Random() For i = 1 To 7 result.Add(generator.Next(1, 49)) Next Return result End Function
Parfait, nous venons de terminer la premire partie de votre programme. La compilation de ce projet permettra de gnrer une DLL qui contiendra la classe NumberGenerator, qui expose une mthode GenerateNumbers. Occupons-nous maintenant de la seconde partie, laffichage. Comme nous ne voulons pas modier notre bibliothque de classe, ajoutons un projet "Application Windows" qui se chargera dafficher les rsultats obtenus depuis notre classe NumberGenerator. En fait, reprenons lancien projet : LotoStandAlone. Nous gardons linterface, mais supprimons tous les traitements qui sont faits.
Private Sub Button1_Click(ByVal sender As System .Object, _ ByVal e As System.EventArgs) Handles Button1.Click End Sub
Chapitre 9
Or cest maintenant notre DLL LotoGenerator qui fait tous les traitements. Il faudra donc linclure au projet.
Cherchez la DLL, qui doit tre dans le dossier dexcution du projet LotoGenerator.
Pour pouvoir utiliser les classes de la DLL, il vous faut inclure son
namespace.
Imports LotoGenerator
Chapitre 9
Vous remarquez quon distingue directement les deux parties du programme. Une instruction fait la rcupration des nombres, le reste des instructions sert afficher. Et, nalement, lapplication est exactement la mme.
De votre point de vue, cela na effectivement rien chang. Maintenant, en ce qui me concerne, je peux enrichir mon application qui faisait "Bonjour le monde.". Il me suffit dajouter votre DLL mon projet et dajouter le namespace, comme vous lavez fait dans la partie affichage. Et je peux maintenant utiliser votre mthode de gnration de nombres. Puis jadapte mon propre affichage pour quil soit en accord avec mon application :
Sub Main() Console.WriteLine("Bonjour le monde.")
Chapitre 9
Dim tirage As List(Of Integer) = NumberGenerator .GenerateNumbers() Console.WriteLine(tirage.Item(0)) Console.WriteLine(tirage.Item(1)) Console.WriteLine(tirage.Item(2)) Console.WriteLine(tirage.Item(3)) Console.WriteLine(tirage.Item(4)) Console.WriteLine(tirage.Item(5)) Console.WriteLine(tirage.Item(6)) Console.ReadLine() End Sub
Et, grce votre DLL, jai pu enrichir mon application. De votre ct, vous avez rendu votre travail rutilisable, ce qui lui a donn une norme valeur ajoute. Si vous aviez gard la version dorigine, o tout est fait au mme endroit (traitement + affichage), je naurais pu lutiliser, et je ne laurais certainement jamais fait. Alors quen la dcoupant comme il faut, en la divisant en deux parties distinctes et dissocies, vous mavez permis de lutiliser dans une application totalement extrieure votre projet. Cette capacit bien discerner les parties dun projet demande de lexprience et de la pratique. Il nest pas intuitif de faire un dcoupage qui na pas lieu dtre au premier abord, surtout dans une optique o vous avez le contrle total de votre application. Qui plus est, cela demande plus de temps, car ce sont autant dlments prendre en compte, en plus de ceux qui existent dj. Mais, pour deux applications
Chapitre 9
qui sont identiques visuellement, la rutilisabilit peut faire la diffrence entre la trs bonne application et celle qui est bien, tout simplement.
Chapitre 9
dinformations essentielles qui vous permettront de comprendre rapidement ce qui sest pass dans votre programme et donc de ragir en consquence. Un outil de rfrence nous permet de grer ceci : Log4Net.
Prsentation de loutil
Log4Net est un outil qui vous permettra de grer le droulement de votre programme travers des "logs", cest--dire des chiers textuels qui dtailleront le comportement de votre application, un peu la manire des journaux dvnements, qui permettent denregistrer les erreurs. Un des aspects intressants de cet outil est sa capacit tre congur lexcution. De cette manire, vous navez pas modier votre programme ni le recompiler avec des logs plus ou moins dtaills. Il offre de nombreuses possibilits telles les suivantes :
j La compatibilit avec de nombreux frameworks.
Il est possible de lexcuter avec la plupart des versions du framework .Net, mme celle destine aux tlphones portables, ou encore Mono, limplmentation de .Net portable sur dautres systmes dexploitation, comme Linux. La multiplicit des sorties possibles. Les informations recueillies par Log4Net peuvent vous tre restitues sous forme de chiers textuels, cest le fonctionnement normal. Mais vous pouvez galement les retranscrire sur la Console, ou encore envoyer des courriers lectroniques, ou tout simplement les garder en mmoire La configuration dynamique. Log4Net offre la possibilit dtre congur travers un chier XML. De cette manire, sans modier votre application, vous pouvez changer le niveau de log que vous voulez voir afficher, la sortie que vous souhaitez utiliser ou encore le chemin qui contiendra votre chier de log. Le contexte de log. Outre les informations que vous avez explicitement demandes, Log4Net enregistre un certain nombre dinformations qui lui sont propres, comme lheure laquelle il a effectu le traitement ou encore le thread ayant appel lopration. Une hirarchie de criticit. Nous sommes daccord pour dire que toutes les informations nont pas la mme importance. Savoir que
Chapitre 9
le programme est entr dans telle mthode est moins important quune erreur ayant surgi sans prvenir. Pour marquer cette importance, Log4Net dnit plusieurs niveaux dans les logs :
Debug. Ce sont les informations les moins importantes. On
pourra y mettre les entres et les sorties de mthodes ou encore des messages informatifs pour nous dire dans quelle partie du programme nous sommes passs. Info. Ce niveau de log correspond une information pertinente. Cela pourra correspondre une action importante ou encore laffichage des donnes utilises dans notre mthode. Warn. Ce niveau marque un avertissement. Un avertissement nest pas une erreur en soi, mais marque un tat qui peut provoquer un comportement instable. Il ny a pas lieu de saffoler, mais il est quand mme bon de savoir que quelque chose de troublant sest pass. Error. Cest le dernier niveau de log utilis, et le plus important. Il est gnralement utilis en cas derreur. En effet, tant donn quune erreur nest jamais faite volontairement, il ne faut surtout pas la rater. En loggant vos erreurs avec ce niveau, vous tes certain de les voir apparatre le cas chant. Aprs cette rapide prsentation de loutil, entrons dans le vif du sujet.
Chapitre 9
Une fois que la rfrence est ajoute, dans chaque chier de votre projet o vous voudrez utiliser Log4Net vous inclurez le namespace log4net et Config.
Chapitre 9
Une fois toutes ces tapes ralises, vous pourrez utiliser Log4Net dans vos projets. titre dexemple, vous pouvez crer une application lgre contenant cette mthode, en ayant bien effectu avant les oprations dcrites ci-dessus.
Module Module1 Sub Main() Dim log As ILog = LogManager .GetLogger(GetType(Module1)) BasicConfigurator.Configure() log.Info("Entering application.") log.Info("Exiting application.") Console.WriteLine("Action finished.") Console.ReadLine() End Sub End Module
On ne dirait pas, mais dans ce bout de programme nous avons fait pas mal de choses.
Chapitre 9
Cette ligne cre le logger. Cest avec cet objet que vous allez effectuer tous vos traitements de log. Le paramtre de la mthode GetLogger est le type de la classe ou du module utilis. Ce paramtre nest pas obligatoire, mais il est possible de faire apparatre cette information dans les logs, cest pourquoi il est bon de la donner au moment dinstancier le logger.
BasicConfigurator.Configure()
En instanciant le logger sans faire dautre action, celui-ci ne fera rien. En effet, pour que ses actions aient une rpercussion visible par lutilisateur, il faut le congurer en consquence. Comme nous navons pas encore vu les dtails concernant la conguration dun logger, nous utilisons la conguration par dfaut, accessible via la classe BasicConfigurator.
log.Info("Entering application.") log.Info("Exiting application.")
Voici comment on utilise le logger. Il suffit tout simplement dappeler la mthode correspondant au niveau de log que lon veut donner et de passer en paramtre le message que lon veut voir apparatre. Et, comme nous lavons vu aprs lexcution de notre application, la conguration par dfaut renvoie en fait les messages de log sur la Console, nous permettant ainsi de suivre ce qui se passe sans avoir crire dinstruction Console.WriteLine. Dans la sortie de notre programme, vous avez pu remarquer que lon trouve un certain nombre dinformations complmentaires qui nous sont fournies par Log4Net. Nous trouvons entre autres le niveau de log utilis (INFO) ou encore le module qui a excut laction (TestLogging.Module1). Les premiers nombres sont des informations de temps et le thread dans lequel linstruction a t faite. Maintenant, nous allons crer une nouvelle mthode et placer le logger un endroit accessible par toutes les mthodes.
Module Module1 Dim log As ILog = LogManager .GetLogger(GetType(Module1)) Sub HelloWorld()
Chapitre 9
Nous pouvons voir lexcution de la mthode HelloWorld, ainsi que laffichage de toutes les informations de log qui y sont associes. Nous pouvons en dduire que la conguration par dfaut affiche les logs jusquau niveau le plus bas. Trs bien, nous pouvons maintenant enrichir nos applications dinformations pertinentes qui seront affiches sur la Console et qui nous permettront de suivre notre programme. En revanche, et je pense que vous serez daccord avec moi, on sy perd un peu. Notre message "Hello World", correspondant au rel traitement de notre mthode, passe
Chapitre 9
un peu inaperu cause de la pollution visuelle provoque par tous ces messages de log. Pour viter ceci, nous allons congurer nous-mmes le logger. La conguration dun logger se fait en utilisant le format XML. Nous la ferons dans un chier nomm Logger.config. Pour ce faire, nous allons remplacer le BasicConfigurator par un XmlConfigurator qui prend en paramtre un FileInfo li notre chier Logger.config.
XmlConfigurator.Configure(New System.IO.FileInfo("Logger .config"))
Voyons maintenant comment crire un chier de conguration du logger. Tout dabord, il faut crer le squelette, cest--dire une balise log4net qui contiendra toutes les informations du logger.
<log4net> </log4net>
Comment congurer un logger ? En fait, Log4Net fonctionne avec un systme dAppender. Un Appender est une manire de restituer ce qui a t trait par le logger. Par exemple, lcriture sur la Console correspond un Appender, lcriture dans un chier correspond un autre type dAppender. Il faudra donc marquer dans le chier de conguration tous les Appender que votre logger devra traiter. Il est dni par un nom, un type et un format de sortie. Pour les dtails propos des formats de sortie, je vous invite chercher dans la documentation de Log4Net. Pour notre application, nous utiliserons le format de sortie par dfaut.
<appender name="A1" type="log4net.Appender .ConsoleAppender"> <layout type="log4net.Layout.PatternLayout"> <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" /> </layout> </appender>
Maintenant que nous avons dni un Appender, il faut que nous prcisions que le logger utilise cet Appender. En utilisant la balise root, nous dnissons une conguration globale pour tous les logger.
Chapitre 9
Dans cette balise, il nous faut galement dnir le niveau minimal daffichage des logs.
<root> <level value="DEBUG" /> <appender-ref ref="A1" /> </root>
En excutant de nouveau notre programme, nous retrouvons notre sortie dorigine sauf que, cette fois-ci, nous avons utilis un chier de conguration. Tentons de changer le niveau de log, en mettant INFO la place de DEBUG.
Chapitre 9
Cela devient un peu plus lisible. Et nous avons pu faire ceci sans retoucher notre programme. Trs bien mais, pour linstant, nous affichons toujours les logs sur la Console. Nous allons maintenant tenter dafficher nos logs dans un chier. Pour cela, il faut ajouter un Appender dans notre chier de conguration : le FileAppender. Il faut galement y dnir le nom du chier de sortie, le format de sortie, mais galement si on crase les anciens chiers ou non. Voici ce que lon doit ajouter notre chier de conguration :
<appender name="FileAppender" type="log4net.Appender .FileAppender"> <file value="log.txt" /> <appendToFile value="false" /> <layout type="log4net.Layout.PatternLayout"> <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" /> </layout> </appender>
Nous avons ajout notre nouvel Appender, il faut donc maintenant prciser dans root que lon veut utiliser celui-ci :
<root> <level value="DEBUG" /> <appender-ref ref="FileAppender" /> </root>
Chapitre 9
La Console nest maintenant plus pollue par tous les messages de Log4Net. A-t-on perdu toutes nos informations pour autant ? Que nenni ! Si nous allons dans le dossier de notre projet, nous pouvons remarquer la cration dun nouveau chier Log.txt (comme le nom que nous avons donn notre chier de sortie). Et quy a-t-il dedans ?
Chapitre 9
Il y a toutes nos informations de logs. Grce ce chier de log, nous pouvons maintenant tracer a posteriori ce qui a t ralis par notre programme. Le FileAppender est la forme la plus simple dAppender sur les chiers. Or Log4Net possde un autre Appender pour les chiers : le RollingFileAppender. Cet Appender permet dutiliser plusieurs chiers de logs de taille plus petite. En effet, selon votre niveau de logs et la manire dont vous les utilisez dans votre programme, un chier de log peut trs vite devenir norme. Essayons de rpter HelloWorld 100 000 fois.
Sub Main() XmlConfigurator.Configure(New System.IO.FileInfo _ ("Logger.config")) log.Info("Entering application.") Dim i As Integer For i = 0 To 100000 HelloWorld() Next log.Info("Exiting application.") Console.WriteLine("Action finished.") Console.ReadLine() End Sub
Le programme prend un peu de temps, mais allons voir ce qui sest pass du ct de notre chier. Il fait maintenant prs de trente mgaoctets. Cest norme ; si vous essayez de louvrir avec un diteur de texte, vous risquez davoir un peu de mal. Le RollingFileAppender permet de scinder un chier de log en plusieurs chiers plus lgers. Comme pour tous les Appender, il faut lui dnir un nom et un format de sortie. Comme il sagit dun Appender sur chiers, il faut galement prciser le nom du chier et si on crase les anciens. De plus, pour le RollingFileAppender, il va falloir prciser la taille maximale dun chier et le nombre maximal de chiers.
Taille des chiers Log
Si lensemble des logs dpasse la taille maximale pour tous les chiers, les dernires informations seront perdues.
Chapitre 9
<log4net> <appender name="A1" type="log4net.Appender.ConsoleAppender"> <layout type="log4net.Layout.PatternLayout"> <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" /> </layout> </appender> <appender name="FileAppender" type="log4net.Appender.FileAppender"> <file value="log.txt" /> <appendToFile value="true" /> <layout type="log4net.Layout.PatternLayout"> <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" /> </layout> </appender> <appender name="RollingFile" type="log4net.Appender.RollingFileAppender"> <file value="log.txt" /> <appendToFile value="true" /> <maximumFileSize value="10000KB" /> <maxSizeRollBackups value="2" /> <layout type="log4net.Layout.PatternLayout"> <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" /> </layout> </appender> <root> <level value="DEBUG" /> <appender-ref ref="RollingFile" /> </root> </log4net>
Si vous ouvrez maintenant le dossier de votre projet, vous remarquez un chier Log.txt, mais galement un chier Log.txt.1. Ce dernier chier est en fait le premier chier de log, qui tant devenu trop volumineux a laiss sa place un autre. De cette manire, pour les analyser, vous pouvez regarder des chiers dune taille que vous aurez choisie. Avec ce que nous avons vu au cours de ce chapitre, vous pouvez renforcer vos applications avec une sorte de mouchard capable de vous dire tout ce quil fait, quand il le fait, et avec quoi il la fait. Cependant, Log4Net expose inniment plus de possibilits que celles que nous
Chapitre 9
avons vues. Nhsitez pas regarder la documentation de Log4Net et faire toutes sortes de tests et dessais pour connatre son comportement.
Chapitre 9
Quelquun qui ne connat pas du tout le Visual Basic peut se retrouver perdu. Pour aider ces personnes, il est judicieux dajouter quelques commentaires qui permettront de mieux comprendre les mthodes.
Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer Retourne laddition entre x et y Cette opration se fait sur nombres entiers Return x + y End Function Public Function Substract(ByVal x As Integer, ByVal y As Integer) As Integer Retourne la soustraction entre x et y Cette opration se fait sur nombres entiers Return x - y End Function Public Function Times(ByVal x As Integer, ByVal y As Integer) As Integer Retourne la multiplication entre x et y Cette opration se fait sur nombres entiers Return x * y End Function Public Function Divide(ByVal x As Double, ByVal y As Double) As Double Retourne la division entre x et y Cette opration se fait sur nombres dcimaux En effet, le rsultat dune division ntant pas exact, il est prfrable de travailler avec des Double Return x / y End Function
Cette tape est dj pertinente, car de cette manire quelquun qui ne connat pas le Visual Basic peut lire les commentaires et comprendre le rsultat des mthodes. De plus, ces commentaires expliquent pourquoi laddition, la multiplication et la soustraction travaillent sur des nombres entiers, alors que la division travaille avec des nombres dcimaux. Or, dans ce cas, il faut absolument que cette personne ait le code de votre application pour comprendre ce que vous avez voulu faire. Il existe cependant un moyen de produire une documentation externe votre programme, de manire pouvoir lexploiter sans possder le code.
Chapitre 9
La documentation XML
Le framework .Net et Visual Studio permettent de produire cette documentation en utilisant le format XML. Il faudra alors dnir pour chacune de vos mthodes une portion XML correspondant votre documentation. crivez trois apostrophes ("") au-dessus dune de vos mthodes :
<summary> </summary> <param name="x"></param> <param name="y"></param> <returns></returns> <remarks></remarks> Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer Retourne laddition entre x et y Cette opration se fait sur nombres entiers Return x + y End Function
Visual Studio va ajouter automatiquement des balises XML vous permettant de dcrire vos applications. Il ne vous restera alors plus qu la remplir.
j j
j j
pourrez y dcrire le traitement effectu par votre mthode. Param est la balise qui vous permettra de dcrire les arguments de votre mthode. Le nom du paramtre est dj marqu pour vous permettre de savoir quel argument vous tes en train de dcrire. Returns vous permet de dcrire le rsultat de votre mthode. Dans la balise Remarks, vous pouvez marquer tout autre commentaire que vous jugerez utile.
Chapitre 9
Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer Retourne laddition entre x et y Cette opration se fait sur nombres entiers Return x + y End Function
Maintenant, si vous compilez votre projet, vous trouverez dans le dossier de sortie un chier XML contenant votre documentation.
<member name="M:TestAppliBackgroundWorker.Form1.Add(System .Int32,System.Int32)"> <summary> Cette mthode effectue une addition entre deux entiers </summary> <param name="x">Premier membre de lopration</param> <param name="y">Deuxime membre de lopration</param> <returns>Le rsultat de laddition, qui est une opration entire</returns> <remarks>Nous avons fait une opration entire car une addition entre 2 entiers sera toujours entire< /remarks> </member>
Maintenant, mme si le format XML nest pas le plus lisible du monde par un tre humain, vous possdez quand mme un chier indpendant de votre programme qui permettra une personne extrieure de comprendre ce que vous avez voulu faire. Vous devez maintenant renseigner toutes les oprations :
<summary> Cette mthode effectue une addition entre deux entiers </summary> <param name="x">Premier membre de lopration</param> <param name="y">Deuxime membre de lopration< /param> <returns>Le rsultat de laddition, qui est une opration entire</returns> <remarks>Nous avons fait une opration entire car une addition entre 2 entiers sera toujours entire</remarks> Public Function Add(ByVal x As Integer, ByVal y As Integer) As Integer Retourne laddition entre x et y Cette opration se fait sur nombres entiers Return x + y End Function
Chapitre 9
<summary> Cette mthode effectue une soustraction entre deux entiers </summary> <param name="x">Premier membre de lopration< /param> <param name="y">Deuxime membre de lopration< /param> <returns>Le rsultat de la soustraction, qui est une opration entire</returns> <remarks>Nous avons fait une opration entire car une soustraction entre 2 entiers sera toujours entire Cependant, le rsultat peut tre ngatif si x est plus grand que y</remarks> Public Function Substract(ByVal x As Integer, ByVal y As Integer) As Integer Retourne la soustraction entre x et y Cette opration se fait sur nombres entiers Return x - y End Function <summary> Cette mthode effectue une multiplication entre deux entiers </summary> <param name="x">Premier membre de lopration< /param> <param name="y">Deuxime membre de lopration< /param> <returns>Le rsultat de la multiplication, qui est une opration entire</returns> <remarks>Nous avons fait une opration entire car une multiplication entre 2 entiers sera toujours entire Cependant, le rsultat peut tre ngatif si un des nombres est ngatif</remarks> Public Function Times(ByVal x As Integer, ByVal y As Integer) As Integer Retourne la multiplication entre x et y Cette opration se fait sur nombres entiers Return x * y End Function <summary> Cette mthode effectue une division entre deux nombres dcimaux </summary> <param name="x">Premier membre de lopration< /param> <param name="y">Deuxime membre de lopration< /param>
Chapitre 9
<returns>Le rsultat de la division, qui est une opration dcimale</returns> <remarks>Nous avons fait une opration dcimale car une division entre 2 nombres peut tre dcimale De plus, le rsultat peut tre ngatif si un des nombres est ngatif</remarks> Public Function Divide(ByVal x As Double, ByVal y As Double) As Double Retourne la division entre x et y Cette opration se fait sur nombres dcimaux En effet, le rsultat dune division ntant pas exact, il est prfrable de travailler avec des Double Return x / y End Function
Vous aurez maintenant un chier de documentation XML complet propos de votre projet.
<member name="M:TestAppliBackgroundWorker.Form1.Add(System .Int32,System.Int32)"> <summary> Cette mthode effectue une addition entre deux entiers </summary> <param name="x">Premier membre de lopration</param> <param name="y">Deuxime membre de lopration</param> <returns>Le rsultat de laddition, qui est une opration entire</returns> <remarks>Nous avons fait une opration entire car une addition entre 2 entiers sera toujours entire< /remarks> </member><member name="M:TestAppliBackgroundWorker.Form1 .Substract(System.Int32,System.Int32)"> <summary> Cette mthode effectue une soustraction entre deux entiers </summary> <param name="x">Premier membre de lopration</param> <param name="y">Deuxime membre de lopration</param> <returns>Le rsultat de la soustraction, qui est une opration entire</returns> <remarks>Nous avons fait une opration entire car une soustraction entre 2 entiers sera toujours entire Cependant, le rsultat peut tre ngatif si x est plus grand que y</remarks> </member><member name="M:TestAppliBackgroundWorker.Form1 .Times(System.Int32,System.Int32)"> <summary> Cette mthode effectue une multiplication entre deux entiers
Chapitre 9
</summary> <param name="x">Premier membre de lopration</param> <param name="y">Deuxime membre de lopration</param> <returns>Le rsultat de la multiplication, qui est une opration entire</returns> <remarks>Nous avons fait une opration entire car une multiplication entre 2 entiers sera toujours entire Cependant, le rsultat peut tre ngatif si un des nombres est ngatif</remarks> </member><member name="M:TestAppliBackgroundWorker.Form1 .Divide(System.Double,System.Double)"> <summary> Cette mthode effectue une division entre deux nombres dcimaux </summary> <param name="x">Premier membre de lopration</param> <param name="y">Deuxime membre de lopration</param> <returns>Le rsultat de la division, qui est une opration dcimale</returns> <remarks>Nous avons fait une opration dcimale car une division entre 2 nombres peut tre dcimale De plus, le rsultat peut tre ngatif si un des nombres est ngatif</remarks> </member><member name="M:TestAppliBackgroundWorker.Form1 .BackgroundCount"> <summary> Mthode de comptage utilisant un BackgroundWorker </summary> <remarks></remarks> </member>
Bon, ce ntait dj pas tellement lisible sur une mthode Maintenant quil y en a quatre, ce nest plus du tout possible de comprendre quoi que ce soit. Heureusement quil existe des outils capables danalyser les chiers de documentation XML pour en faire des chiers plus lisibles pour un homme.
Le logiciel NDoc
Le logiciel de rfrence pour analyser les chiers de documentation XML et les transformer en chier daide est NDoc. partir de votre DLL et du chier de documentation XML qui a t gnr, NDoc pourra vous fournir une documentation dans diffrents formats. Dj, prparons le projet.
Chapitre 9
2 Crez une nouvelle classe et mettez-y le code cr prcdemment. Compilez. Vous devriez avoir plusieurs chiers dans le rpertoire de sortie.
Chapitre 9
Laissons l un instant le code pour vous procurer NDoc. Le site officiel est http://ndoc.sourceforge.net/. Vous pourrez y trouver de nombre daides et de dtails propos de cette application. Cependant, la version officielle de NDoc nest pas compatible avec le framework .Net version 2.0. Fort heureusement, la communaut (NDoc est un projet OpenSource) a cr un portage pour la version 2 du framework .Net. En revanche, ce portage nest pas officiel, et la version existante nest pas stable. Mais elle permet quand mme un nombre dactions suffisant pour tre intressante. Vous pourrez lobtenir sur le site http://www.kynosarges.de/NDoc.html. NDoc ncessite une application de Microsoft : HTML Help Workshop. Il faudra vous la procurer avant de pouvoir utiliser NDoc. Elle est disponible ladresse http://www.microsoft.com/downloads/details .aspx?FamilyID=00535334-c8a6-452f-9aa0-d597d16580cc&displaylang=en. Une fois NDoc tlcharg et dcompress, excutez le chier
Ndocgui.exe.
De nombreuses options sont congurables dans NDoc. Il nest pas ncessaire de sy attarder pour linstant. Cependant, dans la liste
264 LE GUIDE COMPLET
Chapitre 9
droulante, slectionnez MSDN-CHM. Vous aurez de cette manire un chier CHM proche de la documentation MSDN de Microsoft.
Maintenant, nous allons ajouter votre application pour que NDoc cre sa documentation. Pour cela, cliquez sur Add, et vous arriverez sur un menu o vous devrez slectionner la DLL.
Chapitre 9
En cliquant sur "" vous pourrez choisir votre DLL via un explorateur de chiers.
Quand vous aurez slectionn la DLL, NDoc cherchera automatiquement le chier de documentation XML au mme endroit. Faites OK pour valider lajout de votre DLL.
Vous revenez maintenant sur lcran principal de NDoc, avec votre DLL qui a t ajoute la liste des projets documenter. Pour lancer la cration de la documentation, il ne vous reste plus qu cliquer sur Build docs.
Chapitre 9
Vous pourrez voir le droulement grce la ProgressBar de linterface de NDoc, qui redeviendra normale une fois lopration termine.
La documentation gnre se trouve dans le dossier doc de NDoc. Elle sappelle Documentation.chm.
Chapitre 9
Maintenant, tout simplement en double-cliquant sur ce chier, vous pouvez voir le rsultat produit par NDoc.
Chapitre 9
Reconnaissez quelle a un aspect trs propre et trs professionnel. Pourtant, vous conviendrez que cette tape na pas t particulirement difficile. Elle demande un peu de mthode et de mthodologie, un bon outil et un peu de bonne volont. Vos utilisateurs et vos collaborateurs vous en remercieront car, grce cela, ils nauront pas besoin de dcortiquer votre code pour savoir ce que vous avez voulu faire (aussi tents quils soient, ce qui nest pas toujours le cas). Merci, NDoc !
Il y a autant de processus que de programmes, et chacun deux peut faire quelque chose de diffrent. Un peut faire du calcul, lautre, de laffichage, un autre peut mme tre un jeu complet.
1 Appuyez sur [Ctrl]+[Alt]+[Supp], et allez dans le gestionnaire des tches de Windows. Puis allez dans longlet Processus. Vous verrez la liste des processus qui sont en ce moment excuts sur votre ordinateur.
LE GUIDE COMPLET 269
Chapitre 9
Figure 9.73 :
Comme vous pouvez le voir, normment de programmes (et donc de processus) tournent en mme temps sur votre ordinateur. Peut-tre en connaissez-vous certains ? Mais comment cela se peut-il ? On a vu quun programme tait une liste dinstructions excutes les unes aprs les autres. Cest effectivement le cas, sauf que votre systme dexploitation (ici Windows) leur fait excuter leurs instructions tour de rle. Ils passent tous dans une le dattente du systme, puis chacun son tour excute un morceau de programme. Cest ensuite le tour dun autre programme dexcuter ses instructions, et ainsi de suite. Voici un schma des tats dun processus qui sont chargs sur le systme dexploitation (voir Figure 9.74). Le systme dexploitation va donc mettre un processus en sommeil, en activer un autre, le mettre en sommeil, en activer un autre, et ceci pour chacun des processus existants. Et, quand il a ni un tour complet, il recommence. Quel travail passionnant, me direz-vous... Autre question qui se pose. Comment tous ces processus ne se marchent-ils pas sur les pieds ? Supposons quun de nos programmes modie une de ses donnes. On vient de voir quil y avait un certain
Chapitre 9
nombre de processus qui tournaient en mme temps sur notre machine. Or la mmoire de lordinateur est unique. Donc, rien nempche que tel programme ait une donne commune avec tel autre.
L encore, cest le rle du systme dexploitation de grer cela. Celui-ci va rserver un espace mmoire pour chacun des processus an que celui-ci ait ses donnes propres et naille pas embter les autres. Vous avez peut-tre dj eu loccasion de voir une erreur qui disait Access Violation. Cela arrive quand un programme essaie daccder une donne ou un espace mmoire qui ne lui appartient pas. Grce ce mcanisme, encore gr par le systme dexploitation (il en fait, des choses !), les modications faites en mmoire par un programme ne se rpercutent pas sur un autre. Dun autre ct, un programme ne pourra jamais voir directement les donnes dun autre. De plus, tant donn que cest le systme dexploitation qui dcide de la quantit despace mmoire utilise par un programme, vous pourriez avoir une erreur OutOfMemoryException, alors quil vous reste de lespace en mmoire ou sur le disque dur.
Chapitre 9
processus
On voit donc que le rle du systme dexploitation est primordial pour la gestion de vos programmes. Nous savons ce quest un processus ; maintenant, quest-ce quun thread ?
Thread
Un thread est galement un processus, car il excute des instructions. Cependant, il est li un processus principal dont il partage lespace mmoire. On dit que les threads sont des processus lgers.
Un thread est une sorte de sous-processus. Il vit lintrieur dun processus et partage son espace mmoire, cest--dire quil peut voir et agir sur les donnes de son processus pre. Au mme titre quun processus, il est dans la le dattente du systme dexploitation, qui le laissera son tour excuter un certain nombre dinstructions. Maintenant que nous avons dgrossi les concepts de processus et de threads, nous allons voir ce quest le multithreading, quelle est son utilit, mais galement quels problmes cela peut poser. Nous verrons bien sr comment rpondre ces problmes. Comme je le disais en introduction de ce chapitre, le multithreading est un concept trs trs subtil, ainsi quune grosse source derreurs, mme dans des applications professionnelles. utiliser avec beaucoup dattention !
Chapitre 9
Nous verrons ensuite un moyen simple de proter du multithreading pour excuter des instructions en tche de fond, de manire ne pas bloquer lutilisateur. Puis comment ragir sur linterface graphique, de manire pouvoir suivre ce qui est fait par vos threads. Et, enn, comment grer les erreurs dans les threads, car cela peut trs vite devenir le bazar, et vous pouvez chercher des heures la source dun problme qui est en fait d laction dun thread sur un autre qui a provoqu un tat instable qui a fait planter votre programme. Du bonheur en perspective !
Chapitre 9
Les lettres envoyer reprsentent le but de votre programme, ce quil doit faire. Les enveloppes, les adresses et les timbres reprsentent les donnes. Et vous et vos amis tes des threads. (Ne vous inquitez pas, on sy fait bien !)
Chapitre 9
Mais vous avez vu quil a fallu expliquer vos amis ce quil fallait faire. De la mme manire, il vous faudra prparer les threads aux actions quils devront effectuer. De plus, vous avez d partager les enveloppes et les timbres. Pareillement, vous aurez vous arranger pour partager les donnes entre les threads. En revanche, il nest pas impossible quun de vos amis ait utilis vos timbres parce quil nen avait plus ou alors quil ait ni bien avant les autres. Cela peut arriver galement au niveau des threads. Ils ne sarrteront pas en mme temps et pourront tre amens utiliser les mmes donnes. Il sagit l de la problmatique principale du multithreading : laccs concurrent aux donnes. En effet, la principale source derreur lorsque lon traite du multithreading est due des donnes modies par des threads alors quun autre thread sen servait. Imaginez que vous vouliez enregistrer une mission la tlvision. Vous programmez lenregistrement sur une chane donne. Votre conjoint passe par l et change de chane pour regarder son mission. Et vous vous retrouvez avec le programme de cette chane plutt que sur celui que vous vouliez enregistrer. Le problme a t pos par un accs concurrent la tlvision. Vous avez tous les deux voulu lutiliser et le traitement de lun a perturb lautre. Maintenant que nous avons vu la thorie sur ce quest le multithreading, faisons une application pour illustrer concrtement ce qui se passe.
Application explicative
1 Tout dabord, crons un nouveau projet (voir Figure 9.76). 2 On lappellera AppliTestMultiThread. Ce sera une application Console simple pour prsenter le concept de multithreading (voir Figure 9.77).
Chapitre 9
Dans un premier temps, notre application ne fera que boucler sur une valeur et lcrire. Elle marquera ensuite la n du programme, que nous nirons par un ReadLine pour que la fentre ne disparaisse pas tout de suite.
Sub Main() Dim count As Integer = 0
Chapitre 9
For i = 1 To 20 Traitement faire 100X count += 1 Console.WriteLine("Dans le thread principal, i = " & i.ToString) Next i Console.WriteLine("Jai fini sans problme le thread principal. Nombre de traitement = " & count.ToString) Console.ReadLine() End Sub
Utilisons maintenant dans ce mme programme un autre thread qui va faire la mme chose. Pour cela, il faut dclarer une mthode qui sera le point dentre du thread, cest--dire la premire quil va excuter. Dans notre cas, on aura une mthode qui fera la mme boucle que celle du programme principal en prcisant que cest celle du thread secondaire.
Sub MakeLoop() Dim count As Integer = 0 For i = 1 To 20 count += 1 Console.WriteLine("Dans le thread secondaire, i = " & i.ToString) Next i
Chapitre 9
Console.WriteLine("Jai fini sans problme le thread secondaire. Nombre de traitement = " & count.ToString) End Sub
Maintenant, pour utiliser un nouveau thread, il suffit tout simplement de linstancier en prcisant son point de dpart, ici notre mthode MakeLoop. Il faut pour cela utiliser le mot-cl AddressOf suivi du nom de la mthode qui sera le point dentre. La classe de Thread est dans le namespace Threading. Ensuite, pour excuter le thread il ny a plus qu faire Start.
Imports System.Threading Sub Main() Dim count As Integer = 0 Dim threadSecondaire As New Thread(AddressOf MakeLoop) threadSecondaire.Start() Console.WriteLine("Jai fini sans problme le thread principal. Nombre de traitement = " & count.ToString) Console.ReadLine() End Sub
Chapitre 9
Trs bien, nous avons russi produire du code dans un autre thread. Mais nous remarquons une chose, cest que la phrase de n du thread principal a t crite avant la premire phrase du thread secondaire. Cest tout fait normal. Comme nous lavons vu la prsentation du concept de thread, cest un processus spar. Le processus principal va donc continuer son excution sans attendre le second thread. Celui-ci est bien excut en parallle du premier. Tout cela est trs bien, mais ici on a juste dplac le traitement. Il y a effectivement deux threads, mais il ny en a quun seul qui travaille rellement. Remettons alors notre boucle dorigine dans le programme principal. Cependant, pour que lexemple soit plus parlant, il va falloir ajouter une instruction dans les boucles, Sleep. Cette instruction permet de stopper le thread qui lexcute pendant un instant donn, calcul en millisecondes. En faisant cela, on simule un traitement long, car en ralit faire une boucle de 20 est tellement rapide que lon ne verra pas les subtilits du multithreading.
Sub Main() Dim count As Integer = 0 Dim threadSecondaire As New Thread(AddressOf MakeLoop) threadSecondaire.Start() For count = 1 To 20 count += 1 Thread.Sleep(0) Console.WriteLine("Dans le thread principal, i = " & count.ToString) Next count Console.WriteLine("Jai fini sans problme le thread principal. Nombre de traitement = " & count.ToString) Console.ReadLine() End Sub
MakeLoop et Sleep
Chapitre 9
Vous devriez obtenir un programme qui ressemble ceci (la sortie peut varier dun ordinateur lautre, car elle dpend de la vitesse de traitement de votre systme dexploitation) :
Comme vous pouvez le constater, lexcution dans lun ou lautre des deux threads est un peu alatoire. Tantt cest le premier qui fait huit tours de boucle. Ensuite, ils alternent chacun leur tour. Puis le second thread nit, et donc le premier termine son tour. Jouez maintenant modier les valeurs de Sleep et le nombre de tours de boucle, vous verrez quutiliser deux threads est plus rapide que nen utiliser quun seul pour le mme traitement. Tout se passe ici pour le mieux, on ne voit aucun problme, et pourtant nous avons optimis notre temps de traitement, sans remettre en cause la prennit de notre programme. Facile, il ny a aucune donne commune
Chapitre 9
utilise par nos deux threads. Qu cela ne tienne, i, notre variable de boucle, va devenir une donne globale qui sera commune nos deux threads. (En vrit, ceci nest pas recommand, mais cest pour vous faire toucher concrtement le problme daccs concurrent aux donnes.)
Module Module1 Dim i As Integer rcrire le code de MakeLoop galement Sub Main() Dim count As Integer = 0 Dim threadSecondaire As New Thread(AddressOf MakeLoop) threadSecondaire.Start() For i = 1 To 20 count += 1 Thread.Sleep(0) Console.WriteLine("Dans le thread principal, i = " & i.ToString) Next count Console.WriteLine("Jai fini sans problme le thread principal. Nombre de traitement = " & count.ToString) Console.ReadLine() Endd Sub End Module
Et voici notre sortie : (voir Figure 9.81) Et l, catastrophe... chacun de nos threads a fait la moiti de son travail. Au lieu davoir fait vingt oprations chacun, le premier en a fait treize, le second, huit, pas du tout ce qui tait prvu lorigine. Cest l un problme daccs concurrent aux donnes, mais nous allons voir que lon peut y remdier.
Chapitre 9
Chapitre 9
Vous et lautre client tes des threads (vous vous y faites mieux la deuxime fois ?). La cassette reprsente la donne partage. Et notre solution, cest lattente. Cette solution se nomme lexclusion mutuelle. Car, lorsquun thread accde une donne, il en bloque laccs aux autres threads. De cette manire, il assure son traitement et rend ensuite la main.
Pour utiliser cette solution, il nous faut un verrou. Ce sera en fait un objet dans notre programme dont le seul but sera de dire aux threads Attention cest verrouill, personne ne passe. Une instance dObject fera trs bien laffaire. Nous sommes obligs dutiliser un objet supplmentaire car on ne peut pas utiliser comme verrou des objets qui sont amens changer.
Dim locker As Object = New Object()
Maintenant que nous avons un verrou, encore faut-il verrouiller la donne quand on lutilise. Ceci est fait avec le mot-cl SynLock, qui a comme argument lobjet verrou que lon va utiliser. SynLock dnit un bloc dinstructions qui seront toutes excutes sans quaucune modication nait pu tre faite sur le verrou.
Dim locker As Object = New Object() Sub MakeLoop() Dim count As Integer = 0 SyncLock locker For i = 1 To 20 count += 1 Thread.Sleep(0) Console.WriteLine("Dans le thread secondaire, i = " & i.ToString) Next i End SyncLock Console.WriteLine("Jai fini sans problme le thread secondaire. Nombre de traitement = " & count.ToString) End Sub Sub Main() Dim count As Integer = 0
Chapitre 9
Dim threadSecondaire As New Thread(AddressOf MakeLoop) threadSecondaire.Start() SyncLock locker For i = 1 To 20 count += 1 Thread.Sleep(0) Console.WriteLine("Dans le thread principal, i = " & count.ToString) Next i End SyncLock Console.WriteLine("Jai fini sans problme le thread principal. Nombre de traitement = " & count.ToString) Console.ReadLine() End Sub
Voici donc votre programme protg des cas daccs concurrent aux donnes. Le thread principal sexcute. Il excute le thread secondaire et continue son excution. Il verrouille la donne et entame sa boucle. De son ct, le thread secondaire, aprs stre initialis, tente de verrouiller la donne. Or celle-ci a dj t verrouille par le thread principal, donc le thread secondaire attend. Le thread principal nit sa boucle et libre donc le verrou. Il nit ensuite son traitement. Le thread secondaire, qui attendait le verrou, voit celui-ci libr. Il peut alors entamer lexcution de sa boucle. Cest lui maintenant qui a mis le verrou. Il nit sa boucle. Fin du programme. Vous avez tout suivi ? Sinon voici lillustration : (voir Figure 9.82) En revanche, le revers de la mdaille rside dans lattente de libration du verrou. En effet, nous avons bien vu que, pendant le verrou, lun des threads devait attendre lautre. La performance est le prix de la scurit. De plus, dans de plus gros programmes, vous pouvez tre amen utiliser plusieurs verrous. Un problme bien connu dans lutilisation des verrous est celui des verrous mortels : un thread 1 verrouille une donne avec un verrou 1. Un autre thread 2 verrouille une autre donne avec un verrou 2. Mais le thread 1 veut maintenant utiliser une donne verrouille par le verrou 2. Il attend donc. Et, de son ct, le thread 2 veut excuter une instruction sur une donne utilise par le thread 1,
Chapitre 9
donc verrouille par le verrou 1. Thread 1 attend Verrou 2 pour dbloquer Verrou 1, mais Thread 2 attend Verrou 1 pour dbloquer Verrou 2.
Ils ne pourront jamais se dbloquer car lun attend lautre qui attend lun (comme luf et la poule) : ceci est un cas de verrou mortel, ou DeadLock. Vous connaissez maintenant les principales possibilits du multithreading, ainsi que ses problmatiques principales, mais aussi une solution pour y remdier. Nhsitez pas pratiquer et tester les moindres cas particuliers, car le multithreading est une notion bien subtile. Mme des programmeurs professionnels font beaucoup derreurs lorsquils introduisent des threads dans leurs applications. De plus, la nature alatoire de lexcution rend le dbogage trs difficile. La seule vraie technique pour matriser les threads, la curiosit et la
Chapitre 9
pratique : tudier la thorie pour comprendre les principes et les coder pour voir la ralit des choses. Bon courage !
1 Tout dabord, crons un nouveau programme que nous appellerons TestAppliBackgroundWorker. Cette fois-ci, nous ferons une application graphique.
2 Crez une interface graphique contenant au moins une ProgressBar et de quoi dnir un nombre et lancer une action. Voici un modle dont vous pourriez vous inspirer.
Chapitre 9
Crez maintenant une mthode qui va compter. Vous pourrez dnir la limite haute en utilisant votre interface et vous indiquerez ltat davancement dans la ProgressBar.
Public Sub Count() Dim count As Integer = Integer.Parse(TextBox1.Text) ProgressBar1.Maximum = count TextBox2.Text = "Launching count..." For i As Integer = 1 To count ProgressBar1.Value = i TextBox2.Text = "" & i.ToString() Next i TextBox2.Text = "Count finished." End Sub
Maintenant, liez cette mthode votre bouton, excutez votre programme. Avec une petite limite haute, pas de souci :
Le programme va trs vite, mais on voit la ProgressBar dler, le comptage se faire, et enn on voit le message nal.
Chapitre 9
Jusquici tout va bien. Que se passe-t-il avec un nombre beaucoup plus gros, comme 100 000 ou 1 million :
Nous voyons la barre avancer un peu puis, au bout dun moment, vous remarquerez quelle navance plus. Si ce moment-l on essaie de cliquer un peu partout pour voir ce qui se passe, pas de raction, mais un message Not Responding sur la fentre.
Quelle explication cela ? Il se trouve que, si votre programme partage le mme thread que votre lment graphique, tout traitement de votre programme, sil est trop long, peut bloquer laffichage de cet lment graphique. Vous reprendrez la main seulement quand il aura ni son traitement. Dans notre cas, cest le mme thread qui a cr les lments de linterface graphique (le formulaire, le bouton, les labels...) et qui fait le traitement. En effet, nous navons pas encore inclus dans notre programme un quelconque mcanisme de multithreading. Lorsque nous avons test avec 10 comme valeur, pas de souci car le traitement tait assez rapide pour quon ne saperoive pas du blocage de linterface graphique. Mais, ds lors quon a mis une limite maximale plus grande, nous avons senti ce blocage. Nous avons pu voir le dbut de lavancement, car le traitement ntait pas considr comme assez grand pour bloquer laffichage de linterface graphique, mais au moment o il a dpass cette limite il nous est devenu impossible de rcuprer la
Chapitre 9
main. Ce sera possible en n de traitement mais il est impossible den voir le droulement. .Net propose un mcanisme un peu plus volu quun thread, mais tout aussi simple utiliser, qui nous permet dexcuter du code en parallle, de notier de la progression et de naliser lexcution de celui-ci : le BackgroundWorker. Pour ajouter un BackgroundWorker dans votre programme, il vous suffit de lajouter depuis la liste des contrles vers votre interface.
Il apparat maintenant dans votre programme, mais en dehors de votre interface graphique.
Le BackgroundWorker se manie comme un objet normal, avec des proprits, des attributs et des mthodes. La premire chose faire avec
LE GUIDE COMPLET 289
Chapitre 9
le BackgroundWorker est de lautoriser notier sa progression. Sans cette tape, il ne vous sera pas possible dutiliser la mthode ReportProgress, qui permet de donner ltat davancement du BackgroundWorker.
BackgroundWorker1.WorkerReportsProgress = True
La premire chose dnir est laction effectuer. Pour faire ceci, il faut traiter lvnement DoWork du BackgroundWorker. Il suffit daller dans lcran des Proprits et, dans la partie vnement, de cliquer sur la partie DoWork.
En double-cliquant sur cet vnement, Visual Studio vous cre le squelette de la mthode qui va faire laction principale. Dans notre programme, laction principale est de boucler sur une limite haute que vous aurez dnie avant :
Public Sub BackgroundWorker1_DoWork(ByVal sender As System.Object, ByVal e As System.ComponentModel .DoWorkEventArgs) Handles BackgroundWorker1.DoWork Dim i As Integer For i = 0 To max counter = i BackgroundWorker1.ReportProgress(i * 100 / max) Next End Sub
La limite haute, max, devra avoir t dnie pralablement. Ceci se fera lors du Click sur le bouton. Nous verrons un peu plus loin le code de lappel qui contient la cration et le lancement du BackgroundWorker.
Chapitre 9
Nous
remarquons
une
instruction
dont
je
nai
pas
parl :
ReportProgress. Cette instruction correspond la notication de ltat davancement du BackgroundWorker. Cet avancement
correspond un pourcentage. Grce un produit en croix avec la limite haute, on obtient le pourcentage davancement. Cette mthode ReportProgress lance lvnement ProgressChange. Il vous faut maintenant dnir comment va tre trait cet vnement. Pour cela, de la mme manire que pour DoWork, double-cliquez sur lvnement ProgressChange dans la fentre de Proprits. Visual Studio va crer le squelette de la mthode dans laquelle vous pourrez mettre le traitement. chaque nouvelle tape davancement, nous marquerons ltat davancement en cours, et nous ferons avancer la ProgressBar.
Public Sub BackgroundWorker1_ProgressChanged(ByVal sender As System.Object, ByVal e As System .ComponentModel.ProgressChangedEventArgs) Handles BackgroundWorker1.ProgressChanged ProgressBar1.Value = e.ProgressPercentage TextBox2.Text = "" & counter.ToString() End Sub
e.ProgressPercentage correspond au nombre qui aura t pass en argument dans la mthode ReportProgress. Cest comme ceci que vous le retrouverez, ce qui permet de faire le lien entre le traitement principal de votre programme et la notication de lavancement de celui-ci.
Enn, il vous reste dnir laction faire en n de traitement. Une fois encore, un vnement correspond cela : RunWorkerCompleted. Comme pour DoWork et ProgressChange, double-cliquez sur lvnement correspondant dans la fentre de Proprits et Visual Studio vous crera le squelette de la mthode. On y marquera simplement la n de traitement dans le Label de votre programme.
Public Sub BackgroundWorker1_RunWorkerCompleted(ByVal sender As System.Object, ByVal e As System .ComponentModel.RunWorkerCompletedEventArgs) Handles BackgroundWorker1.RunWorkerCompleted TextBox2.Text = "Background count finished." End Sub
Maintenant que lensemble des vnements du BackgroundWorker est dni, il ne reste plus qu prparer son lancement et laffecter au Click du bouton. Cliquez sur le bouton, et double-cliquez sur lvnement Click dans la fentre de Proprits. Dans cette partie, on crera la limite haute pour le comptage, et on lancera le traitement du
Chapitre 9
Accessibilit
Il faudra avoir dni "max" dans une partie du programme accessible par toutes les mthodes.
Nous voyons que le programme sexcute sans bloquer, et nous pouvons suivre lavancement de notre boucle, jusqu sa n. Le BackgroundWorker est rellement un objet simple dutilisation qui permet de proter des bienfaits du multithreading pour excuter une tche en arrire-plan. Si une partie de votre programme doit prendre un peu de temps, il est conseill dutiliser cet objet plutt quessayer de le grer travers des threads, surtout si vous devez agir sur une interface graphique. En effet, avec le framework .Net, la gestion des interfaces graphiques est un peu particulire dans un contexte multithreading. Cest ce que nous allons voir dans la partie qui suit.
Chapitre 9
lutilisateur, faire un traitement de n, et tout cela sans bloquer laffichage et sans perdre dinteractivit sur notre application. Supposons maintenant que ce BackgroundWorker nexiste pas, et essayons dutiliser les autres connaissances apprises dans le chapitre. Vous vous en doutez bien, nous allons utiliser des threads pour effectuer le mme traitement.
TextBox2.Text = "Launching count..." For i As Integer = 1 To count ProgressBar1.Value = i TextBox2.Text = "" & i.ToString() Next i TextBox2.Text = "Count finished." End Sub
Trs bien, maintenant que notre mthode de traitement est cre, il nous faut instancier un thread et lui spcier que son point dentre sera la mthode count :
Chapitre 9
Parfait, il ny a dsormais plus qu lier cette action au Click du bouton de notre interface :
Public Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim thread1 As New Threading.Thread(AddressOf Count) thread1.Name = "ThreadCount" thread1.Start() End Sub
Notre transformation est maintenant prte, notre application va effectuer exactement la mme tche quavec le BackgroundWorker, mais en utilisant directement un thread. On excute :
Chapitre 9
Par lment dinterface graphique, on entend tout objet drivant de la classe Control, tels les Form, Label, Button, ProgressBar, TextBox
Dans notre application, le processus principal cre la fentre. Dun autre ct, nous crons pour faire notre traitement un autre thread qui excutera la mthode Count. Or, dans cette mthode, nous essayons de modier la ProgressBar :
ProgressBar1.Maximum = count
Cependant, nous avons vu quelle avait t cre dans le processus principal. Cest lors de cet accs que le framework se protge et envoie cette fameuse erreur Cross thread exception. ce point-l, nous sommes un peu coincs On ne sait pas dire "Thread 1, fais cette instruction, puis Thread 2, fais cette instruction, et revenons Thread 2". Car ce serait la solution. Nous effectuons le traitement non graphique dans notre thread secondaire, puis au moment de traiter les lments graphiques on repasse dans le thread dorigine. Cest peu prs la solution, sauf quon ne peut pas traiter le passage interthread par instructions. Il faudra le faire partir de mthodes, en utilisant des dlgus.
Chapitre 9
Par exemple, nous avons vu que count modie la ProgressBar. Donc, si le thread qui appelle count nest pas celui qui a cr la ProgressBar, il faudra faire lchange. Le thread qui a cr la ProgressBar va alors excuter count. La mthode qui permet de faire cela est la mthode Invoke. Cest une mthode qui existe pour tous les objets de type Control et qui va renvoyer lexcution dune autre mthode au thread dorigine. Pour pouvoir utiliser Invoke, il faut en revanche crer un dlgu correspondant la mthode Invoker. Reportez-vous ce sujet au chapitre Dialoguez avec un ordinateur.
Public Delegate Sub DelegateCounter()
Nous avons cr le dlgu qui correspond notre mthode count. Maintenant, comme nous savons que notre mthode count va modier la ProgressBar, au moment dappeler count il nous faudra, plutt que le faire directement, utiliser Invoke. Invoke prend comme paramtre la mthode Invoker.
Dim myDelegate As New DelegateCounter(AddressOf Count) ProgressBar1.Invoke(myDelegate)
De cette manire, laccs au Control est scuris. Vous pouvez maintenant excuter de nouveau lapplication, qui pourra se poursuivre jusqu la n.
Count
La mthode count modie galement dautres Control, comme la TextBox ou le Label. Or ces lments ont t crs dans le mme thread que la ProgressBar, donc lInvoke de celle-ci fonctionne galement pour eux.
Chapitre 9
Une bonne pratique concernant lInvoke est lutilisation dune mthode Invoker qui va faire la vrication de la ncessit de lInvoke. En effet, les objets de type Control possdent galement une proprit InvokeRequired qui permet de savoir lexcution sil est ncessaire de faire un Invoke ou non. De cette manire si lInvoke est ncessaire, vous le faites, sinon vous appelez la mthode normalement. Il est recommand de faire ceci car faire un Invoke est gourmand en ressources et peut rduire vos performances. Lutilisation de la proprit InvokeRequired permet dviter de le faire systmatiquement. En dnissant cette vrication dans une autre mthode, vous optimisez vos appels, et il suffit ensuite dappeler lInvoker pour garder la scurit tout en limitant les pertes de performances.
Public Sub Invoker() Dim myDelegate As New DelegateCounter(AddressOf Count) If (ProgressBar1.InvokeRequired) Then ProgressBar1.Invoke(myDelegate) Else Count() End If End Sub
Chapitre 9
Lutilisation dun bloc Try Catch tant cense rattraper les erreurs, au pire, notre mthode count ne sexcutera pas comme il faut, mais au moins elle ne plantera pas lapplication.
Perdu, lapplication a quand mme plant avec une erreur Cross Thread Exception. Pourquoi ?
Try et Catch
Un bloc Try Catch protge des exceptions survenant dans le thread qui a excut ce bloc Try Catch.
Dans notre cas, nous avons un bloc Try Catch qui fait appel un autre thread. Il ny a eu aucun problme dans notre thread principal. Cest notre thread secondaire, qui, en voulant modier un lment graphique quil navait pas cr, a provoqu une erreur.
Chapitre 9
Trs bien, protgeons donc notre second thread en mettant un bloc Try
Catch dans notre mthode count, et excutons de nouveau :
Public Sub Count() Try Dim count As Integer = Integer.Parse(TextBox1 .Text) ProgressBar1.Maximum = count
TextBox2.Text = "Launching count..." For i As Integer = 1 To count ProgressBar1.Value = i TextBox2.Text = "" & i.ToString() Next i TextBox2.Text = "Count finished." Catch ex As Exception Console.WriteLine("il y a eu une erreur dans le thread secondaire") End Try End Sub
Il ne sest rien pass. Rien de visible, en tout cas. De plus, Visual Studio nous a bien fait tat dune erreur Cross Thread Exception. Cependant, lapplication na pas plant, elle est toujours active, ce qui ntait pas le cas prcdemment. Voyons la fentre de sortie.
Chapitre 9
Nous sommes passs dans la partie Catch. Cest une bonne nouvelle, car cela nous montre bien que le thread secondaire a t protg. Ceci nous amne a une conclusion importante.
Protection sur les erreurs
Tous les threads de votre programme doivent grer la protection de leurs erreurs.
Comme nous avons pu le constater tout au long de ce chapitre, la gestion dun contexte multithread est une chose trs subtile. Cependant, elle donne vos applications une nouvelle dimension, car elle permet de bncier dune activit accrue, ainsi que proter du maximum de ressources prsentes sur le systme. Cela demande en contrepartie une rigueur et une attention particulires. Ne vous inquitez pas si cela vous pose des soucis, car mme des professionnels se trouvent rgulirement confronts des erreurs quils ne comprennent pas ou quils ont du mal solutionner cause des threads. Cela demande galement de la pratique et de la curiosit. Nhsitez pas jouer avec les threads, comparer, en ralentir exprs avec la commande Sleep pour voir le comportement, mais tentez aussi de diviser vos applications en soustraitements excutables par plusieurs threads. Elles prendront tout de suite une autre dimension, croyez-moi. Bon courage !
Un album photo .................................................................................................................. 302 Dcouvrir DirectX ............................................................................................................... 319 Un lecteur multimdia ....................................................................................................... 319
Chapitre 10
Vous avez prsent tous les outils en main pour devenir de bons programmeurs. Il ne vous manque plus que la pratique. Comme un musicien, il faut jouer le plus possible de votre instrument. Vous avez vu pour le moment des exemples simples raliser et conus en moins de 15 minutes. partir de maintenant, vous crerez des programmes plus complexes, plus longs concevoir et qui mettent en jeu toutes les notions acquises. Il ny a aucune limite aux applications que vous pouvez produire. Vous allez dans ce chapitre raliser deux applications dont vous pourrez vous servir tous les jours. La premire est un album photo, qui va vous permettre dafficher vos photographies en taille relle, de les faire pivoter, etc. Ensuite, nous introduirons les notions de rfrence et dimportation, qui permettent dutiliser du code dj crit et compil. Puis, nous parlerons de la bibliothque DirectX, qui permet des manipulations multimdias. Ensuite, vous crerez un lecteur multimdia grce auquel vous pourrez couter de la musique et lire des vidos.
Le contrle ListView
Lancez Visual Basic et crez un nouveau projet que vous appellerez Album Photo (voir Figure 10.1).
1 Dans le designer de formulaires, ouvrez la bote outils et ajoutez au formulaire principal un contrle ListView.
Un album photo
Chapitre 10
Listview
La ListView permet, un peu la manire du contrle TreeView vu prcdemment, dafficher une collection dobjets.
Pour le moment la ListView ressemble un rectangle blanc. Cest normal. Ancrez-la gauche du formulaire de manire quelle prenne toute la hauteur du formulaire.
2 Utilisez la proprit Dock en mettant la valeur Left, de sorte que la ListView occupe la gauche du formulaire.
Figure 10.2 :
La ListView
Chapitre 10
3 Ajoutez au formulaire un contrle de type FolderBrowser en le faisant glisser depuis la bote outils. Vous allez utiliser ce contrle pour quau chargement de lapplication, il vous soit demand o sont stockes les photos afficher. 4 Ajoutez une PictureBox au formulaire. Elle servira visualiser les images slectionnes. 5 Une fois la PictureBox ajoute, double-cliquez sur la barre de titre du formulaire, pour vous placer dans lditeur de code lendroit de lvnement correspondant au chargement du formulaire.
Avant dentrer les instructions, prenez quelques minutes pour rchir ce que vous faites. De quoi avez-vous besoin ? Une fois que lutilisateur a choisi le dossier contenant ses images, que faut-il faire ? Il faut commencer par vrier le type des chiers. Pour cela, vous allez rcuprer, pour chaque chier prsent dans le rpertoire de lutilisateur, son extension, et vous assurer quil sagit dun chier JPG. Cette rexion conduit au code suivant :
If FolderBrowserDialog1.ShowDialog = _ Windows.Forms.DialogResult.OK Then For Each fichier As _ String In _ System.IO.Directory.GetFiles( _ FolderBrowserDialog1.SelectedPath) If System.IO.Path.GetExtension(fichier) = ".jpg" Then
La premire ligne correspond au test. Est-ce que lutilisateur a bien cliqu sur le bouton OK pour valider le choix de son rpertoire ? Si oui, vous utilisez une boucle de type For Each pour vrier chaque chier contenu dans le dossier accessible via le chemin donn par lutilisateur. La vrication se fait laide de la mthode GetFiles de lespace de noms System.IO.Directory, qui est un ensemble de mthodes et de fonctions destines faciliter la manipulation des chiers et dossiers. La proprit FolderBroserDialog.SelectedPath renvoie le chemin complet du dossier slectionn, sous forme de chane de caractres. En la passant en paramtre de la mthode GetFiles, vous recevez un tableau de chanes de caractres dont chaque entre correspond un chier du rpertoire.
Un album photo
Chapitre 10
Une fois que vous avez ce tableau, il faut tester chaque entre pour vrier si oui ou non son extension est bien .jpg. Pour cela, vous utilisez une autre mthode de lespace de noms System.IO.Path .GetExtension. Lorsque vous lui donnez en paramtre le chemin daccs au chier, elle compare lextension de ce dernier avec .jpg. Il reste alors crire la suite du test conditionnel. Que se passe-t-il si le chier possde bien une extension de type JPG ? Vous allez tout simplement lajouter la ListView. Il est temps de sintresser ce nouveau contrle.
6 Retournez dans le designer de formulaires. Slectionnez la ListView et affichez la liste de ses proprits. Cherchez la proprit nomme View. Elle reprsente la manire dont vont tre vus les lments de la ListView. Choisissez LargeIcons.
Comme pour le contrle Listbox, chaque lment de la ListView est un Item et possde des proprits et des mthodes qui vont vous faciliter la tche.
7 Revenez lditeur de code. Vous avez la condition de test, il faut remplir les instructions si le test russit.
Chapitre 10
Pour chacun des chiers du rpertoire de type JPG, il va falloir un objet de type Item correspondant dans la ListView.
8 Si le test russit, vous crez un objet de type ListViewItem qui va contenir limage.
Dim MonImage As ListViewItem = ListView1.Items .Add(fichier) MonImage.Name = fichier MonImage.Text = System.IO.Path .GetFileNameWithoutExtension(fichier) End If
La premire chose faire est de dclarer une nouvelle variable de type ListViewItem (voir la premire ligne). Dans la mesure o il est ncessaire dinitialiser cette variable, vous faites dune pierre deux coups en linitialisant avec la chane de caractres que reprsente la variable Fichier et vous lajoutez directement la collection Items de la ListView avec la mthode Add(). La deuxime ligne permet de faire un lien entre le chier sur lappareil photo ou le disque dur et le nom de lobjet ListViewItem dans le contrle ListView. Ce nom permet galement didentier limage de manire unique. Une fois ajout cet objet la ListView, vous allez modier sa proprit Text, pour afficher un nom de photo plus facile retenir que le chemin complet. La proprit GetFileNameWithoutExtension permet de rcuprer uniquement le nom du chier dont le chemin est pass en paramtre. Noubliez pas de fermer la boucle conditionnelle, ce qui est fait en dernire ligne.
9 Lancez lapplication avec la touche [F5]. 10 Au lancement, la slection du rpertoire contenant les photos est propose. Slectionnez un rpertoire contenant des images au format JPG, et cliquez sur le bouton OK (voir Figure 10.4).
Si vous navez pas dimage votre disposition, vous pouvez en tlcharger ladresse www.flickr.com/photos/splashworld/. La ListView devrait tre remplie par les noms de tous les chiers JPG. Cela dit, afficher le nom des images, cest bien, mais afficher les images, ce serait mieux !
Un album photo
Chapitre 10
11 Quittez lapplication et revenez au designer de formulaires. 12 Slectionnez le contrle ListView et affichez la fentre des proprits, pour modier les vnements. Double-cliquez sur la case vide droite de lvnement "clic" de la ListView. Une fois dans lditeur de code, entrez linstruction suivante :
PictureBox1.Image = Image.FromFile(ListView1 .SelectedItems.Item(0).Name)
Cette instruction va gnrer en mmoire une image partir du chemin du chier associ llment de la ListView actuellement slectionn. Dans la mesure o plusieurs objets de la ListView peuvent tre slectionns, il faut afficher dans la PictureBox uniquement le premier dentre eux. Cela explique lutilisation de lindex 0 de la collection SelectedItems.
13 Relancez lapplication avec [F5]. 14 Lorsque vous cliquez sur un lment de la ListView, il saffiche dans la PictureBox (voir Figure 10.5). 15 Pour le moment tout se passe bien. Mais si au cours de lexcution, il vous prend lenvie de changer de rpertoire pour visualiser dautres photos ? Dans la situation actuelle, il faudrait redmarrer lapplication pour choisir un nouveau dossier, ce qui est fort peu pratique. Ajoutez un contrle Button au formulaire dans le designer, puis double-cliquez dessus pour vous placer dans le code de lvnement "clic" du bouton.
LE GUIDE COMPLET 307
Chapitre 10
Vous avez dj un contrle FolderBrowserDialog dans le projet, il est donc inutile den ajouter un autre.
16 Recopiez le code suivant, qui a pour but de rutiliser tous les contrles existants.
If FolderBrowserDialog1.ShowDialog = _ Windows.Forms.DialogResult.OK Then For Each fichier As String In _ System.IO.Directory.GetFiles( _ FolderBrowserDialog1.SelectedPath) If System.IO.Path.GetExtension(fichier) = _ ".jpg" Then Dim MonImage As ListViewItem = _ ListView1.Items.Add(fichier) MonImage.Name = _ fichier MonImage.Text = _ System.IO.Path.GetFileNameWithoutExtension(fichier) End If Next End If
Un album photo
Chapitre 10
Vous ralisez ici les mmes vrications et les mmes allocations que lors du lancement du programme. Chaque image du nouveau rpertoire est ajoute la ListView. Maintenant que vous avez un programme simple et complet, compliquez-le un peu en lui ajoutant des fonctionnalits. Par exemple, dans la colonne des noms des photos, insrez un aperu des documents. En ltat actuel des choses, il parat difficile de remplacer le nom de limage par une version miniature de limage elle-mme. La premire ide qui viendrait lesprit serait dajouter une PictureBox dans le contrle ListView, et ce pour chaque image quelle contient. Dune part, cela ne fonctionne pas, et dautre part, il est impossible de connatre lavance le nombre de photos quun utilisateur aura dans un dossier. Ce nest donc pas une bonne ide
Le contrle ImageList
La bonne mthode consiste utiliser le contrle ImageList.
ImageList
Une ImageList est un contrle qui permet de constituer une liste dimages. Vous pouvez utiliser cette liste avec dautres contrles contenant des collections dlments pour mettre en relation un objet et une image de la liste. Cette mise en relation est faite par un index qui caractrise la position de limage dans la liste. Les images de la liste constituant une collection, lindex du premier lment est 0.
Comme les lments que vous ajoutez dans la ListView possdent galement un index, il suffit de synchroniser les ajouts dans la ListView et dans lImageList pour quun lment ait le mme index dans les deux collections. Passons la pratique.
Chapitre 10
Retournez au code de chargement de lapplication en double-cliquant sur la barre de titre dans le designer de formulaires et remplacez le code par le suivant :
If FolderBrowserDialog1.ShowDialog = Windows.Forms .DialogResult.OK Then For Each fichier As String In System.IO.Directory .GetFiles(FolderBrowserDialog1.SelectedPath) If System.IO.Path.GetExtension(fichier) = ".jpg" Then Dim MonImage As ListViewItem = ListView1.Items .Add(fichier) MonImage.Name = fichier MonImage.Text = System.IO.Path .GetFileNameWithoutExtension(fichier) ImageList1.Images.Add(Image.FromFile(fichier)) MonImage.ImageIndex = MonImage.Index End If Next End If
Les deux nouvelles instructions ncessaires la synchronisation de limage et de son aperu sont les deux dernires lignes de la boucle For Each.
ImageList1.Images.Add(Image.FromFile(fichier)) MonImage.ImageIndex = MonImage.Index
Un album photo
Chapitre 10
La premire ajoute une image lImageList en utilisant la mthode FromFile de lobjet Image. Ce dernier est fourni par le Framework .NET 2.0, qui permet la manipulation dimages, ou encore comme ici, le chargement dune image partir du chemin dun chier. La deuxime donne limage dans la ListView un ImageIndex, qui est un nombre entier reprsentant limage utiliser dans lImageList. Dans ce cas, limage est ajoute simultanment dans lImageList et dans la ListView, lindex est donc le mme. Cest pourquoi vous associez le numro dindex MonImage.Index la proprit ImageIndex. Une question se pose alors. Si vous pouvez ajouter une image dans la
ListView, pourquoi garder la PictureBox sur le formulaire ? Simplement parce que lImageList nest faite que pour afficher des miniatures. La PictureBox dispose de contrles plus appropris laffichage dimages.
2 Revenez au designer de formulaires et slectionnez la ListView. 3 Affichez la fentre des proprits et cherchez la proprit nomme LargeImageList. 4 Cliquez sur le menu droulant droite et choisissez ImageList1, qui reprsente la liste.
5 Lancez lapplication. Slectionnez le rpertoire dimages, puis cliquez sur OK. Normalement le programme met lgrement plus longtemps pour se charger. Cela est d au fait quil faut charger les miniatures de chaque image dans la mmoire de votre
Chapitre 10
ordinateur une bonne fois pour toutes. Ensuite, le programme affiche les miniatures des images gauche, et droite la PictureBox contenant limage slectionne.
Si vous dsirez changer la taille des miniatures, retournez dans le designer de formulaires, puis cliquez sur ImageList1 en bas du designer. Affichez la fentre des proprits puis cherchez la proprit nomme ImageSize. La taille par dfaut est initialise 16;16.
Un album photo
Chapitre 10
Changez ces deux valeurs, qui reprsentent respectivement la hauteur et la largeur des miniatures. Par exemple, inscrivez 128;128, en insrant le caractre de sparation qui est un point-virgule.
Les couleurs
Pour que les miniatures soient plus belles, vous pouvez changer la profondeur de lespace couleur utilis pour les reprsenter en modiant la proprit ColorDepth du contrle ImageList. Attention, les performances de lapplication sont directement lies la taille des ressources qui lui sont alloues. En clair, plus les miniatures seront grandes, plus lapplication mettra de temps se charger. Si vous tes photographe professionnel et que les rpertoires contiennent plusieurs centaines dimages, le chargement des miniatures chaque changement de rpertoire risque de devenir handicapant.
Lancez lapplication avec [F5] pour constater les changements (voir Figure 10.11). Il est temps prsent de tester toutes les possibilits du programme. Cliquez sur le bouton 1 et slectionnez un nouveau rpertoire pour en afficher les images. Remarquez que les images ne viennent pas remplacer celles dj prsentes, mais sajoutent la liste dimages. Cette fonctionnalit peut se rvler intressante, mais ce nest pas exactement ce que vous voulez. Transformer un mauvais comportement dun logiciel en une fonctionnalit supplmentaire est une mauvaise habitude ! Par consquent, corrigez ce comportement.
Chapitre 10
Le problme vient du fait que lorsque vous modiez le code excut lors du clic sur le bouton est le mme que lors du chargement du programme. Allez dans lditeur de code en double-cliquant partir du designer. Remplacez le code par celui-ci :
If FolderBrowserDialog1.ShowDialog = _ Windows.Forms.DialogResult.OK Then ListView1.Items.Clear() ImageList1.Images.Clear() For Each fichier As String In _ System.IO.Directory.GetFiles( _ FolderBrowserDialog1.SelectedPath) If System.IO.Path.GetExtension(fichier) _ = ".jpg" Then Dim MonImage As ListViewItem = _ ListView1.Items.Add(fichier) MonImage.Name = fichier MonImage.Text = System.IO.Path .GetFileNameWithoutExtension(fichier) ImageList1.Images.Add(Image.FromFile(fichier)) MonImage.ImageIndex = MonImage.Index End If Next End If
Un album photo
Chapitre 10
La diffrence se situe juste aprs le clic sur le bouton OK. Deux instructions sont ajoutes :
ListView1.Items.Clear() ImageList1.Images.Clear()
La premire vide tous les lments de la ListView. La deuxime rpte lopration, mais avec la liste dimages comme cible. Une fois cela fait, les deux contrles rcuprent la liste des images quils doivent enregistrer. Lajout marche parfaitement. Si vous le souhaitez, reprenez le code sans les modications et placez-le dans un autre bouton. Vous aurez ainsi un bouton dajout dimage disponible lors de la sance de visualisation en cours et un bouton de vidage des listes. Vous avez maintenant une application de visualisation dimages presque complte. Vous allez ajouter une fonctionnalit apprcie : la rotation dimage.
1 Commencez par ajouter au projet un deuxime formulaire. Pour cela, choisissez Ajouter un nouvel lment dans le menu Projet.
Chapitre 10
Dans le designer de formulaires, ajoutez un contrle PictureBox, destin accueillir limage une fois la rotation effectue.
2 Une fois la PictureBox ajoute, slectionnez-la et affichez ses proprits. 3 Dans les vnements, reprez celui qui est nomm Paint.
vnement Paint
Un album photo
Chapitre 10
Vous allez donner les instructions pour que limage afficher subisse une rotation de 90 degrs dans le sens des aiguilles dune montre.
La premire ligne sert rcuprer limage qui est affiche dans le premier formulaire, donc limage courante. Ensuite, il faut initialiser une variable de type Graphics. Elle va servir dessiner sur lespace de la PictureBox. Cest la ruse dont il tait question plus haut. La PictureBox ne permet pas directement la modication des images, il faut donc passer limage courante en mmoire, la modier, et faire appel au moteur de dessin des formulaires pour afficher la version modie. Limage est prsent en mmoire et vous pouvez dessiner sur sa surface. Il faut faire pivoter le document. Pour cela, il faut passer par une matrice de transformation. Rassurez-vous, il est inutile de ressortir vos cours de mathmatiques du lyce, tout est automatis. Il faut dclarer une variable de type Matrix qui va servir de support la transformation. Pour dclarer un objet de type Matrix, vous devez effectuer une importation de lespace de noms System .Drawing.Drawing2D. Pour cela, ajoutez la ligne suivante tout en haut du chier du formulaire dans lditeur de code (elle doit devenir la premire ligne du chier) :
Imports System.Drawing.Drawing2D
Cela fait, vous dclarez une rotation de la matrice M laide de la mthode Rotate.
M.RotateAt(90, New PointF(Width / 2, Height / 2))
Cette instruction prcise quune rotation est effectue. Les paramtres de la mthode dnissent langle (ici 90 degrs) et lorigine de la rotation (ici le centre de la PictureBox).
Chapitre 10
Une fois la matrice dnie, il faut prciser au programme quil sagit de la matrice de transformation de lespace graphique G, ce qui se fait par la ligne suivante :
g.Transform = M
La dernire ligne fait appel la mthode Draw de llment Graphics, qui permet deffectuer rellement le dessin.
5 Il reste appeler le deuxime formulaire partir du premier. Revenez au designer de votre premier formulaire en cliquant sur celui-ci dans lExplorateur de solutions. Ajoutez un contrle Button et double-cliquez sur ce dernier pour vous placer dans lditeur. 6 Ajoutez le code suivant :
Dim form2 As Rotation90 form2 = New Rotation90 form2.Show()
Dans cet exemple, le deuxime formulaire du projet est renomm en Rotation90, ces deux lignes ayant pour but de gnrer une fentre de ce type suite un clic du bouton 2. Lancez lapplication en appuyant sur [F5]. Choisissez une image dans la ListView de gauche, puis cliquez sur le bouton 2. Limage ayant subi une rotation de 90 degrs vers la droite saffiche dans un nouveau formulaire.
Un lecteur multimdia
Chapitre 10
Vous pouvez reprendre ce principe et ajoutez dautres boutons de rotation qui correspondrait aux angles de 90 et 180 degrs. Vous pouvez mme imaginer une TrackBar qui permette de dnir langle de la rotation.
7 La dernire fonction ajouter est la fermeture simplie du deuxime formulaire. Dans le designer du deuxime formulaire, double-cliquez sur la PictureBox. Une fois dans lditeur, ajoutez la ligne suivante :
Me.Close()
Cela aura pour effet de fermer le formulaire quand vous cliquerez sur limage. Vous verrez qu la longue, cest pratique !
1 Dans lExplorateur de solutions, cliquez du bouton droit sur le nom du programme et slectionnez Ajouter une rfrence.
Chapitre 10
2 Dans la longue liste des rfrences disponibles, slectionnez Microsoft.DirectX.AudioVideoPlayback. Vous pourrez ainsi utiliser les fonctions permettant de diffuser des chiers audio et vido. Ajoutez un menu lapplication.
320 LE GUIDE COMPLET
Un lecteur multimdia
Chapitre 10
3 Ajoutez un bouton et appelez-le Jouer un fichier audio. 4 Double-cliquez sur le bouton et une fois dans lditeur, ajoutez le code suivant :
If OpenFileDialog1.ShowDialog = Windows.Forms .DialogResult.OK Then Dim PlayAudio As New Microsoft.DirectX .AudioVideoPlayback.Audio(OpenFileDialog1 .FileName) PlayAudio.Play() End If
Ce code dclare un nouvel objet de type audio, puis le joue. Pour le moment, vous ne pouvez pas stopper la lecture du morceau. Pour ce faire, crez votre propre classe. Implmentez ensuite les mthodes appropries. Lisez ce sujet le chapitre Passer au niveau suprieur. Le chier se joue via un appel la mthode Play() de lobjet audio. Une mthode Stop() permet darrter la lecture en cours. Passons la vido. La lecture de la vido se faire de la mme manire.
5 Ajoutez un bouton au formulaire et ditez son code. Insrez les lignes suivantes :
If OpenFileDialog1.ShowDialog = Windows.Forms .DialogResult.OK Then Dim PlayVideo As New Microsoft.DirectX .AudioVideoPlayback.Video(OpenFileDialog1 .FileName) PlayVideo.Play() End If
La vido se lance dans une fentre part. Comme pour laudio, il nest pas possible de la stopper, moins de raliser une classe part dans laquelle vous grerez toutes les proprits dune vido. Vous pouvez ajouter des fonctionnalits au lecteur multimdia. Par exemple, lajout dune ListBox permettrait lutilisation dune liste de lecture. Si vous reprenez la mthode de lecture des chiers dun rpertoire de lexemple prcdent, vous pouvez jouer tout le contenu multimdia dun rpertoire ! Rappelez-vous que les seules limites du programme sont celles de votre imagination.
LE GUIDE COMPLET 321
Chapitre 11
Vous avez appris raliser des applications Windows. Vous allez voir comment tous les concepts peuvent sappliquer la ralisation de sites Internet. En lisant ce chapitre, vous serez mme de mettre en ligne votre propre blog. Vous apprendrez raliser une page web de manire classique, puis lui ajouter du contenu dynamique pour nir par mettre en pratique tout ce que vous avez dj vu sur les applications Windows pour crer une interface riche sur votre site.
Copiez ces quelques lignes dans votre diteur de texte favori et enregistrez le chier en lui donnant lextension .html. Vous prcisez ainsi votre systme dexploitation que le chier que vous venez denregistrer est une page web. Si vous double-cliquez sur ce chier, il souvrira dans votre navigateur web en affichant "Bonjour tout le monde" (voir Figure 11.1). Quand vous ouvrez le chier, votre navigateur fait une lecture ligne par ligne en interprtant les couples de balises places dans le chier. Remarquez que chaque couple de balises est compos dune balise <NomDeLaBalise> et dune balise fermante ouvrante </NomDeLaBalise>. De cette manire, votre navigateur sait comment afficher ce qui se trouve entre les balises.
Le langage HTML
Chapitre 11
Analysons maintenant le chier dans le dtail. Bien que la page affiche soit des plus lmentaires, elle respecte un format qui est celui de toutes les pages web du monde, et ce depuis plus de 30 ans. La premire ligne contient une balise HTML, qui spcie au navigateur quil sagit dune page formate dans ce langage. La particularit de cette balise est de dlimiter la zone de la page qui sera affiche dans le navigateur. Normalement, tout ce qui est plac en dehors du couple de balise HTML nest pas interprt par le navigateur.
Les navigateurs
Les navigateurs rcents autorisent une certaine largesse vis--vis des conventions et affichent parfois le texte en dehors des balises. Ces tolrances ne sont pas forcment propres tous les navigateurs. Attention donc respecter les normes.
La deuxime balise, HEAD, sert ouvrir une zone qui permet de dnir un lot dinformations concernant la page. Ces informations ne sont pas ncessairement affiches. Dans cet exemple, vous ajoutez lintrieur des deux balises HEAD, deux balises TITLE. Ces deux balises permettent de dnir un titre pour la page, qui sera affich dans la barre de titre de la fentre. Ici cest la chane de caractre "Ma premire page". Une fois la balise TITLE ferme, il ne faut pas oublier de refermer la balise HEAD et ainsi de dlimiter la n de la zone den-tte. Une fois cela fait, vous avez spci toutes les informations ncessaires pour que le navigateur sache ce quil faut afficher.
Chapitre 11
Aprs len-tte de la page, il faut passer au corps. Pour prciser la zone de corps de page, il convient dutiliser le couple de balises BODY. Entre ces balises, vous crivez tout ce qui doit tre affich dans le navigateur. Il sagit ici de la simple phrase "Bonjour tout le monde". Il convient ensuite de fermer la balise BODY dans la mesure o le corps de la page a ni dtre dcrit, vu que vous navez plus rien ajouter. Vous dclarez la n du document HTML avec une balise fermante </HTML>.
2 Crez ensuite une deuxime page, dans le mme dossier que la prcdente, avec le code suivant :
<HTML> <HEAD> <TITLE>Ma page lie/TITLE> </HEAD> <BODY> Bienvenue sur la deuxime page. </BODY> </HTML>
Lorsque vous afficherez la premire page dans un navigateur, elle sera compos dun lien qui vous mnera la seconde. Vous pouvez observer que le texte qui compose le lien est celui que vous entrez entre les balises <a> et </a>.
Ajouter du style
Chapitre 11
Il existe une longue liste de balises HTML ddies aux styles, mais la fournir napporterait rien ici. Elles gurent sur le site web du W3C, www.w3c.org. Il sagit de lorganisme qui gre les conventions et les normes pour toute la programmation web.
Chapitre 11
Notez quil est possible de combiner diffrents codes de mise en page. Vous pouvez ainsi crire du texte gras soulign en faisant se chevaucher les balises. Mais attention bien respecter leur ordre. Il faut toujours fermer en premier la balise que vous avez ouverte en dernier. Code correct :
<b><i>Mon texte gras italique</i></b>
Code incorrect :
<b><i>Mon texte gras italique</b></i>
Cette mthode marche parfaitement mais est un peu lourde ds lors que lon veut cumuler les attributs. Cest pourquoi, pour tout ce qui relve de la mise en page, il est maintenant courant davoir recours aux feuilles de style.
Garder le style
Chapitre 11
Avoir la classe
Voyons maintenant comment dnir des attributs de style dans une feuille CSS. Une fois de plus, lancez votre diteur de texte prfr et copiez les lignes suivantes :
.rouge { color:Red; }
Remarquez bien le point (.) devant le mot rouge. Cela signie que vous dclarez une classe. Cette classe, tout comme en programmation oriente objet, va permettre de dnir un ensemble de proprits. Une fois cela fait, vous pourrez appliquer toutes ces proprits une balise ou un lment dune page HTML en lui indiquant quelle classe il doit se conformer. Ici vous avez dni une classe rouge qui va contenir un seul attribut, celui de la couleur du texte. Tous les paramtres CSS sont dj dnis, il vous suffit juste de leur donner une valeur pour les utiliser. Ici vous utilisez lattribut Color, qui permet de dnir la couleur du texte dans un conteneur donn. Pour lui donner la valeur rouge, il suffit de noter :
color:Red
Les attributs CSS sont peu prs aussi nombreux que les balises HTML. Cest pourquoi nous nen fournirons pas une liste dtaille ici. Vous pourrez les trouver sur Internet, en saisissant Attributs CSS dans votre moteur de recherche favori.
Enregistrez le chier CSS en le nommant fichierstyle.css (notez lextension .css). Sauvegardez-le si possible dans le mme rpertoire que le chier HTML. Vous allez maintenant indiquer la page web quelle doit utiliser le style du chier .css.
Chapitre 11
1 Ouvrez le chier contenant le code HTML et ajoutez la ligne suivante entre les deux balises HEAD :
<link rel=stylesheet href=fichierstyle.css />
Cette balise dnit un lien entre la page HTML et le chier .css. Cela va permettre dutiliser tous les styles dnis dans le chier.
prsent, tout le texte qui sera saisi entre les deux balises BODY sera de couleur rouge. Chargez votre page dans votre navigateur Internet. Le texte est maintenant devenu rouge.
Organiser la page
Voici le point mthodologique du chapitre. Comme vous lavez vu dans la section prcdente, vous pouvez facilement ajouter des attributs de style une balise HTML. Cependant, comment avoir une partie du texte en rouge et une partie du texte en bleu ? Vous ne pouvez pas avoir deux ensembles BODY dans une page web. Il faut donc ruser. Il existe pour cela une balise qui permet de dlimiter une zone laquelle sappliquera une srie de paramtres. Il sagit de la balise DIV. Elle vous permettra dappliquer un style une partie seulement de la page. Voici un exemple.
Chapitre 11
Notez que ces lignes peuvent tre places nimporte quel endroit de la page. Dans la balise ouvrante <script>, il est coutume de prciser le type de langage de script utilis, ici JavaScript. Une seule instruction gure entre les balises, qui va ici permettre dcrire une ligne dans la page web. Recopiez les instructions prcdentes entre les balises BODY de la page et chargez-la dans un navigateur web.
Chapitre 11
Notez que vous recourez une schmatisation objet en utilisant la mthode writeln de lobjet document. En effet, en JavaScript, la page est schmatise sous forme dobjet, disposant de proprits et de mthodes que vous pourrez modier. Voici par exemple une instruction qui permet de changer le titre de la page :
document.title="Ma page de script"
Place entre les balises script de la page, celle-ci va modier le titre par la chane de caractres place aprs =.
Une subtilit des variables JavaScript est quelles nont pas besoin dtre types. En dautres termes, vous navez en aucun cas prciser que vous utilisez des entiers ou des chanes de caractres par exemple.
Chapitre 11
Au lieu dafficher la somme de deux entiers, vous allez afficher la concatnation des deux chanes de caractres, soit 34. On dit que JavaScript est faiblement typ. De la mme manire, vous pouvez utiliser des nombres dcimaux comme valeurs des variables :
<script language="javascript"> var a = "3.5"; var b = "4.5"; document.writeln(a+b); </script>
Les instructions
En JavaScript, chaque ligne dinstruction doit tre termine par un point-virgule. Si vous loubliez, le script ne sera pas interprt par le navigateur.
Chapitre 11
Rester fonctionnel
Vous pouvez galement dclarer des fonctions en JavaScript, comme dans dautres langages, de sorte pouvoir rutiliser du code, clarier le script et lorganiser de manire claire. Pour dclarer une fonction en JavaScript, il convient dutiliser le mot-cl function suivi du nom de la fonction. Voici un simple exemple qui affichera deux chanes concatnes :
<script language="javascript"> function add(){ var a = "Bonjour"; var b = "Tout le monde"; return a+b; } document.writeln(add()) </script>
Pour quune fonction JavaScript retourne une valeur, il faut utiliser le mot-cl return.
Les vnements
Pour rellement rendre interactives vos pages, vous pouvez, tout comme avec Visual Basic, ajouter du code source lorsquun vnement se produit sur la page. Vous avez vu pour le moment quelques balises HTML. Voyons maintenant comment ajouter un bouton sur la page HTML et excuter du code lorsque lutilisateur va cliquer dessus.
Chapitre 11
Lorsque vous cliquez sur le bouton, une fentre dalerte affiche la chane de caractre "Bonjour tout le monde". Il existe plusieurs types dvnements, dont les principaux sont rcapituls dans le tableau suivant. Vous pouvez utiliser les vnements sur la plupart des balises HTML.
Tableau 11.1 : Les principaux vnements JavaScript
Nom de lvnement
Se produit lorsque La souris quitte la zone de la balise. Lutilisateur clique sur la zone dlimite par la balise. La souris passe sur la zone dlimite par la balise. La page est charge par le navigateur.
Notez que lvnement OnLoad ne peut tre dni que pour la balise BODY.
Distribuer un site
Lorsque vous avez ni de dvelopper votre site et que vous en tes er, vous pouvez le mettre en ligne. Si vous disposez dun accs Internet, il est bien souvent coupl une offre dhbergement. Ayez recours la documentation de votre fournisseur daccs pour connatre les dtails concernant la publication de contenus. Vous avez maintenant une ide claire de ce qui compose une page web, qui nest nalement rien dautre quune suite de balises. Ce court
LE GUIDE COMPLET 335
Chapitre 11
chapitre ne couvre pas lintgralit du dveloppement de site web et chaque section de ce chapitre pourrait faire lobjet dun livre elle seule. Le but ici tait de vous prsenter les trois principales technologies que sont HTML, JavaScript et les CSS, dans le cadre du dveloppement de sites web laide du Framework .NET. Cest ce que vous allez voir dans ce qui suit.
Chapitre 12
En ayant appris dvelopper un site HTML qui utilise JavaScript et des feuilles CSS, vous connaissez toutes les techniques de dveloppement web utilises jusquen lan 2000. Depuis, le dveloppement web ne sest pas arrt, il sest simplement dplac. Jusque-l, tout tait fait du ct de lordinateur du client. Le schma tait alors le suivant :
1 Un client se connecte un site web via une adresse du type www.mapageweb.com. 2 Lordinateur qui hberge le site envoie lordinateur client lobjet de sa requte, cest--dire la page demande. 3 Si la page contient du contenu JavaScript, le script est excut sur lordinateur client.
Cela convenait tout le monde, ou presque. Lun des principaux dsavantages de cette mthode est que toute la page doit tre envoye au client, et ce chaque requte. Cela implique que toute la page est disponible du ct du client. Que se passe-t-il si la page contient un mot de passe ? Il est en clair sur la page et tous ceux qui peuvent la lire le voient. Dun point de vue concurrentiel, cela signie galement que lon peut sauvegarder toutes les pages sur un disque dur, modier le site puis le remettre en ligne en sappropriant le travail. En bref, ce schma de dveloppement prsentait quelques dsavantages.
1 Un ordinateur se connecte un site web. 2 Le serveur qui hberge le site interprte la page demande. 3 La page voulue est envoye au client dans une forme comprhensible par son navigateur web.
Le principal avantage de cette mthode est la possibilit dun vritable change entre le client et le serveur.
PHP
Chapitre 12
De cette manire et en utilisant un langage complexe, vous pourrez proposer un visiteur de vritables programmes sur le Web, travers vos sites. Tous les sites modernes utilisent des technologies serveur. Deux principales technologies se partagent le march : dun ct, les solutions dites "open source", avec les outils PHP, Apache et MySQL, et de lautre, les solutions propritaires reprsentes par Microsoft, avec les technologies ASP et SQL Server.
12.2. PHP
PHP est lacronyme de "PHP Hypertext Preprocesseur", ce qui signie en franais "prprocesseur PHP". Il sagit de gnrer une page web au format HTML pour la rendre lisible sur un navigateur.
Chapitre 12
Enregistrez le chier dans le dossier www du rpertoire dinstallation dEasyPHP, en lui donnant lextension .php. Lancez maintenant votre navigateur Internet et rendre-vous ladresse http://localhost/nomdevotrepage/php. localhost est simplement un alias stipulant que la page est stocke sur votre serveur.
Les instructions
En PHP, les instructions se terminent par un point-virgule (;) en n de ligne. Ne lomettez pas, sous peine de rendre vos pages inutilisables.
Remarquez que le code PHP est plac lintrieur des balises <?php et ?>. Lutilit des technologies serveur est la rception et lenvoi de donnes. Vous allez voir comment procder en recourant aux formulaires web.
PHP
Chapitre 12
Vous disposez maintenant dune page qui affiche trois zones de saisie de texte : Nom, Prnom et ge. Le problme est que, pour linstant, vous ne pouvez rien en faire. Vous allez changer cela tout de suite.
Chapitre 12
$prenom= $_POST["prenom"]; $age=$_POST["age"] echo "Vous vous appelez".$prenom." ".$nom." et vous avez ".$age." ans"; ?>
Il sagit de la page qui sera destine au traitement des donnes du formulaire. Pour rcuprer ces donnes, il convient de les stocker en utilisant des variables. Il faut pour cela les dclarer de cette faon : $nomdelavariable=valeur.
Tout comme JavaScript et Visual Basic.Net, PHP est un langage faiblement typ. Il nest donc pas ncessaire de prciser le type des variables lorsque vous les dclarez. La valeur que vous leur affectez ici est celle qui est rcupre depuis le formulaire. En PHP, lorsquun formulaire est utilis, ses variables sont stockes diffremment selon la mthode utilise pour dclarer le formulaire. Il existe deux mthodes, POST et GET, sur lesquelles nous reviendrons. Vous utilisez ici la mthode POST. Quelle que soit la mthode employe, la manire de stocker les variables du formulaire ne change pas. Elles sont enregistres dans un tableau, chacune dans une case qui porte le nom donn la balise input du formulaire. Le nom du tableau est toujours du type $_POST[""] ou $_GET[] selon la mthode utilise.
PHP
Chapitre 12
Vous appelez ensuite la fonction echo de PHP, qui permet dafficher du texte sur une page. Il suffit de lui passer en paramtre les chanes et les variables dont vous souhaitez afficher le contenu.
4 Il faut maintenant faire le lien entre le formulaire et son traitement. Modiez la page dorigine conformment au modle suivant :
<html> <head> <title>Ma page de formulaire</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <form method="POST" action="traitement.php"> Nom:<input type=text name="nom"/> Prnom:<input type=text name="prenom"/> Age:<input type=text name="age"/> <input type=submit /> </form> </body> </html>
Elle a pour but dajouter la page de formulaire un bouton de validation qui valide les donnes et les envoie la page de traitement spcie dans lattribut action de la balise ouvrante du formulaire. Copiez ces deux pages dans le dossier www du rpertoire dinstallation dEasyPHP.
Chapitre 12
contiendra le nom du paramtre et sa valeur, sous la forme www .mapagedetraitement.com?nomduparamtre=valeur. Vous pouvez prendre lexemple suivant pour effectuer une recherche sur Google partir de votre site :
<html> <head runat="server"> <title>Ma page de formulaire</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <form method=GET action=http://www.google.fr> Recherche:<input type=text name=q/> <input type=submit /> </form> </body> </html>
Dans la partie body de la page, vous dclarez un formulaire. La mthode est GET et le traitement est report la page www.google.fr. Dans ce formulaire, vous ajoutez un champ de saisie de texte appel q, puis un bouton de validation. Chargez la page dans un navigateur, entrez un ou plusieurs mots dans le champ de texte et appuyez sur le bouton de validation. Votre navigateur va charger la page de traitement du formulaire, en ajoutant les donnes saisies dans le champ de recherche. Ladresse charge devient alors www.google.fr?q=mot+recherch.
Rcupration des donnes
Bien que les donnes de formulaire soient passes dans la barre dadresse, il nest pas possible de les rcuprer pour les traiter autrement quen lisant le tableau de donnes GET[] associ au formulaire.
La mthode POST transmet les donnes dans len-tte de la page, cest--dire de manire compltement transparente pour lutilisateur. Lavantage principal est de ne pas exposer les donnes sensibles nimporte qui. Si par exemple vous demandez une identication par mot de passe sur votre site en faisant appel la mthode GET, le mot de passe apparat en clair dans la barre dadresse du navigateur, ce qui est proscrire dans le cadre dune application scurise.
PHP
Chapitre 12
Si Alors Sinon
La boucle de type If se dcrit de cette manire :
<html> <head runat="server"> <title>Ma page de If</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <?php $variable = 150 if ($variable<250){ echo("La variable est plus petite que 250"); } else{ echo("La variable est plus grande que 250"); } ?> </body> </html>
Notez bien lutilisation daccolades pour dlimiter les blocs dinstructions. Si vous avez plusieurs tests successifs, vous pouvez utilisez la structure If ElseIf Else, qui permet dimbriquer plusieurs tests, de la manire suivante :
<html> <head runat="server"> <title>Ma page de If</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <?php $variable = 150 if ($variable<250){ echo("La variable est plus petite que 250") } elseif($variable>250){ echo("La variable est plus grande que 250") }
Chapitre 12
Il existe une autre faon dcrire le contrle If, sans les accolades :
<html> <head runat="server"> <title>Ma page de If</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <?php if(votre test): Instructions; else: Instructions; ?> </body> </html>
Attention car cette criture nest pas compatible avec toutes les versions de PHP.
Les boucles
Les boucles itratives permettent de rpter une ou plusieurs instructions.
While
La boucle While, galement propose par Visual Basic .NET, a la syntaxe suivante en PHP :
While(votrecondition){ //Vos instructions }
Commentaires
PHP
Chapitre 12
La boucle While permet de rpter les instructions tant que le test conditionnel est vrai. cause de cela, si vous ne pensez pas mettre un cas darrt, cest--dire un modicateur de la condition de test, la boucle ne sarrtera jamais. Heureusement, la plupart des navigateurs rcents arrtent le programme automatiquement au bout de 30 secondes.
For
La boucle For permet, contrairement la boucle While, de prciser le nombre ditrations partir dune condition initiale et larrt de la boucle avec une condition darrt. Elle est utile lorsque vous raisonnez en termes de nombre ditrations plutt quen termes de condition. La syntaxe de la boucle For en PHP est la suivante :
$i; $j=2; For($i=0;$i<10;$i++){ Echo $i*$j; }
Vous affichez ici la table de multiplication par 2. Sur les deux premires lignes, vous initialisez deux variables i et j. La premire sert de compteur, la seconde de variable pour la table de multiplication. Dans la boucle for, vous prcisez linitialisation, ici la valeur de base de i, ensuite le cas darrt, savoir une sortie de la boucle dexcution quand i est gal 9 (il faut donc tester si la valeur de i est strictement infrieure 10), et enn le pas, ce qui reprsente la modication applique la valeur de i chaque itration de la boucle.
Switch
La structure Switch permet de remplacer avantageusement un grand nombre de tests conditionnels :
<html> <head runat="server"> <title>Ma page de If</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <?php if ($i == 0) { print "i gale 0";
Chapitre 12
} if ($i == 1) { print "i gale 1"; } if ($i == 2) { print "i gale 2"; } switch ($i) { case 0: print "i gale 0"; break; case 1: print "i gale 1"; break; case 2: print "i gale 2"; break; } ?> </body> </html>
Ces deux blocs de code sont quivalents. Le Switch permet de clarier la syntaxe qui peut tre brouillonne si vous multipliez les tests.
Instruction Break
Linstruction break des lments case de la structure prcdente permet darrter le traitement des instructions. Si vous lomettez, toutes les instructions de tous les case seront excutes.
Les fonctions
Il est galement possible de dclarer des fonctions en PHP, avec tous les avantages que cela amne. Pour crire des fonctions en PHP, il suffit dutiliser le mot-cl Function de la manire suivante :
<html> <head runat="server"> <title>Ma page de fonctions</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <?php Function nomdelafonction($argument1,$argument2){ Echo $argument1+$argument2; ?>
PHP
</body> </html>
Chapitre 12
Ici, la fonction va effectuer un affichage sur la page de deux arguments quelle reoit en paramtre.
Tests
Ce genre de fonctions est utile pour effectuer des tests sur un projet an de trouver do viennent les problmes.
Vous pouvez maintenant structurer correctement les chiers de votre site en organisant au mieux votre code. Pour bien rutiliser du code, il convient de le placer dans un chier part. Imaginez une fonction qui affiche le formulaire de recherche sur Google sur chacune des pages de votre site :
<html> <head runat="server"> <title>Ma page de fonctions</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <? Function QuestionGoogle(){ <form method=GET action=http://www.google.fr> Recherche:<input type=text name=q/> <input type=submit /> </form> } ?> </body> </html>
Vous allez la placer dans un chier part : fonctions1.php. Pour rutiliser le contenu de fonctions1.php dans un autre chier, il suffit dajouter la ligne suivante :
<?include "fonctions1.php"?>
En ajoutant cette ligne en haut du chier courant, vous pourrez utiliser tout le code plac lintrieur de fonctions1.php comme si vous laviez copi-coll.
Chapitre 12
soit en utilisant des chiers cookies, qui enregistrent des informations sur lordinateur du client ; soit en utilisant des sessions, qui stockent temporairement des informations dans la mmoire de lordinateur qui hberge le site web.
Le cookie est un chier texte qui peut contenir la valeur que vous voulez. Vous pouvez faire en sorte que le chier cookie expire lorsque lutilisateur quitte votre site. Mais il est courant de lutiliser pour enregistrer par exemple la date de la dernire visite de linternaute. Si vous ne prvoyez pas un dlai assez large entre deux visites, vous perdrez linformation.
Enregistrer un cookie
Pour enregistrer un cookie sur lordinateur du client, utilisez le code suivant :
<html> <head runat="server"> <title>Ma page de fonctions</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <?php $valeur = "Valeur de test"; setcookie("MonCookie", $valeur); ?> </body> </html>
La fonction setcookie() dnit le chier crire sur lordinateur client ou plutt le contenu du chier.
PHP ct serveur
Chapitre 12
Il nest permis dcrire quune seule valeur par chier cookie. Aussi, si vous comptez stocker plusieurs informations, vous devez utiliser un sparateur de texte, par exemple la barre oblique ou un point-virgule.
Selon la manire dont lutilisateur a congur son navigateur Internet, le chier est maintenant stock quelque part sur le disque dur de lordinateur client. Pour en lire le contenu, il faudra utiliser un code ressemblant celui-ci :
<html> <head runat="server"> <title>Ma page de fonctions</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <?php echo $_COOKIE["MonCookie"]; ?> </body> </html>
La lecture des cookies se fait par un tableau les contenant tous. En inscrivant le nom de votre cookie (le premier paramtre de la fonction setcookie) en index du tableau, vous pourrez en rcuprer la valeur et lutiliser directement. Dans lexemple prcdent, il est question de lafficher, mais vous pouvez le stocker dans une variable, comme suit :
<html> <head runat="server"> <title>Ma page de fonctions</title> <link rel=stylesheet href=StyleSheet.css /> </head> <body> <?php $Variable = $_COOKIE["MonCookie"]; ?> </body> </html>
Les cookies sont des systmes de stockage dinformations utiliss plutt sur le long terme. Pour le court terme, il est dusage de recourir au mcanisme de sessions.
Chapitre 12
Soit lutilisateur vient dune page o les sessions existaient dj, il dispose donc dun numro unique de session qui est ractiv sur cette page. Lutilisateur vient dune page o les sessions ntaient pas initialises et un numro unique est initialis dans les informations de navigation de linternaute sur le serveur.
PHP ct serveur
Chapitre 12
Dans cet exemple de page, vous dclarez une variable contenant la chane "valeur", qui sera ensuite intgre la collection des variables de session. Le paramtre de Session_register() est le nom dune variable et nest pas prcd du caractre $. Attention : les initialisations de session doivent gurer en tout dbut de chier. En effet, vous risquez davoir des erreurs dans lexcution du script de votre page si le dmarrage des sessions se fait au milieu de la page.
Lorsque vous chargez cette page, le contenu de la variable enregistre prcdemment saffiche.
Chapitre 13
Jusqu maintenant, vous avez vu la plupart des techniques employes en programmation avec Visual Basic .NET ainsi que les principes fondamentaux du dveloppement de sites web dynamiques avec PHP. Imaginez une jointure entre les deux mondes. Supposez un instant que vous puissiez utiliser la facilit de dveloppement de .NET dans une application web. Si vous avez dj une lgre exprience de ce que peut tre le dveloppement dun site complet en PHP, lide doit vous plaire. Si vous tes encore dbutant, imaginez simplement que vous allez construire des sites web complexes aussi facilement que vous avez cr des applications Windows compltes dans les chapitres prcdents. Ce monde o le meilleur des deux principes de dveloppement se rejoint, cest ASP .NET. ASP .NET nest pas un langage, cest un ensemble de technologies. ASP est lacronyme d"Active Server Pages". Il sagit dun ensemble doutils prts lemploi permettant de tout grer ct serveur. En dautres termes, toute la gestion des formulaires, des sessions, etc. est dj implmente. En dveloppant ASP .NET, Microsoft a rchi pour vous. Vous navez plus qu utiliser ces outils mis votre disposition.
Crer un projet
Comme pour les projets Visual Basic .NET, il faut passer par le menu Fichier/Nouveau projet pour commencer le dveloppement dun nouveau site. Vous retrouvez alors lExplorateur de solutions, la fentre des proprits, la bote outils, etc. Tous les lments qui vous ont aid crer vos applications sont de nouveau disponibles.
Chapitre 13
La page default.aspx
Lors de la cration dun projet, une page par dfaut est ajoute votre solution. Il sagit de la page par dfaut de votre application. Si vous appuyez sur [F5] ds maintenant, vous allez charger cette page dans votre navigateur et elle sera blanche. Commencez par lui ajouter du contenu :
1 Cliquez du bouton droit sur la page puis slectionnez Vue Design. 2 Ajoutez des contrles depuis la bote outils, comme vous le feriez dans un projet classique. 3 Appuyez sur [F5] pour tester lapplication. Cela marche.
Vous pouvez ajouter dautres pages de type HTML, .asp, .aspx, etc. en cliquant du bouton droit sur le nom de votre site dans lExplorateur de solutions et en choisissant Ajouter un nouvel lment. Voyons maintenant comment ajouter un peu dinteractivit ce nouveau site.
Chapitre 13
web. Ce sont bien souvent des adaptations de ce que lon trouve gnralement sur les sites Internet. Les dveloppeurs ont ainsi loutil ad hoc prt lemploi, ce qui leur facilite la tche. Par exemple, tous les sites web ont besoin de boutons pour ajouter de linteraction avec le navigateur. Ainsi, dans la bote outils de Visual Web Developer Express, vous trouverez un contrle Button et un contrle ImageButton. Le premier est un bouton classique qui se comportera comme celui des applications Windows. Le second a une proprit Image qui sera son image de fond. Cette image sera "cliquable" pour simuler un clic de bouton. En faisant glisser un contrle sur la page default.aspx, vous constatez que vous ne pouvez pas le dplacer comme sur un formulaire Windows. Cest normal. Pour placer vos lments sur la page, vous devez utiliser une feuille de style CSS. Voici un exemple de petit site permettant dafficher des images la manire dun blog.
1 Ouvrez un nouveau projet de type site web ASP .NET. 2 Ajoutez un contrle FileUpload. 3 Ajoutez un contrle Button.
prsent, appuyez sur [F5].
Chapitre 13
Le contrle FileUpload permet de grer lenvoi de chiers vers le serveur web. Cependant, il faut prciser quand et o sauvegarder le chier. Le "quand" se prcise sur un vnement de la page, par exemple le clic dun bouton. Dans le designer de pages web, double-cliquez sur le bouton pour vous placer dans lvnement "clic", puis entrez linstruction suivante :
FileUpload1.SaveAs("c:\image.jpg")
Cette instruction prcise o et sous quel nom le chier slectionn peut tre sauvegard.
Chemin de sauvegarde
Le contrle FileUpload naccepte que les chemins complets, et non les chemins dits "abrgs" de type "./repertoire/repertoire2".
Vous avez maintenant envoy votre image au serveur. Encore faut-il lafficher sur la page. Pour cela, vous allez ajouter un contrle Image. Ensuite, ajoutez la ligne suivante au code de lvnement "clic" du bouton :
Image1.ImageUrl = "c:\image.jpg"
Cette ligne affecte une image au contrle. Relancez la page avec [F5]. Slectionnez une image puis cliquez sur le bouton. Limage saffiche sur la page. Si vous testez cette mthode sur plusieurs navigateurs, vous risquez davoir des rsultats diffrents. Cela vient du fait que les navigateurs ont une gestion diffrente des chemins, cest--dire des adresses des chiers sur le disque dur. Vous tes maintenant en mesure dajouter votre site Internet tous les contrles disponibles et de les utiliser. Vous pouvez reprendre le systme de connexion une base de donnes, utiliser les vnements, etc.
Annexes
Glossaire de programmation .......................................................................................... 362 Raccourcis clavier .............................................................................................................. 365 Sites web ............................................................................................................................. 366 Blogs ..................................................................................................................................... 368 Comparatif des langages ................................................................................................. 371 Mots cls du langage Visual Basic .NET ..................................................................... 374 Les Balises HTML .............................................................................................................. 376 Rcapitulatif des projets .................................................................................................. 377
Chapitre 14
Annexes
Base de donnes
Systme de classement et de stockage dinformations.
Bibliothque
Ensembles de classes et de fonctions destines tre rutilises.
Bogue
Problme de comportement dun programme.
Caractre
Symbolise une variable destine stocker une lettre ou un symbole.
Chane
Tableau de caractres.
Classe
Ensemble de mthodes et de proprits.
Code source
Fichier contenant les instructions compiler pour obtenir un programme.
Compilateur
Programme destin transformer un code source en code excutable par un ordinateur.
Glossaire de programmation
Chapitre 14
Compilation
Appel un compilateur.
Contrle
Dans le contexte de la programmation dapplications Windows, il sagit dune classe destine faciliter linteraction avec lutilisateur.
Cookies
Fichiers permettant de stocker des informations lorsquun utilisateur se connecte un site web.
Dboguer
Corriger les failles dun programme.
diteur
Programme utilis pour ldition de code source.
Entier
Symbolise une variable destine stocker une valeur numrique entire.
Fichier
Ensemble de donnes destin au stockage.
Flottant
Symbolise une variable destine stocker une valeur numrique dcimale.
Fonction
Ensemble dinstructions qui forment une portion de code rutilisable. la diffrence dune mthode, une fonction renvoie une valeur.
Chapitre 14
Annexes
Formulaire
Dans le cadre de la programmation dapplications Windows, il sagit dune fentre destine assurer la communication dinformations entre le programme et lutilisateur.
IDE
Environnement de dveloppement. Il sagit de programmes destins regrouper tous les outils ncessaires la programmation, comme Visual Basic Express.
Index
Valeur numrique utilise pour le positionnement dans un tableau.
Langage de programmation
Ensemble de termes et dinstructions.
Mthode
Ensemble dinstructions qui forment une portion de code rutilisable.
Navigateur
Permet dafficher les pages web.
Objet
Instance dune classe.
Projet
Ensemble des codes sources dun programme.
Raccourcis clavier
Chapitre 14
Serveur web
Ordinateur qui stocke les pages dun site Internet.
Solution
Ensemble de projets.
Systme dexploitation
Plate-forme destine lexcution du programme.
Variable
Emplacement mmoire rserv au stockage dune donne dun type dni.
Raccourci [Ctrl]+[N] [Ctrl]+[O] [Ctrl]+[S] [Ctrl]+[Maj]+[S] [Ctrl]+[H] [Ctrl]+[Alt]+[L] [Ctrl]+[Alt]+[X] [Ctrl]+[Alt]+[S] [Maj]+[F4] [F1]
Action Crer un nouveau projet Ouvrir un projet existant Sauvegarder le chier en cours Sauvegarder tous les chiers en cours Rechercher et remplacer une chane Afficher lExplorateur de solutions Afficher la bote outils Afficher lExplorateur de bases de donnes Afficher les proprits dun contrle Afficher laide de Visual Studio
Chapitre 14
Annexes
Le laboratoire .NET
www.labo-dotnet.com Le site du laboratoire des technologies .NET de SUPINFO. Vous pouvez y tlcharger des cours, travaux pratiques, et utiliser le forum pour poser des questions.
Sites web
Chapitre 14
Le rseau Codes-sources
www.codes-sources.com Le rseau Codes-sources est un ensemble de sites ddis diffrents langages. Vous y trouverez des exemples illustrs pour raliser bon nombre doprations de programmation.
Chapitre 14
Annexes
Le club dveloppez.com
www.developpez.com/ Le site developpez.com met votre disposition des articles, des exemples et un forum trs actif pour vous permettre de progresser en programmation.
14.4. Blogs
La plupart des dveloppeurs professionnels possdent un blog sur lequel ils exposent leurs soucis techniques et les solutions quils ont trouves. Voici quelques adresses intressantes. Cette liste nest pas complte et na pas la prtention de ltre. Lorsque vous restez bloqu sur un problme de dveloppement, saisissez votre problme sur un moteur de recherche. Quelquun a probablement eu le mme problme avant vous et la peut-tre dj rsolu.
Patrice Lamarche
http://blogs.developpeur.org/patrice/ Patrice est un ancien du rseau Codes-sources. Son blog fournit des informations sur le dveloppement .NET en gnral.
Blogs
Chapitre 14
Simon Ferquel
http://blogs.labo-dotnet.com/simon/ Le futur du dveloppement. Simon est un passionn de recherche et dveloppement et son blog est une vritable vitrine technologique. Attention : le niveau demand pour la comprhension du code est lev.
Chapitre 14
Annexes
Thomas Lebrun
http://morpheus.developpez.com/ Thomas est membre de lquipe de rdaction de dveloppez.com et spcialiste de linteraction entre le dveloppement .NET et la suite Office.
Chapitre 14
C
C est un langage qui date de la n des annes 70. Il est souvent enseign luniversit car, du fait de son anciennet, il existe beaucoup de dveloppeurs expriments capables de transmettre leur savoir. Le principal avantage de C est de permettre une grande interaction avec la machine au niveau physique. En effet, il ny a aucun ramasse-miettes et il faut grer soi-mme lespace mmoire du programme. Cest un peu comme une voiture de sport sans assistance au freinage. Il est possible daller trs vite et darriver en tte de la course, mais la moindre erreur, vous payez plein tarif. C est trs utilis en environnement Linux, ce systme tant entirement dvelopp en C. Exemple :
#include <stdio.h> #include <stdlib.h> int main(void) { puts("Hello World!"); return EXIT_SUCCESS; }
C++
Apparu quelques annes aprs C, C++ en reprend les ides fondamentales et ajoute les concepts de la programmation oriente objet. C++ na toujours pas de ramasse-miettes et est aujourdhui couramment utilis pour les applications scientiques demandant une forte optimisation, et pour les jeux. Ce langage est trs performant car proche de la machine, mais attention aux erreurs. Exemple :
#include <iostream.h> main()
Chapitre 14
{
Annexes
C#
Prononcez "C Sharp". C# est un langage invent par Microsoft pour promouvoir les technologies .NET. Son principal avantage est une syntaxe proche de Java et surtout un environnement manag permettant une grande souplesse de dveloppement. En ajoutant toutes les fonctionnalits du Framework .NET, vous obtenez un langage permettant de dvelopper rapidement des applications professionnelles.
using System; namespace Exemple { class Class1 { static void Main(string[] args) { Console.WriteLine("Hello, World"); } } }
Java
Java est le grand concurrent de C#, dvelopp par Sun. Java offre peu prs les mmes avantages : un environnement manag, des bibliothques de fonctions, le concepts de la programmation oriente objet. Au moment de la rdaction de ce livre, Java reprsente environ 55 % des dveloppements logiciels en entreprise. Si vous cherchez un nouveau langage pour complter votre savoir, Java peut tre un bon choix.
public static void copyFile(File src, File dest) throws IOException {FileInputStream fis = new FileInputStream(src); FileOutputStream fos = new FileOutputStream(dest); java.nio.channels.FileChannel channelSrc = fis .getChannel(); java.nio.channels.FileChannel channelDest = fos .getChannel();
Chapitre 14
PHP
PHP est un langage la mode dans le monde du dveloppement de sites Internet. Il permet une interaction pousse avec lutilisateur et sa facilit daccs en fait un bon langage pour le dveloppement dapplications web. Il est aujourdhui devenu incontournable dans le monde des intranets dentreprise.
<?php // Hello World en PHP echo Hello World!; ?>
ASP
Plus quun langage, ASP (Active Server Pages) est une technologie dveloppe par Microsoft pour concurrencer PHP. Proposant une interaction forte avec lenvironnement Windows, son volution ASP .NET avec le Framework .NET constitue un outil puissant dans le dveloppement de sites Internet dynamiques.
<%@ language="vbscript" %> <html><body> <% Response.write "Hello World!" %> </body></html>
HTML
HTML est un langage destin la prsentation des sites web. Il nest pas compil, mais interprt par le navigateur au moment du chargement de la page. Trs facile daccs, cest le langage connatre pour la ralisation de sites Internet.
<HTML> <HEAD> <TITLE>Hello World!</TITLE>
Chapitre 14
</HEAD> <BODY> Hello World! </BODY> </HTML>
Annexes
As Boolean Date Decimal Dim Do Double Each Else ElseIf End False Finally For Function If In Inherits
Chapitre 14
Is Me New Next Not Object Private Protected Public Return Short Static String Sub Then Throw True Try Until While Xor
Mot cl permettant laccs aux ressources de la classe Appel du constructeur de la classe Passe litration suivante dune boucle For Ngation Type de base Modie la porte dune variable Modie la porte dune variable Modie la porte dune variable Spcie la valeur de retour dune fonction Type de variable pour les petits nombres Modie laccs aux donnes dune classe Type de donne chane de caractres Spcie le dbut dune procdure Complment du type conditionnel Permet la gestion dexception Boolen vrai Permet le test dune instruction pour en grer les exceptions Boucle sexcutant jusqu ce quune condition soit vraie Boucle sexcutant tant quune condition est vraie Ou exclusif
Chapitre 14
Annexes
A BODY BR BUTTON CAPTION FORM FRAMESET FRAME Hx HEAD HTML IMG INPUT LI LINK OPTION P SCRIPT SELECT TABLE TD TEXTAREA TH TITLE TR UL
Chapitre 14
Lalbum photo
Code excuter au chargement de lapplication:
If FolderBrowserDialog1.ShowDialog = Windows.Forms .DialogResult.OK Then For Each fichier As String In System.IO.Directory .GetFiles(FolderBrowserDialog1.SelectedPath) If System.IO.Path.GetExtension(fichier) = ".jpg" Then Dim MonImage As ListViewItem = ListView1.Items .Add(fichier) MonImage.Name = fichier MonImage.Text = System.IO.Path .GetFileNameWithoutExtension(fichier) ImageList1.Images.Add(Image.FromFile(fichier)) MonImage.ImageIndex = MonImage.Index End If Next End If
Chapitre 14
Annexes
Importation
Lecteur Multimdia
Ajoutez votre projet la rfrence Microsoft.DirectX.AudioVideoPlayback puis un bouton et une bote de dialogue pour la slection dun chier. Pour lvnement clic dun bouton, ajoutez le code suivant :
If OpenFileDialog1.ShowDialog = Windows.Forms.DialogResult .OK Then Dim PlayAudio As New Microsoft.DirectX .AudioVideoPlayback.Audio(OpenFileDialog1.FileName) PlayAudio.Play() End If
Chapitre 14
La RichTextBox
Sauvegarder un chier
SaveFileDialog1.Filter = "Fichiers RTF(*.rtf)|.rtf" If (SaveFileDialog1.ShowDialog() = Windows.Forms .DialogResult.OK)_ Then RichTextBox1.SaveFile(SaveFileDialog1.FileName) End If
Charger un chier
RichTextBox1.LoadFile(OpenFileDialog1.FileName)
Index
Chapitre 15
Index Constante, 44 Contrle, 68, 363 Button, 72 Label, 70 ListBox, 73 ListView, 302 MenuStrip, 91 OpenFileDialog, 75 PictureBox, 75 web, 357 WebBrowser, 79 Cookies, 350, 363 CSS, 329
!
$_SESSION, 353
A
Accesseurs, 171 Album photo, 302 Ancrage, 111 ASP, 373 ASP.NET, 355 Attribut, 49, 165 Audio, 321
B
Balise, 324 Barres doutils, 95 Base de donnes, 131, 137, 362 Bibliothque, 362 Blogs, 368 BODY, 326 Bogue, 362 Bornes, 60 Boucles, 52, 56 dterministes, 56 innie, 58 non dterministes, 56 Button, 358
D
Dboguer, 363 Dimension, 47 DirectX, 319 DIV, 331 Docking, 111
E
couteur, 156 crire dans un chier, 122 diteur, 363 Encapsulation, 167 Enregistrement, 45 Enregistrer, 119 Entier, 363 numration, 44 tat, 57 vnement, 69, 165, 335 Exceptions, 146-147 Expression, 54
C
C#, 372 C++, 371 Caractre, 362 Chane, 362 Classe, 164, 362 Client-serveur, 338 Code source, 362, 367 Collection, 159 Compilateur, 362 Compilation, 363 Conditions, 52
F
Feuilles de style, 329 Fichier, 363 FileUpload, 359 Flottant, 363
Index Flush, 155, 157 Fonction, 52, 363 For, 347 Formulaire, 86, 364 Function, 348 C, 371 C#, 372 C++, 371 Lecture de chiers, 126 Liens, 326 ListView, 302 Locales, 65 Logs, 153
Chapitre 15
G
GET, 344 GetExtension, 305 Getter, 171 Gras, 327
M
Matrice, 47 Matrix, 317 Me, 166 Membre, 165 Menus, 91 MenuStrip, 91 Method, 343 Mthode, 165, 364 Miniatures, 312 MSDN, 366
H
HEAD, 325 HREF, 326 HTML, 324, 373
I
IDE, 364 If, 345 Image, 306, 359 ImageButton, 358 ImageIndex, 311 ImageList, 309 Imbrication, 53 Index, 364 Instanciation, 201 Instructions, 52 Interface, 181 Interne, 168
N
Navigateur, 364 Nouveau projet, 20
O
Objet, 164, 364 OnBlur, 336 OnClick, 336 OnLoad, 336 OnMouseOver, 336 Opacit, 109
J
Java, 372 JavaScript, 331 Journaux dvnements, 153
P
Page daccueil, 20 par dfaut, 357 Paint, 316 Paramtres, 61
L
Langage de programmation, 364
Chapitre 15
Index Solution, 365 SUPINFO, 366 Switch, 347 Syntaxe, 52 Systme dexploitation, 365
Passage, 59 PHP, 339, 373 Porte, 65 POST, 344 Priv, 167 Procdures, 52 Projet, 20, 364 bote outils, 23 compiler, 24 explorateur de solutions, 21 instructions, 25 nouveau, 20 proprits, 21 Proprits, 21, 165, 172 Protg, 168 Public, 168
T
Tableau, 47 Tas manag, 201 ToolStrip, 96 Tour de boucle, 60 Transparence, 106 Type, 47
R
Ramasse-miettes (garbage collector), 203, 364 RichTextBox, 95 Rotation, 317
V
Valeur, 44 de retour, 61 Variable, 30, 44, 365 boolens, 31 caractres, 35 chane, 35 conversion, 39 decimal, 34 integer, 33 type, 30 Vido, 321 Visual Basic Express 2005, 20 Visual Web Developer Express, 356
S
Saisies, 116 Schma client-serveur, 338 Scurit, 118 Serveur, 350 web, 365 Sessions, 350-351 Session_register(), 353 Setcookie(), 350 Setter, 171 Signature, 178 Sites dynamiques, 337
W
While, 346 Windows Forms, 23