Objectif Général
Ce chapitre introductif commence par présenter ce qu’est la programmation évènementielle et
explique la différence entre ce type de programmation et la programmation procédurale. Il offre une vue
d’ensemble de la plate-forme .NET et présente l’architecture sur laquelle se base cette plate- forme.
Objectifs Spécifiques
A la fin de ce chapitre les étudiants auront les connaissances nécessaires pour :
Connaitre la différence entre la programmation événementielle et la programmation
Procédurale ;
Connaitre les principaux éléments de la plate- forme .NET.
Connaitre le rôle de Visual Studio .NET dans la plate- forme .NET.
Pré-requis
Algorithmique, programmation procédurale.
Volume horaire
3 Heures
Table des matières
Section 1 : Introduction à Visual Basic .NET - Structures de base................................................ 6
1.1 Variable et opérations arithmétiques.................................................................................................. 6
1.1.1 Notion de Variable ........................................................................................................................................... 6
1.1.2 Opérateurs arithmétiques .................................................................................................................................. 7
1.2 Instructions conditionnelles ................................................................................................................. 8
1.2.1 If … Then … Else … End If ............................................................................................................................ 8
1.2.2 IIf (Condition, ValeurSiVrai, ValeurSiFaux) ................................................................................................. 10
1.2.3 Select case … Case … Case …Else Case … End Select .............................................................................. 10
1.3 Tableaux .............................................................................................................................................. 11
1.4 Instructions répétitives ....................................................................................................................... 12
1.4.1 For … To … Next ......................................................................................................................................... 12
1.4.2 Do While … Loop / Do … Loop While … .................................................................................................... 13
1.4.3 Do Until … Loop / Do … Loop Until … ....................................................................................................... 14
1.4.4 For … Each … Next....................................................................................................................................... 15
1.4.5 Conclusion...................................................................................................................................................... 15
1.5 Procédures et Fonctions ..................................................................................................................... 15
1.5.1 Procédure (Transmission par valeur : ByVal) ............................................................................................... 16
1.5.2 Procédure (Transmission par référence : ByRef) ........................................................................................... 16
1.5.3 Fonction......................................................................................................................................................... 17
1.5.5 Portée des variables, procédures et fonctions ................................................................................................. 18
1.5.6 Quelques fonctions globales ........................................................................................................................... 19
1.5.7 Interruption de séquences ............................................................................................................................... 20
Section 2. Introduction à l’environnement de développement VB ................................................ 21
2.1 Environnement VB ............................................................................................................................. 21
2.1.1 Formulaires (Forms) ....................................................................................................................................... 21
2.1.2 L’explorateur des solutions ............................................................................................................................ 24
2.1.3 La fenêtre Properties....................................................................................................................................... 25
2.1.4 La boîte à outils et les contrôles standards ..................................................................................................... 27
2.2 Programmation par événements ...................................................................................................... 29
2.3 Exercices .............................................................................................................................................. 33
Section 3. Les contrôles ................................................................................................................... 34
3.1 Concept d’objet................................................................................................................................... 34
3.2 Contrôles standards............................................................................................................................ 35
3.2.1 La propriété “Name” ...................................................................................................................................... 35
3.2.2 Label ............................................................................................................................................................... 36
3.2.3 TextBox .......................................................................................................................................................... 36
3.2.4 RadioButton.................................................................................................................................................... 36
3.2.5 CheckButton ................................................................................................................................................... 38
3.2.7 GroupBox ....................................................................................................................................................... 39
3.2.8 Exercices ........................................................................................................................................................ 41
3.2.9 ListBox ........................................................................................................................................................... 42
3.2.10 ComboBox.................................................................................................................................................... 42
3.2.11 La propriété Items......................................................................................................................................... 42
3.2.12 Exercices ...................................................................................................................................................... 45
3.2.13 Solution ........................................................................................................................................................ 47
3.2.14 L’éditeur de menus ....................................................................................................................................... 49
3.2.14 L’éditeur de menus ....................................................................................................................................... 49
1. Introduction à Visual Basic et .NET
1.1 Définition
En informatique, une programmation événementielle se dit d'un type de programmation
fondé sur les événements. Elle s'oppose à la Programmation séquentielle. Le programme sera
principalement défini par ses réactions aux différents événements qui peuvent se produire.
Les applications écrites en langage séquentielle s’exécutent en avançant logiquement, ligne
après ligne, dans le code du programme. Le flux logique peut être temporairement transféré à
d’autres parties du programme au moyen de diverses instructions de code, dirigeant le programme
du début à la fin.
Dans une application événementielle, les instructions du programme ne s’exécutent que
lorsqu’un événement spécifique appelle une section de code associée à cet événement. Ces
événements peuvent correspondre à une action de l'utilisateur : un clic sur un bouton de commande,
une écriture dans une zone de texte, un choix dans une case d'option ou une case à cocher, le
déplacement d'un objet, ...
La programmation événementielle peut être réalisée dans n'importe quel langage de
programmation, bien que la tâche soit plus aisée dans les langages de haut niveau (comme Java).
1.2. Historique de Visual Basic
Visual Basic (VB) est un langage de programmation événementiel de troisième génération Il
permet le développement rapide d'applications, la création d'interfaces utilisateur graphiques, l'accès
aux bases de données…
1964 John Kemeny et Thomas Kurz invente le BASIC. Leur but était d'enseigner les
fondements de la programmation à leurs étudiants.
1975 Paul Allen et Bill Gates créent un nouveau BASIC : Le 4K Basic.
1979 Ils améliorent le BASIC pour l'utiliser avec le 8080 (en 16 bits)
Mai 1991 Naissance de Visual Basic 1.0 avec IHM
Novembre 1992 Microsoft annonçait la mise en marché de Visual Basic 2.0
1993 Visual Basic 3.0
Aout 1995 la version 32-bits de Visual Basic 4.0 est lancée.
mars 1997 Visual Basic 5.0 Visual Studio 97 incluait Visual Basic 5.0
juin 1998 Visual Basic 6.0 Visual Studio (6.0)
2002 Visual Basic .NET est le successeur désigné de Microsoft à Visual Basic 6.0, et
fait partie de la plate-forme Microsoft Visual Studio .NET (2002). Celui-ci se
compile et s’exécute sur l'architecture .NET(le framework .NET) ;
Tableau1.1 : Historique de Visual Basic
1.3. Visual Studio .NET
Microsoft Visual Studio est une suite de logiciels de développement pour Windows
conçu par. C’est un environnement de développement qui permet le design, le développement, le
débogage et le déploiement rapide des solutions basées sur .NET Framework. Il est possible
d’accéder à tout un ensemble commun d’outils, de concepteurs et d’éditeurs à partir de n’importe
quel langage de programmation Visual Studio .NET (C Sharp, C++…..)
1.4 .NET
.NET (prononcez «Dot net») est un standard proposé par la société Microsoft, pour
le développement d'applications d'entreprises multi- niveaux, basées sur des composants. La plate-
forme .NET a été élaborée en s'appuyant sur une communauté d'utilisateurs et a abouti
àl’élaboration de spécifications. Ces spécifications ont été ratifiées par un organisme international
de standardisation, l'ECMA (European Computer Manufacturers Association).
2.2. Architecture du [Link]
-4-
La plate- forme .Net fournit un ensemble de technologies et d’outils facilitant le
développement d’applications et propose une solution pour pratiquement tous les types
d’applications :
Applications Windows : Ce modèle contient les outils, la structure et le code de
démarrage pour une application standard basée sur Windows.
Application Web ([Link])
Services Windows,
Services Web XML: sont des applications hébergées sur un serveur Web
Auxquelles les clients accèdent par l’intermédiaire du Web.
Tous ces types d’applications sont réalisables grâce à un élément essentiel : le [Link]. Ce
Framework prend en charge l’intégrité de la vie d’une application, du développement jusqu'à
l’exécution.
Le Framework .NET comprend notamment :
-5-
CLR (Common Language Runtime) : permettant de compiler le code source de
l'application en un langage intermédiaire, appelé MSIL (Microsoft Intermediate Language).
Lors de la première exécution de l'application, le code MSIL est à son tour compilé en
code spécifique au système grâce à un compilateur JIT (Just In Time).
Bibliothèques de classes .NET : Il y a trois couches au-dessus du (CLR), chacune
comportant des classes apportant des fonctionnalités de plus en plus évoluées.
Dans la première couche se trouve la Base Class Library (BCL), rassemblant des classes
permettant les manipulations de chaînes de texte, la gestion des entrées/sorties, des communications
réseaux, des processus légers et le design des interfaces utilisateur. La librairie de classe de .NET
Framework est organisée en nom d’espace hiérarchisé (figure
1.2). Un nom complet de classe comporte le "chemin" hiérarchique de son espace de nom et
se termine par le nom de la classe exemples :
La classe DataSet qui se trouve dans l'espace de noms "[Link]" se déclare
comme
"[Link]".
La classe Console qui se trouve dans l'espace de noms "System" se déclare
comme
"[Link]".
La classe DataAdapter qui se trouve dans l'espace de noms "[Link] " se
déclare comme "[Link]. [Link]
Classes d’accès aux données : La deuxième couche est composée de deux
bibliothèques de classes d'accès aux données. Tout d'abord, [Link] (DATA)
permettant l'accès sous format XML aux interfaces de bases de données SQL Server,
ODBC, OLE
DB, Oracle et Sybase. Les XML Classes permettent de manipuler les données XML.
XML Web Services, Web Forms, Windows Forms: La dernière couche, la plus élevée,
est utilisée pour la création de services web, de pages Web, et d'applications Windows.
Les deux premiers forment [Link].
Compilation et exécution d'une application .NET
Quand une application .NET est compilée, elle n'est pas compilée en code binaire machine,
mais dans un code binaire intermédiaire MSIL. Une application consiste donc en un
ensemble d'assemblages contenus dans un ou plusieurs fichiers exécutables (.EXE) ou
fichiers DLL en format MSIL.
Quand l'exécution d'un programme démarre, le premier assemblage est chargé en mémoire.
Le CLR commence par examiner les permissions demandées par cet assemblage et les compare à la
-6-
politique de sécurité du système. Puis, si l'assemblage est autorisé à s'exécuter, un processus est
créé pour exécuter l'application. Le premier morceau de code nécessaire à l'exécution est chargé
en mémoire et est compilé en code binaire natif par le compilateur juste à temps (Just-In-Time,
JIT). Une fois compilé, le code est exécuté et stocké en mémoire sous forme de code natif,
garantissant ainsi que chaque portion de code n'est compilée qu'une seule fois lors de l'exécution
de l'application.
-7-
-8-
Espace de travail VB
Boîte à outils (Toolbox) Explorateur de solution
(non active = barre grise)
Un formulaire (Form) sélectionné Fenêtre des propriétés (Property
de nom ‘Form1’ window). Propriétés de l’objet
sélectionné (Form1)
Figure 1: Environnement de développement Visual Basic .NET
-9-
Chapitre 2 : Langue et syntaxe VB .NET
Objectifs : Maitriser les structures de base de la programmation en [Link]
Remarque préliminaire :
• VB ne fait pas de distinction entre les minuscules et les majuscules. Ainsi, ValeurVariable
et vALEURvARIABLE représentent la même variable.
I- Notion de Variable
Les variables sont nécessaires pour stocker (conserver) une valeur dynamique et réutilisable. C'est
en fait une simple zone mémoire qui porte un nom choisi par le programmeur. Le nom de la
variable est une adresse mémoire. La déclaration se fait avec le mot réservé Dim.
Syntaxe
Dim NomVariable As Type
Pour la lisibilité du code, on peut ajouter un commentaire après une apostrophe ( ‘ )
Exemple
‘ Ceci est un commentaire
Dim Taux as Single ‘ Taux de la TVA
Dim Réponse As String ‘ Mot proposé par le joueur
Pour initialiser les variables déclarées on procède comme suit :
NomVariable = valeur_initialisation
Exemples
Compteur = 0 ‘ = est le symbole d’affectation en VB
Taux = 21
II- les types en VB
Le langage VB utilise plusieurs types de données dont les plus utilisés sont le type String (chaîne
de caractères), le type Integer (entier) et le type Single (décimal). Les types standards de données en
VB sont résumés dans le tableau ci-dessous.
Types standards de données
Opérateur Plage de valeurs Déclaration et affectation
Integer Nombres entiers de –32 768 à +32 767 Dim Nb As Integer
Nb = 100
Single Nombres réels avec précision de sept décimales Dim Mt As Single
Mt = 45.11
Valeurs négatives :
E E
de –3,402823 38 à –1,401298 -45
Valeurs positives:
E
de 1,401298 -45 à 3,402823E38
String Chaîne de caractères pouvant aller jusqu'à Dim as String
Prénom = “Jean”
65535 caractères (environ 2 milliards si la
longueur est variable)
Long Nombres entiers de Dim Profit As Long
- 10 - Profit = 123 465 789
–2 147 483 648 à +2 147 483 647
Double Nombres réels avec précision de seize décimales Dim DblPrec As Double
Mt = 1.23456789012
Valeurs négatives :
E
De –1,79769313486232 308
E
à –4,94065641247 -324
Valeurs positives:
E
De 4,94065641247 -324
E
à 1,79769313486232 308
Byte Nombres entiers de 0 à 255 Dim BitPattern As Byte
BitPattern = 128
Boolean Vrai ou faux (valeur logique) Dim Test As Boolean
Trouvé = True
Date De 1/1/100 à 31/12/9999 Dim JourPlus As Date
JourPlus = “06/06/44”
Currency Nombres entiers Dim Valeur As Currency
de – 922337203685477,5808
à 922337203685477,5808
III- Opérateurs arithmétiques
VB reconnaît les opérateurs arithmétiques usuels qui sont résumés dans le tableau suivant :
Opérateurs arithmétiques
Opérateur Description Exemples
+, - Addition et soustraction 12 + 34; 87.56 – 387.222
* Multiplication 45.87 * 4
/ Division décimale 36 / 25 = 1.44
^ Puissance 5 ^ 3 =125
\ Division entière 36 \ 25 = 1
MOD Modulo (reste de la division entière) 36 MOD 25 = 11
Si, dans une expression arithmétique plusieurs opérateurs sont utilisés, les priorités sont résolues
comme indiqué dans le tableau qui suit :
Priorité des opérateurs arithmétiques
Opérateur Description Priorité
( ) Parenthèses 1
^ Puissance 2
- Négation 3
*,/ Multiplication et division 4
\ Division entière 5
MOD Modulo 6
+, - Addition et soustraction 7
- 11 -
Chapitre 3 : LES STRUCTURES DE CONTRÔLE
I- Structures conditionnelles
Les deux instructions conditionnelles le plus utilisées en VB sont If et Select Case.
1 If … Then … Else … End If
Si la condition se trouvant après le mot réservé If est vraie, les instructions qui suivent le mot réservé
Then sont exécutées sinon, ce sont celles qui suivent le mot réservé Else qui sont exécutées.
L’instruction If se termine (obligatoirement) avec les mots réservés End If.
a. Forme simple :
Syntaxe
If condition(s) Then
Instruction11
Instruction12
Else
Instruction21
Instruction22
End If
Exemple
If Moyenne >= 12 Then
Admis = Admis + 1
MsgBox(" Candidat admis ") ‘ affiche une fenêtre avec le message indiqué
Else
Ajournés = Ajournés + 1
MsgBox(" Candidat ajourné ")
End If
b. Forme imbriquée
Syntaxe
If condition(s) Then
Instruction11
If condition Then
Instruction12
Else if condition Then
Instruction13
Else
Instruction14
End If
…
Else
Instruction21
Instruction22
…
End If
- 12 -
Exemple
If NombreProposé > NombreATrouver Then
MsgBox("Votre nombre est trop grand!")
ElseIf NombreProposé < NombreATrouver Then
MsgBox("Votre nombre est trop petit !")
Else
End If
MsgBox("Gagné !")
c. Opérateurs de comparaison
Opérateur Signification Exemple Résultat
= Egal à 15 = 11 + 4 True
> Supérieur à 17 > 11 True
< Inférieur à 17 < 11 False
<> Différent de 23 <> 23.1 True
>= Supérieur ou égale à 23 >= 23.1 False
<= Inférieur ou égal à 23 <= 23.1 True
Si plusieurs conditions doivent être testées, celles-ci doivent être combinées avec des opérateurs
logiques. VB accepte les opérateurs logiques suivants: AND, OR, NOT et XOR. La signification
de chacun d’eux est présentée dans le tableau qui suit:
d. Opérateurs logiques
Opérateur Signification Exemple Résultat
AND Connexion ET. Il faut que les conditions soient ( 1 = 1) AND (2 < 4) True
vraies pour que le résultat soit vrai ( 1 > 2) AND (2 = 4) False
OR Connexion OU. Il faut que l’une des deux ( 1 = 2) OR (3 < 2) False True
conditions soit vraie pour que le résultat soit vrai ( 1 > 2) OR (2 > 1)
NOT Connexion NON. La valeur logique est inversée EstCeVrai = True
NOT EstCeVrai False
XOR Connexion OU exclusif. Une seule des deux ( 1 = 1) XOR (2 = 2) False
conditions doit être vraie pour que le résultat soit ( 2 > 1) XOR (3 < 1) True
vrai
d. IIf (Condition, ValeurSiVrai, ValeurSiFaux)
Cette instruction (IIF) fonctionne comme le IF d'EXCEL.
Syntaxe
IIf (Condition, ValeurSiVrai, ValeurSiFaux)
Exemple
- 13 -
Dim Note As Single
Dim Réponse As String
Note = InputBox (" Tapez votre note ")
Réponse = IIf (Note >= 10, " Admis ", " Ajourné
") MsgBox (Réponse)
2. Select case … Case … Case …Else Case … End Select
L’instruction Select Case est une instruction conditionnelle alternative, c’est-à-dire qu’une
expression peut être testée par rapport à plusieurs valeurs possibles.
Syntaxe
Select Case expression
Case
Liste_Valeurs_1
Instruction11
Instruction12
…
Case
Liste_Valeurs_2
Instruction21
…
…
Else
Case
InstructionElse1
InstructionElse2
…
End Select
Les instructions se trouvant après ‘Case Liste_Valeurs_i’ seront exécutées si ‘expression = à l’un
des éléments de Liste_Valeurs_i’, i = 1, 2, 3, …. Sinon, les instructions se trouvant après ‘Else
Case’ seront exécutées. Liste_Valeurs_i peut être :
• une suite de valeurs : 1, 3, 5, 7, 9
• une fourchette de valeur : 0 To 9
• une plage de valeur : Is >= 10 (Is est un mot réservé)
Exemple
Select Case CodeASCIICaractère
Case 65, 69, 73, 79, 85
MsgBox(" C’est une voyelle ")
Case 66 To 90
MsgBox(" C’est une consonne ")
Case Else
MsgBox(" Ce n’est pas une lettre ")
End Select
Notez que ‘Liste_Valeurs_i’ peut être une combinaison de listes de valeurs comme dans le cas des
exemples suivants :
Case 1 To 4, 7 To 9, 11, 13, Is > NombreMAx
Case "Lundi", "Mercredi", "Dimanche", VariableJour
Numéro 65 66 67 … 89 90
Majuscule A B C … Y Z
- 14 -
VB permet de travailler avec des tableaux de deux, trois, quatre, dimensions ou plus
Exemple d'un tableau à deux dimensions:
Dim ExempleMatrice(10, 10) As Single
ExempleMatrice est une matrice (de nombres réels) de 11 lignes et 11 colonnes et où
ExempleMatrice(1, 9) est l’élément se trouvant à l’intersection de la première ligne et de la
2
dixième colonne .
Exemple de déclaration d’un tableau à trois dimensions:
Dim ExempleMatrice(10, 10, 10) As Single ‘ matrice à trois dimensions
II. Instructions répétitives
Les instructions répétitives sont utilisées pour boucler sur une suite d’instructions.
1 For … To … Next
Si le nombre de boucles est connu à l’avance, on utilise l'instruction For … To … Next.
Syntaxe
For Compteur = Début To Fin [Step Incrément]
Instructions
[ ... Exit For] ‘ pour une interruption préalable de la boucle
[Instructions]
Next [Compteur] ‘ le mot Compteur est facultatif
Le test (Compteur = Début) est effectué au début de la boucle. La variable numérique Compteur
est incrémentée à chaque fin de boucle du nombre indiqué par l’incrément. Si l’Incrément (le pas
par lequel Compteur augmente à chaque boucle) n’est pas spécifié, il est fixé par défaut à 1.
Si la valeur de Fin est inférieure à la valeur de Début, l’incrément est négatif. La valeur de
Compteur peut être utilisée (par exemple, pour numéroter le passage dans la boucle) mais ne doit
pas être modifiée dans le corps de la boucle.
Exemple
Dim i As Integer
Dim Chaîne As String
Dim TabInitial(1 To 12) As Single
For i = 1 To 12
Chaîne = InputBox("Température N° " & Compteur)
TabInitial(i) = Chaîne
Next i ‘le i n’est pas obligatoire
2 Do While … Loop / Do … Loop While …
Test antérieur
Syntaxe
Do While Condition
Instructions
- 15 -
[... Exit Do]
[Instructions]
Loop
La condition est ici testée au début, c'est-à-dire à l’entrée de la boucle. Avec While (tant que), la
boucle est répétée tant que la condition est vraie. Si la condition n’est pas vraie au départ, les
instructions de la boucle ne sont pas exécutées.
Exemple
Do While MotProposé <> MotDePasse
MotProposé = InputBox("Donnez votre mot de passe")
Loop
Cela présuppose que MotProposé soit initialisé par une valeur autre que MotDePasse (par exemple,
la valeur par défaut "").
Test postérieur
Syntaxe
Do
Instructions
[... Exit Do]
[Instructions]
Loop While Condition
La condition est alors testée à la fin de la boucle. Avec While (tant que), la boucle est répétée tant
que la condition est vraie. Les instructions de la boucle sont donc exécutées au moins une fois.
Exemple
Do
MotProposé = InputBox("Donnez votre mot de passe")
Loop While MotProposé <> MotDePasse
Cet exemple ne présuppose aucune initialisation de MotProposé.
3 Do Until … Loop / Do … Loop Until …
Test antérieur
Syntaxe
Do Until Condition
Instructions
[... Exit Do]
[Instructions]
Loop
La condition est ici testée au début, c'est-à-dire à l’entrée de la boucle. Avec Until (jusqu'à), la
boucle est répétée jusqu'à ce que la condition soit vraie. Si la condition est vraie au départ, les
instructions de la boucle ne sont pas exécutées.
Exemple
- 16 -
Do Until MotProposé = MotDePasse
MotProposé = InputBox("Donnez votre mot de passe")
Loop
Cela présuppose que MotProposé soit initialisé par une valeur autre que MotDePasse (par exemple,
la valeur par défaut "").
Test postérieur
Syntaxe
Do
Instructions
[... Exit Do]
[Instructions]
Loop Until Condition
La condition est alors testée à la fin de la boucle. Les instructions de la boucle sont donc exécutées
au moins une fois. Avec Until (jusqu'à), la boucle est répétée jusqu'à ce que la condition soit vraie.
Exemple
Do
MotProposé = InputBox("Donnez votre mot de passe")
Loop Until MotProposé = MotDePasse
Cet exemple ne présuppose aucune initialisation de MotProposé.
1.4.5 Conclusion
Selon le problème à traiter, vous aurez le choix entre ces différentes structures de contrôle. Il
s'agira de choisir la plus élégante ou du moins, celle qui ne provoquera pas de dysfonctionnement
de votre programme.
Trouvez les erreurs dans les exemples suivants :
Exemple 1:
Dim VotreRéponse As String
Réponse = "LaRéponse"
Do
VotreRéponse = InputBox("Donnez votre réponse")
Loop While VotreMot = Réponse
Exemple 2
Dim Cote As Single
Do Until Cote >= 0 And Cote <= 20
Cote = InputBox("Taper une note entre 0 et 20")
Loop
- 17 -
