Vous êtes sur la page 1sur 20

APPRENEZ À PROGRAMMER EN

VB .NET
Thomas Martinet
DANS LA MÊME COLLECTION

Propulsez votre site avec Prenez en main BOOTSTRAP


WORDPRESS
Julien Chichignoud Maurice Chavelli
ISBN : 979-10-90085-73-2 ISBN : 979-10-90085-62-6

Programmez en ACTIONSCRIPT 3

Des applications Programmez en


Vous avez toujours voulu réaliser des animations Flash sans jamais vraiment savoir comment

Guillaume Lapayre
faire  ? Ce livre est fait pour vous  ! Conçu pour les débutants, il vous apprendra pas à pas

Guillaume Chau
Actionscript 3, le langage de programmation de Flash.

Qu’allez-vous apprendre ?

ultra-rapides avec NODE.JS ACTIONSCRIPT 3


Les bases d’Actionscript
La programmation orientée objet PROGRAMMEZ EN
La création de dessins vectoriels

ACTIONSCRIPT 3
La manipulation d’images
Les animations et interpolations
L’interaction avec l’utilisateur
La création de mini jeux

ACTIONSCRIPT 3
À propos de l’auteur Guillaume Chau et Guillaume Lapayre
Guillaume Chau
Etudiant ingénieur, passionné par les nouvelles technologies et le Web, il a
remporté le premier prix de Innov’Game 2011, grâce à un jeu de stratégie
réalisé à l’aide de Actionscript 3.0 et du Flex SDK.

Guillaume Lapayre
Diplômé d’une école d’ingénieurs généralistes et d’un master en acoustique
et vibrations, Guillaume Lapayre est toujours en quête de connaissances
dans de nouveaux domaines. C’est ainsi qu’après avoir fait ses premiers pas
avec divers langages tels que le C, le C++, le Java ou l’Actionscript, il décide

Mathieu Nebra Guillaume Chau & Guillaume Lapayre


de partager ses connaissances sur OpenClassrooms.

L’esprit d’OpenClassrooms
Des cours clairs et ludiques, conçus pour tous
Une communauté de professionnels et de passionnés prêts à vous aider sur nos forums
Des ressources disponibles partout, tout le temps : sur le web, en PDF, en eBook…

ISBN : 979-10-90085-59-6 ISBN : 979-10-90085-64-0


ISBN : 979-10-90085-55-8

32€
9 791090 085558

Structurez vos données avec XML

Apprenez à programmer en Structurez vos données


Vous souhaitez structurer les données manipulées ou échangées par vos programmes ou vos
applications mobiles ? Ce livre est fait pour vous ! Conçu pour les débutants, il vous apprendra
Ludovic Roland

pas à pas à maîtriser le XML.

Qu’allez-vous apprendre ?

ADA avec XML


Les éléments de bases
La Document Type Definition (DTD) STRUCTUREZ VOS DONNÉES AVEC
v Les schémas XML

XML
L’API DOM
L’API XPath
Les espaces de noms
La mise en forme avec CSS

À propos de l’auteur Ludovic Roland


Ludovic Roland
Développeur Android et Windows Phone, Ludovic voit le XML comme un
moyen efficace de structurer les données à échanger entre un serveur et les
XML

nouveaux appareils que sont les smartphones et tablettes. Il décide alors


de partager ses connaissances en rédigeant un cours sur OpenClassrooms.

L’esprit d’OpenClassrooms

Vincent Jarc
Des cours clairs et ludiques, conçus pour tous

Ludovic Roland
Une communauté de professionnels et de passionnés prêts à vous aider sur nos forums
Des ressources disponibles partout, tout le temps : sur le web, en PDF, en eBook…

ISBN : 979-10-90085-58-9 ISBN : 979-10-90085-56-5


ISBN : 979-10-90085-56-5

27€
9 791090 085565

Créez des applications en C#


pour WINDOWS PHONE 8

Nicolas Hilaire
ISBN : 979-10-90085-63-3

Apprenez à votre rythme Rejoignez la communauté


grâce à l’offre Premium  OpenClassrooms :
OpenClassrooms :
téléchargez des eBooks,
www.openclassrooms.com
des vidéos des cours et
faites-vous certifier.
www.facebook.com/openclassrooms
Devenez Premium !
@OpenClassrooms
Devenez Premium
Téléchargez
les eBooks
Accédez
aux certifications
Téléchargez
les vidéos en HD
www.openclassrooms.com/premium
APPRENEZ À PROGRAMMER EN

VB .NET
Thomas Martinet
Sauf mention contraire, le contenu de cet ouvrage est publié sous la licence :
Creative Commons BY-NC-SA 2.0
La copie de cet ouvrage est autorisée sous réserve du respect des conditions de la licence
Texte complet de la licence disponible sur : http : //creativecommons.org/licenses/by-nc-sa/2.0/fr/
Mentions légales
Conception couverture : Sophie Bai
Illustrations chapitres : Fan Jiyong et Alexandra Persil
OpenClassrooms 2014 - ISBN : 979-10-90085-54-1
Avant-propos

es programmes nous entourent. Dès que vous mettez en marche votre ordina-
L teur, votre télévision, votre téléphone portable et même votre cafetière (pour cer-
taines), des programmes démarrent et exécutent les actions pour lesquels ils ont
été conçus : vous permettre de lire vos e-mails, de regarder le dernier journal télévisé,
de passer un appel téléphonique et. . . vous faire votre café.
Cependant, tout ce petit monde (à l’instar de Rome) ne s’est pas construit en un jour. Il
y a eu des milliers, des dizaines de milliers de programmeurs qui ont collaboré depuis la
création du premier ordinateur, pour vous permettre d’atteindre ce niveau de confort.
Ces programmeurs étaient sûrement comme vous, se sentant délaissés dans l’immense
océan qu’est celui de l’informatique. Ils sont aussi partis de rien pour apprendre, pro-
gresser et finalement exceller dans le domaine de la programmation informatique. Cela
leur a permis de concevoir les programmes animant des machines qui font aujourd’hui
partie intégrante de notre mode de vie.
Certes, la programmation n’est pas forcément aisée à appréhender, des mots et des
concepts compliqués se cachent derrière chaque ligne que le programmeur écrit, des
heures de réflexion et de recherche sont derrière chaque programme réussi. En y réflé-
chissant, on peut croire que développer un programme n’est pas à la portée du premier
venu.
Mais la vérité est tout autre : la programmation, à l’instar de n’importe quelle autre
discipline, nécessite juste un peu de volonté et de pratique. Souvenez-vous vos premiers
mètres faits sur votre vélo rutilant du haut de vos cinq ans. Cette épreuve vous semblait
insurmontable, impossible. Pourtant, vous saviez très bien que d’autres avaient réussi
avant vous. Prenant votre courage à deux mains, vous avez réussi à surmonter votre
peur et pris votre élan. Mais rappelez-vous, vous avez sûrement commencé avec des
petites roulettes, destinées à vous apporter la stabilité et le maintien nécessaires pour
vous initier en toute sécurité au cyclisme.
Considérez ce livre comme vos roulettes. Il va vous aider à faire vos premiers pas dans le
monde de la programmation, et plus spécifiquement dans la programmation en Visual
Basic .NET. Ce livre va, je l’espère, vous enseigner tous les rudiments nécessaires pour
créer un programme pleinement fonctionnel. Des notions vous seront enseignées, mais
le monde de la programmation est immense ! Une fois le livre terminé, ce sera à vous
d’expérimenter vos propres tentatives. D’enlever vos roulettes et de vous lancer à toute
vitesse dans le fabuleux monde de la programmation.

i
CHAPITRE 0. AVANT-PROPOS

Le Visual Basic .NET


Si vous débutez en programmation, cela doit être pour vous un immense entremêlement
de langages plus complexes les uns que les autres. . . Cependant, en voilà un qui se
démarque de ses congénères. Le Visual Basic .NET est un langage destiné à être très
facilement compréhensible (le mot « Basic » résume bien cela). Il va vous permettre,
à vous débutants, ou vous adeptes de la programmation, de concevoir rapidement,
simplement et gratuitement vos propres programmes. Si vous souhaitez apporter votre
pierre à l’édifice de l’informatique en concevant un programme et en le diffusant aux
autres, vous pouvez.
Ce langage vous permettra rapidement et en quelques lignes seulement de concevoir
des programmes avec des interfaces graphiques constructibles intuitivement. Pas de
prise de tête avec Visual Basic, concentrez-vous uniquement sur l’essentiel. Il n’en est
pas pour le moins extrêmement complet ! En gardant l’étendue des possibilités de ses
congénères tout en simplifiant au maximum leur syntaxe de programmation, le Visual
Basic .NET est, à mon sens, un des langages de programmation les plus simples à
appréhender.

Qu’allez-vous apprendre en lisant ce livre ?


Nous allons apprendre le langage de programmation VB .NET de façon progressive au
cours de cet ouvrage composé des parties suivantes :

1. La théorie et les bases : nous commencerons par découvrir les bases du


langage VB .NET. Et cela depuis zéro : quel logiciel dois-je installer pour dé-
velopper une application ? quelles sont les instructions de base du langage VB
.NET ? Nous allons découvrir tout cela au cours de cette première partie qui
permettra de poser les briques de nos premières applications.
2. Le côté visuel de VB : le mot « Visual » de Visual Basic signifie « vi-
suel », nous allons donc dans cette deuxième partie nous atteler à apprendre
à construire nos premières fenêtres graphiques pour permettre une interaction
plus aisée avec l’utilisateur. Des TP seront présents au cours de ce chapitre pour
mettre en pratique vos connaissances.
3. La programmation orientée objet : ici, les choses sérieuses commencent
et nous allons voir ce qu’est la programmation orientée objet. Nous étudierons
comment le VB .NET utilise ses notions et comment nous en servir pour aug-
menter les capacités de nos programmes. Vous vous rendrez alors compte de
l’étendue des possibilités du langage VB .NET
4. Les bases de données : pour continuer à agrémenter ces connaissances, nous
nous attaquerons aux bases de données, et verrons comment les interfacer avec
nos programmes en VB .NET. Cette partie vous permettra d’effectuer efficace-
ment du stockage de données (primordial dans la plupart des programmes).
5. La communication par le réseau : dans un monde où le réseau est omni-
présent, je ne pouvais pas vous laisser sans vous apprendre comment faire com-

ii
COMMENT LIRE CE LIVRE ?

muniquer vos programmes par le réseau. Cette partie est consacrée à ce sujet et
vous permettra de poser les bases de ce nouveau domaine de programmation.
6. Annexes : une partie finalement dédiée à diverses notions vous permettant
d’apporter plus de flexibilité à votre programme. C’est dans cette partie que
vous découvrirez également comment diffuser votre application et permettre à
d’autres personnes d’en profiter.

Comment lire ce livre ?


Suivez l’ordre des chapitres
Lisez ce livre comme on lit un roman. Il a été conçu comme tel. Contrairement à
beaucoup de livres techniques où il est courant de lire en diagonale et de sauter certains
chapitres, il est ici très fortement recommandé de suivre l’ordre du cours, à moins que
vous ne soyez déjà un peu expérimentés (et très sûr de vous).

Pratiquez en même temps


Pratiquez régulièrement. N’attendez pas d’avoir fini de lire ce livre pour allumer votre
ordinateur et faire vos propres essais ; n’hésitez pas à modifier les codes donnés en
exemples, afin de bien cerner le comportement de chaque instruction. Plus vous exer-
cerez, et plus l’apprentissage sera rapide et efficace.

Remerciements
Je souhaite remercier un certain nombre de personnes qui, de près ou de loin, ont
contribué à la naissance de cet ouvrage :
— Ma famille, qui me soutient au quotidien et qui continue de me témoigner sa
confiance.
— M. Philippe De Guis, qui m’a permis, au cours d’un stage en entreprise, de
découvrir ce langage de programmation et qui m’a donné envie d’écrire cet
ouvrage.
— Mes colocataires et amis qui doivent me supporter au quotidien.
— Jonathan, Mathieu, Pierre et l’ensemble de l’équipe de Simple IT.
— Tous les lecteurs qui ont contribué à son amélioration grâce à leurs commentaires
précieux et avec qui j’ai beaucoup de plaisir à partager mes connaissances.

iii
CHAPITRE 0. AVANT-PROPOS

iv
Sommaire

Avant-propos i
Le Visual Basic .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ii
Qu’allez-vous apprendre en lisant ce livre ? . . . . . . . . . . . . . . . . . . . . ii
Comment lire ce livre ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iii
Remerciements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . iii

I La théorie et les bases 1

1 Historique et Visual Basic Express 2010 3


Historique, naissance du Visual Basic . . . . . . . . . . . . . . . . . . . . . . . 4
Le framework .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Notre outil : Visual Basic 2010 Express . . . . . . . . . . . . . . . . . . . . . 7
Installation de Visual Basic 2010 Express . . . . . . . . . . . . . . . . . . . . 8
Découverte de l’interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Premiers pas 15
Hello World ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Objets, fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Fonctions, arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3 Les variables 23
Les types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Les utiliser - la théorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

v
SOMMAIRE

Les utiliser - la pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4 Modifications des variables et opérations sur les variables 31


Opérations sur une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Plus en profondeur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Différentes syntaxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Lire une valeur en console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5 Conditions et boucles conditionnelles 41


Les boucles conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Select . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Mieux comprendre et utiliser les boucles . . . . . . . . . . . . . . . . . . . . . 52

6 TP : La calculatrice 55
Addition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Mini calculatrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

7 Jouer avec les mots, les dates 63


Les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Les dates, le temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
TP sur les heures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

8 Les tableaux 71
Les dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Autres manipulations avec les tableaux . . . . . . . . . . . . . . . . . . . . . . 74
Mini-TP : comptage dans un tableau. . . . . . . . . . . . . . . . . . . . . . . 76
Exercice : tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Les énumérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80

9 Les fonctions 83
Créons notre première fonction ! . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Ajout d’arguments et de valeur de retour . . . . . . . . . . . . . . . . . . . . 85
Petits plus sur les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

vi
SOMMAIRE

Petit exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

10 Les inclassables 93
Les constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Les structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Boucles supplémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Les casts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Le type Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Les MsgBox et InputBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

II Le côté visuel de VB 105

11 Découverte de l’interface graphique 107


Les nouveautés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Avantages par rapport à la console . . . . . . . . . . . . . . . . . . . . . . . . 108
Manipulation des premiers objets . . . . . . . . . . . . . . . . . . . . . . . . . 109
Les paramètres de notre projet . . . . . . . . . . . . . . . . . . . . . . . . . . 110

12 Les propriétés 111


À quoi ça sert ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Les utiliser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Les assigner et les récupérer côté VB . . . . . . . . . . . . . . . . . . . . . . . 114
With . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

13 Les événements 121


Pourquoi ça encore ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Créer nos événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
Les mains dans le cambouis ! . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Mini-TP : calcul voyage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

14 Les contrôles spécifiques 129


Checkbox, boutons radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
La pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Les combobox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
MicroTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

vii
SOMMAIRE

15 Les timers 139


Créer son premier timer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
TP : la banderole lumineuse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

16 Les menus 145


Présentation des menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
La barre de menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Les différents contrôles des menus . . . . . . . . . . . . . . . . . . . . . . . . . 150
La barre de statut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Le menu contextuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

17 TP : navigateur web 161


Le cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
Les ébauches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
Bien exploiter les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Le design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168

18 Fenêtres supplémentaires 171


Ajouter des fenêtres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Ouverture et fermeture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Notions de parent et d’enfant . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Communication entre fenêtres . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

19 Les fichiers - partie 1/2 183


Introduction sur les fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
Le namespace IO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Notre premier fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Nos premières manipulations . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

20 Les fichiers - partie 2/2 197


Plus loin avec nos fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
Les répertoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Mini-TP : lister notre arborescence . . . . . . . . . . . . . . . . . . . . . . . . 202
Un fichier bien formaté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

21 TP : ZBackup 207

viii
SOMMAIRE

Le cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208


Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
Récapitulatif du fichier ini . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222

III La programmation orientée objet 225

22 Les concepts de la POO 227


Pourquoi changer ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Les accessibilités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Les fichiers de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230

23 Notre première classe 233


Notre première classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Des méthodes et des attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
Les propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Notre petit Mario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

24 Concepts avancés 243


L’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Les classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Les événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
La surcharge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
La surcharge d’opérateurs et les propriétés par défaut . . . . . . . . . . . . . 254
Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
Les bibliothèques de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

25 La sauvegarde d’objets 263


La sérialisation, c’est quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
La sérialisation binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
La sérialisation XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
La sérialisation multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

26 TP : ZBiblio, la bibliothèque de films 275


Le cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276

ix
SOMMAIRE

La correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
Améliorations possibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288

IV Les bases de données 291

27 Introduction sur les bases de données 293


Qu’est-ce qu’une base de données ? . . . . . . . . . . . . . . . . . . . . . . . . 294
Les bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Lexique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
SQL Server 2008 R2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
Installation de SQL Server 2008 R2 . . . . . . . . . . . . . . . . . . . . . . . . 299
Découverte de l’interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306

28 Introduction au langage SQL 311


Rechercher des informations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Ajouter des informations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
La mise à jour d’informations . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
Supprimer des informations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315

29 Création et remplissage de la BDD 317


Création de notre base de données (BDD) . . . . . . . . . . . . . . . . . . . . 318
La création de la table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
Le remplissage de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

30 La communication VB .NET - BDD 325


ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
Connexion à la BDD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
Insertion ou modification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
Lecture de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330

31 Le DataSet à la loupe 333


Qu’est-ce ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
La lecture de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
L’ajout de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

32 L’utilisation graphique : le DataGrid 341

x
SOMMAIRE

La découverte du DataGrid . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342


Liaison avec le code VB .NET . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Liaison via l’assistant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344

33 TP : ZBiblio V2 351
Cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Correction : partie BDD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Correction : partie VB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358

V La communication par le réseau 361

34 Introduction à la communication 363


La communication, pourquoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
Les sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
.NET remoting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
WCF, Windows Communication Fundation . . . . . . . . . . . . . . . . . . . 366

35 Communication via sockets 369


Client/serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
La connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
Le transfert de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Mini-TP : demande d’heure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

36 TCPListener/TCPClient 381
TCPListener . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
TCPClient . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
La communication par flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

37 Les threads 385


Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
Notre premier thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
La synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
Les Windows Forms et les threads . . . . . . . . . . . . . . . . . . . . . . . . 391

38 TP : ZChat 395

xi
SOMMAIRE

Cahier des charges . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396


La correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 404

VI Annexes 407

39 Gérer les erreurs 409


Découvrons le Try . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Catch, throw . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411

40 Les ressources 415


Qu’est-ce qu’une ressource ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Ajoutons nos ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
Récupérons-les maintenant . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
Le registre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419

41 Diffuser mon application 425


Définition de l’assembly . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
Debug et Release . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
La publication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427

xii
Première partie

La théorie et les bases