Programmation Evenementielle Et IHM 1

Support de cours de Programmation Evénementielle et IHM 1
La connaissance ne signifie pas

seulement savoir que 1+1=2.
Elle est une combinaison de trois

éléments :
1) Le savoir savant : Je sais que

1+1=2 (Théorie)
2) Le savoir faire : je sais

calculer 1+1=2 (Pratique)
3) Le savoir être : Je sais

trouver que 1+1=2 (Ethique)
PROGRAMMATION EVENEMENTIELLE ET IHM 1
Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web: www.sergedoumi.net
Page 1
Fiche Matière
PRE REQUIS
Notions de base en programmation événementielle 2
OBJECTIFS GENERAUX
A la fin de ce module l’étudiant sera capable de :

 Comprendre les notions de base liées à l’IDE VB.Net
 Analyser un problème informatique et être capable de l’automatiser à l’aide de VB.Net
 Développer des applications informatiques interactives en VB.Net
 Concevoir des Interfaces Homme Machine Professionnelle
POPULATION
Profil : Brevet de Technicien Supérieur

Option : Génie Logiciel (IGL)
Niveau : 1
EVALUATION
Contrôle continu
Evaluation semestrielle
MOYENS PEDAGOGIQUES
Support de cours
Travaux Pratiques

Page 2
TABLE DES MATIERES

Table des matières .............................................................................................................................. 3
Avantages de l’IDE Visual Studio .NET ............................................................................................. 6
I.2. L’environnement Visual Studio .NET ............................................................................................. 6
L’écran d’un projet en développement ........................................................................................... 7
La fenêtre de code ........................................................................................................................... 7
II. Introduction à la programmation Visual Basic ............................................ Erreur ! Signet non défini.
II.1. En général ............................................................................................. Erreur ! Signet non défini.
II.4. Application Windows Forms................................................................. Erreur ! Signet non défini.
II.5. Opérateurs arithmétiques ............................................................................................................ 8
II.6. Opérateurs relationnels et logiques ............................................................................................. 8
II.9. Les types de données ................................................................................................................... 9
II.10. Utilisation d’une boîte de dialogue .......................................................................................... 11
III. structures de contrôle ET programmation modulaire ............................... Erreur ! Signet non défini.
III.1. Mots clés du langage Visual Basic ............................................................................................. 29
III.2. Structures de choix .................................................................................................................... 30
La structure «If…Then» ................................................................................................................. 30
Structure de contrôle «If … else … end if » ................................................................................... 31
Structure de sélection multiple «Select Case» .............................................................................. 31
Structure «switch(…)» ................................................................................................................... 33
Structure «iif(…)»........................................................................................................................... 33
Structure «choose(…)» .................................................................................................................. 33
III.3. Structures de répétition ............................................................................................................ 33
Structure de contrôle «While … end while» ................................................................................. 33
Structure de contrôle «Do While … Loop» .................................................................................... 34
Structure de contrôle «Do Until …Loop» ...................................................................................... 34
Structure de répétition «Do … Loop While» ................................................................................. 35
Structure de répétition «Do …Loop Until» .................................................................................... 35
Structure de contrôle «For … Next» .............................................................................................. 36

Page 3
Structure de contrôle «For each… Next» ...................................................................................... 36

III.4. Procédure « Sub … » .................................................................................................................. 37
Exemple d’appels de procédure .................................................................................................... 37
Forme générale d’une procédure ................................................................................................. 38
III.5. Fonction « function … » ............................................................................................................. 39
Exemple d’appels de fonction ....................................................................................................... 39
Fig 54 : exemple d’appel de fonction ............................................................................................ 39
Forme générale d’une fonction ..................................................................................................... 40
Les Méthodes ................................................................................................................................ 40
III.6. Promotion d’arguments ............................................................................................................ 41
III.7. Passage d’argument par valeur et passage par référence ........................................................ 42
III.8. Règles d’accès et visibilite (scope) d’une variable .................................................................... 43
III.9. Génération de nombre aléatoire............................................................................................... 44
III.10. Surchargement (overloading) des procédures et arguments optionnels ............................... 45
Surchargement des procédures .................................................................................................... 45
Arguments optionnels ................................................................................................................... 45
Modules ......................................................................................................................................... 46
IV. Les Tableaux ..................................................................................................................................... 47
IV.1. Tableaux à une dimension ........................................................................................................ 47
IV.2. Passer un tableau à une procédure .......................................................................................... 49
IV.4. Longueur variable de la liste de paramètres............................................................................. 50
vii. Interface graphique 1 ................................................................................ Erreur ! Signet non défini.
VII. 1. les composants de base......................................................................................................... 14
VII.2. Modèle événementiel .............................................................................................................. 18
VII.4. Premiers controles usuels ........................................................................................................ 20
«Labels», «TextBoxes» et «Buttons» ............................................................................................ 20
«GroupBoxes» et «Panels» ........................................................................................................... 21
«CheckBoxes» et «RadioButtons»................................................................................................. 23
«PictureBoxes» .................................................................................................................................. 24

Page 4
VII.5. Événements de la souris .......................................................................................................... 25

VII.6. Événements du clavier ............................................................................................................. 26

Page 5
Chapitre 1 : NOTIONS GENERALES SUR L’IDE VISUAL STUDIO .NET
Avantages de l’IDE Visual Studio .NET
On peut utiliser n’importe quel éditeur texte pour développer des fichiers source d’un
programme .NET. Mais le meilleur environnement est Visual Studio .NET car il c’est un
environnement intégré de développement (IDE) qui offre plusieurs avantages :
 Développement visuel design de formulaire avec la technologie glisser-déposer

 IntelliSense et complétion automatique du code
 Débuggeur intégré
 Construction et compilation automatique
 Intégration d’aide dynamique.
 Etc.
I.2. L’ENVIRONNEMENT VISUAL STUDIO .NET

La version très récente Visual studio 2008 Express V. 9.0x SP est celle que nous
allons utiliser pour développer nos applications. Elle est gratuite et téléchargeable sur la
toile (site de Microsoft). Ce téléchargement procure un fichier essentiel exécutable mais
l’installation nécessite la connexion internet pour le téléchargement de tous les
composants utiles. Cette version installe entre autres le .NET Framework V. 3.5 SP1
qui constitue le socle du développement.
Une version express contrairement à la version complète payante de Visual Studio .NET,
permet d’installer le Framework et un seul support de langage (dans notre cas le Visual
Basic .NET que nous allons souvent appelé VB dans la suite du cours). Donc, l’écran sera
titré Microsoft Visual Basic 2008 Express.
Fig 15 : écran d’accueil de VS 2008: l’on peut ouvrir un projet existant ou en

créer un nouveau.

Page 6
Fig 16 : écran pour choix d’un nouveau ‘gabarit’ ou ‘template’ pour un projet VB
L’écran d’un projet en développement
Fenêtre qui contient tous les

éléments de la solution
Onglets Objet projet :

du essayez clic
Contient projet droit/ajouter/n
les outils ouvel élément
pour le par exemple.
design
de
l’interfac
e et
Fenêtre qui
d’autres
permet de
Formulaire actif ici spécifier les
« form2 en mode propriétés d’un
design, l’onglet à sa objet
droite ouvre la fenêtre
de son code (comme
Fig 18 : fenêtre du projet « test03 » en développement
La fenêtre de code
La programmation sur la plate-forme .NET est orientée objet : le principal élément est
« la classe » qui définit un objet à travers ses propriétés et ses méthodes. Et le
programmeur bénéficie d’un grand nombre de classes prédéfinies regroupées en espaces
de noms ou namespaces dont l’ensemble forme de FCL(Framework Class Library).
L’IDE que nous utilisons facilite très bien l’implémentation de cette notion d’orientée
objet. Le plus gros élément conteneur qui est le formulaire est édité en mode concepteur
(design) et constitue une classe vue en mode code.

Page 7
II.5. OPERATEURS ARITHMETIQUES

Avec Visual Basic, il existe des opérateurs arithmétiques afin d’effectuer des
opérations sur les nombres. Voici la liste des opérateurs en ordre de précédence
Opér Opération Ordre d’évaluation Expression dans VB
ateur(s)
() Parenthèse Les parenthèses sont évaluées en a - (b (c + d) )

premier. Si les parenthèses sont
imbriquées, on évalue l’expression la Premièrement, c et d
plus interne. S’il existe des seront additionnés.
parenthèses au même niveau, on Ensuite, b multipliera le
évalue l’expression de gauche à résultat de c + d, et
droite. finalement on soustrait ce
résultat de a.
^ Exposant Évalué en deuxième. S’il existe 10^3 = 103

plusieurs exposants, en évalue de
gauche à droite. Ici on veut le résultat de
10 exposant 3.
+,- Signe Troisième élément évalué. Si -5 : Le chiffre moins 5
d’opération. plusieurs, évalué gauche à droite. +3 : Le chiffre plus 3
*,/ Multiplication Évalué en quatrième, si plusieurs, 4 * 5 =20

évalué gauche à droite.
Division (float) 10.4 / 2 = 5.2
\ Division Évalué en cinquième position. Si 10 \ 2 = 5

(integer) plusieurs, évalué de gauche à droite.
Mod Modulo Sixième évalué, si plusieurs, évalué 10 Mod 7 = 3

de gauche à droite.
+,- Addition Dernière opération évalué, si 10 + 5 =15

plusieurs, évalué gauche à droite
Soustraction 10 – 5 = 5
Fig 30 : Tableau des opérateurs arithmétiques
II.6. OPERATEURS RELATIONNELS ET LOGIQUES

Pour évaluer des opérations ou comparer des valeurs, on a besoin des opérateurs
relationnelles et logiques. Voici la liste de ces opérateurs.

Page 8
Opérateur Opérateur dans VB Exemple d’une Interprétation de l’opération

opération
= = x=y x est égal à y
 <> x <> y x est pas égal à y
> > x>y x est plus grand que y
< < x<y x est plus petit que y
 >= x >= y x est plus grand ou égal à y
 <= x <= y x est plus petit ou égal à y
Fig 31 : Tableau des opérateurs relationnels
II.7. LES TYPES DE DONNÉES

En vb, il y a des types dits types valeur et ceux dits types référence. Ce qui explique en
partie le passage en paramètres par valeur et le passage par référence.
- Le type valeur est utilisé pour « une pièce de donnée » :les prédéfinis sont : integer,
double, long, char, etc. Le programmeur peut construire des types valeurs
(énumérations, structures, etc.
- le type référence a une location dans sa mémoire où la donnée est stockée. Cette
location peut contenir plusieurs « pièces de donnée » : les prédéfinis sont : string,
object. Le programmeur peut construire des types références comme les tableaux, les
fichiers, les classes, les interfaces, etc
Type Taille en bits Plage de valeurs
Boolean 16 True ou False
Char 16 Un caractère Unicode
Byte 8 0 à 255
Date 64 1 Janvier 0001 à décembre 9999
0 :00 :00 à 23 :59 :59
Decimal 128 1.0E-28 à 7.9E+28
Short 16 -32,768 à 32,767

Page 9
Integer 32 -2,147,483,648 à 2,147,483,647
Long 64 -9,223,372,036,854,775,808 à
9,223,372,036,854,775,807
Single 32  1.5E-45 à  3.4E+38

Double 64  5.0E-324 à  1.7E+308
Object 32 Donnée de n’importe quel type.
String Nombre de caractères 0 à ~2000000000
Fig 34 : Tableau des types prédéfinis en VB (les types référence sont dans le
fond gris)
II.8. LES NOMS DE VARIABLES

 L'utilisation de majuscules ou minuscules n'a pas d'importance, sauf pour la lisibilité ;
 Le nom doit commencer par une lettre ;
 Maximum de 255 caractères ;
 Ne doit pas contenir d'espaces ;
 Le nom d’une variable peut contenir des signes exceptés ceux qui décrivent un type de
données comme : ! single, # double,% integer, $ string, & long, @ currency ;
 Le trait d'union - quoique légal est fortement déconseillé car il porte à confusion avec
l'opération moins; utilisez plutôt le underscore comme: nom_famille ou les majuscules
comme: nomFamille ;
 Ne doit pas être un mot réservé (qui fait partie du code).
II.9. LA DÉCLARATION DE VARIABLES
Définir une variable au début d'une procédure, juste avant son utilisation ou dans la
section "Declarations" en utilisant Dim
Dim unEntier As Integer
Dim nomClient As String
Dim montantDu As Double
Ceci a pour effet de spécifier le nom d'un espace de stockage et d'annoncer au
compilateur le type de valeur qui sera contenue. Cela permet une gestion plus efficace de
la mémoire et aide à éviter les erreurs. On peut aussi déclarer plusieurs valeurs sur une
même ligne:
Dim nomEtudiant As String, noteEtudiant As Single
Dim nbHeures, salBrut, salNet As Single
Dim dateNaiss, dateEmbauche As Date
On peut aussi initialiser les variables en les déclarant :
Dim nbHeures As Integer = 40
Dim monNom As String = "Michel"

Page 10
Dim dateEmbauche As Date = #1995-10-30#

Dim valUn As Integer = 0, valDeux As Integer = 0
II.10. LA DECLARATIONS DES CONSTANTES

Une constante est une valeur qui ne change pas au cours de l'exécution d'une procédure; on la déclare avec
Const comme:
Const ValeurPi = 3.1416
II.11. LA PORTÉE DES VARIABLES (SCOPE)

Une variable déclarée dans une procédure avec l'instruction Dim est locale; lorsqu'on
sort de la procédure la variable n'existe plus.
Si on déclare la variable dans la section General/Declarations avec Dim, la variable est
locale au module.
Si on déclare la variable dans la section General/Declarations d'un module, avec l'instruction
Public au lieu de Dim, la variable est globale et elle est disponible à l'application toute
entière.
II.12. UTILISATION D’UNE BOITE DE DIALOGUE

La plupart des applications, avec une interface utilisateur, affichent une boîte de
dialogue pour avertir l’utilisateur d’une erreur, d’un résultat, d’un message ou de la
confirmation d’une action. La classe «MessageBox» qui permet cette fonctionnalité fait
partie du namespace «Imports System.Windows.Forms». Il faut absolument ajouter
cet espace de noms au début du code avec « imports… » particulièrement dans le cas
d’une application console qui ne l’importe pas systématiquement.
Lorsque «MessageBox.Show» est utilisée, une boîte dialogue apparaît. La

méthode «Show» peut admettre 1,2,3 ou 4 arguments : elle est surchargée ou overload.
Le 1er argument est le message et le 2ème , le titre de la boîte à dialogue comme
auparavant. Le 3ème argument est une constante indiquant le type de bouton. Liste des
constantes indiquant le type de bouton (fig 36). Le 4ème argument lui, change l’icône
dans la boîte à dialogue. (fig 37).:
Fig 35 : cas d’ne boîte de dialogue avec 2 arguments seulement: le message et

le titre)
Constantes de MessageBoxButton Message Box
MessageBoxButtons.OK

Page 11
MessageBoxButtons.OKCancel
MessageBoxButtons.YesNo
MessageBoxButtons.YesNoCancel
MessageBoxButtons.RetryCancel
MessageBoxButtons.AbortRetryIgnore
Fig 36 : Les différents boutons correspondant aux différentes constantes

prédéfinies
Constantes de Icône
MessageBoxIcon
MessageBoxIcon.Exclamation

Page 12
MessageBoxIcon.Information
MessageBoxIcon.Question
MessageBoxIcon.Error
Fig 37 : Les différentes icônes correspondant aux différentes constantes

prédéfinies

Page 13
Chapitre 2 : INTERFACE GRAPHIQUE 1
2. 1. DEFINITION
Une interface graphique permet aux utilisateurs d’interagir avec un programme.

L’interface graphique est souvent appelée GUI (Graphical User Interface). Il existe plusieurs
composantes de base afin de construire ce type d’interface :
2. 2. LES COMPOSANTS DE BASE
Les formulaires Windows sont utilisés pour créer des programmes GUI. Un
formulaire (forms) est un élément graphique qui apparaît sur le bureau. Un formulaire
peut être une boîte à dialogue, une fenêtre ou un MDI (Multiple Document Interface)
windows. Une composante est une instance d’une classe qui implémente l’interface
«IComponent». Cette interface définit les comportements des composantes graphiques.
Un contrôle, par exemple un bouton (button) ou une étiquette (label), sont des
composantes qui ont une représentation lors de l’exécution du programme. Les contrôles
sont visibles mais d’autres comme «timer» ne le sont pas.
Nom de l’objet Description
Label Objet où une icône, une image ou un texte peut être affiché.
Textbox Objet où l’utilisateur peut entrer des données avec le clavier. Cet objet
peut aussi afficher de l’information.
Button Objet qui déclenche un événement lorsqu’il est cliqué.
CheckBox Objet qui est permet la sélection ou la désélection.
ComboBox Objet contenant une liste d’articles dans laquelle l’utilisateur peut faire
une sélection en cliquant dans la liste ou en tapant dans la boîte.
ListBox Objet qui affiche une liste d’articles. L’utilisateur peut sélectionner dans
la liste en cliquant sur n’importe lequel des articles. Plusieurs articles
peuvent être sélectionnés.
Panel Objet qui contient des composantes.
Scrollbar Objet qui permet l’utilisateur d’accéder à un intervalle d’éléments qui

normalement ne peuvent être affichés complètement.
Figure 64: Liste de quelques objets de base

Page 14
La figure suivante montre les contrôles et les composantes d’un formulaire Windows dans
le «Toolbox». Les deux premières images présentent les contrôles que peut contenir un
formulaire et la troisième image présente les composantes.
Pour ajouter un contrôle ou une composante, l’utilisateur sélectionne l’objet voulu

et le jette sur le formulaire. Il faut noter que le pointeur (Pointer) n’est pas un objet, il
sert à redonner le contrôle à l’utilisateur et empêche l’ajout d’un objet sélectionné.
Lorsqu’on utilise plusieurs fenêtres, la fenêtre active est celle en avant de toutes
les autres. Une fenêtre devient active lorsque l’utilisateur clique à l’intérieur de celle ci.
On dit que la fenêtre à le «focus».
Un formulaire est un objet qui sert à contenir les composantes et les contrôles.
Lorsqu’un contrôle est ajouté, Visual Studio .NET génère le code pour nous. Il crée une
instance de l’objet et initialise ses propriétés. On pourrait écrire le code nous même mais
il est plus facile de créer et modifier les contrôles en utilisant les fenêtres «Toolbox» et
«Properties».
Lorsqu’un utilisateur interagit sur des contrôles avec la souris ou le clavier,

certains événements se produisent. Un événement est un message envoyé au
programme afin de signaler qu’une action a été menée. Un événement est utilisé pour
signaler l’interaction d’un utilisateur avec les composantes GUI mais aussi pour signaler
une action interne. Par exemple, en cliquant le bouton OK d’un «MessageBox» génère
un événement.
Le «MessageBox» gère cet événement. Le «MessageBox» est programmé pour

se fermer quand le bouton OK est appuyé.
Chacune des classes présentées dans la prochaine section fait partie du

«namespace» System.Windows.Forms. La classe Form, est la fenêtre de base
utilisée par les applications Windows. Cette classe se retrouve dans
System.Windows.Forms.Form tout comme la classe Button qui se trouve dans
System.Windows.Forms.Button.
Pour créer une application Windows nous avons besoin d’ajuster les propriétés du
formulaire, ajouter des contrôles, changer les propriétés et implémenter les événements.
Voici la liste des propriétés, des méthodes et des événements les plus communs du
formulaire :
Propriétés Description
AcceptButton Bouton cliqué quand on appuie «Enter».

Page 15
AutoScroll Valeur Booléenne qui ajoute ou enlève les «scrollbars».
CancelButton Bouton cliqué quand on appuie «Escape».
FormBorderStyle Style de la bordure du formulaire (none, single, 3D, sizable)
Font Police du texte affiché dans le formulaire et aussi la police par défaut
des autres contrôles ajoutés dans le formulaire.
Text Texte dans la barre titre du formulaire.
Méthodes Descriptions
Close Ferme le formulaire et libère les ressources utilisées. Un formulaire

fermé ne peut pas être ré-ouvert.
Hide Cache le formulaire. Ne détruit pas le formulaire et ne libère pas les

ressources utilisées.
Show Affiche un formulaire caché.
Événement Descriptions
Load Cet événement se produit avant que le formulaire apparaisse à

l’écran. Cette méthode peut être visionnée lorsque l’utilisateur double
clique sur le formulaire.
Figure 66 : liste des propriétés, des méthodes et événements les plus communs pour un
formulaire
2. 3. LES RÈGLES DE NOMMAGE

Quand on crée des contrôles en VB (Visual Basic), l'éditeur leur donne automatiquement
un nom. Par exemple, le premier bouton sera Button1 et le vingtième sera Button20.
Dans le code, quand on voudra se référer au bouton pour exécuter les calculs, est-ce
Button8 ou Button12 ?
Et une variable qu'on a définie, est-ce une "String" ou une "Single" ou une "Double"?
C'est difficile de se rappeler de tous les contrôles et les variables qu'on crée pour pouvoir
s'y retrouver par la suite si on n'utilise
pas un système de référence.
Pour nommer les objets en VB il y 2 facteurs à considérer:

Page 16
 Utiliser toujours un nom significatif pour chaque variable ;

 Respecter les conventions de nommage utilisées dans l’entreprise.

Page 17
2.4. MODÈLE ÉVÉNEMENTIEL

Les applications GUI sont exécutées avec des événements. L’utilisateur provoque
des événements en bougeant la souris, en cliquant la souris, en cliquant un bouton sur le
formulaire, en tapant du texte dans un «textbox», en sélectionnant un article dans un
menu et en ouvrant/fermant une fenêtre. L’information de l’événement est manipulée
par le système à l’aide de méthodes qui sont appelées lorsque qu’un événement
spécifique entre en action. Par exemple, un formulaire change de couleur lorsqu’un
bouton est appuyé. Lorsque l’utilisateur appuie sur un bouton, l’application génère un
événement qui appelle une méthode qui cause le changement de couleur du formulaire.
Les événements sont basés sur une notion qui s’appelle délégation. Les objets
référent à des méthodes. Les événements délégués sont «multicast» (classe
MulticastDelegate), ils représentent des groupes de délégués avec la même signature.
Les délégués «multicast» permettent à l’appel des événements d’être envoyés
séquentiellement. Dans le modèle événementiel, les délégués actent comme
intermédiaires entre les objets qui créent des événements et les méthodes qui
manipulent ces événements.
Objet A génère événement E
Délégué pour événement E
Manipulateur 1 pour événement E Manipulateur 2 pour événement E Manipulateur 3 pour événement E
Les délégués permettent aux classes de spécifier des méthodes qui ne sont pas
nommées ou implémentées jusqu'à ce que la classe soit instanciée. Ce principe est très
utile lors de la création de manipulateur d’événement. Par exemple, le créateur de la
classe «Form» n’a pas besoin de nommer ou de définir la méthode qui va s’occuper de
l’événement Clic. En utilisant les délégués, la classe est spécifiée quand un manipulateur
d’événement est appelé.

Page 18
Lorsqu’un événement est généré, le système appelle toutes les méthodes

référenciées par le délégué. Chacune des méthodes du délégué doit avoir la même
signature parce que toutes les méthodes passent la même information.
Plusieurs situations requièrent les manipulateurs d’événement généré par les

contrôles de .NET comme les boutons ou les scrollbars. Ces contrôles ont déjà des
délégués prédéfinis correspondant à tous les événements qu’ils peuvent générer. Les
programmeurs créent des manipulateurs d’événement et les enregistrent avec les
délégués. Visual Studio .NET aide en automatisant cette tâche. Par exemple, nous créons
un formulaire qui affiche une boîte de message lorsque nous cliquons un «Label».
Ensuite, nous analysons le code de l’événement généré par Visual Studio .NET.
Suivez les étapes pour construire un «Form» qui contient un «Label».

Premièrement, créer une nouvelle application Windows. Sélectionner l’élément «Label»
dans la liste «Toolbox». Jeter le «Label» dans le formulaire pour le créer. Dans la
fenêtre «Properties», donner le nom lblOuput et donner à la propriété «Text» la
valeur “Cliquer moi !».
Nous avons jusqu’ici travaillé dans le mode Design. Ce mode nous permet de
fournir une représentation graphique du programme. Dans l’arrière plan, Visual Studio
.Net a créé du code qui peut être accédé en utilisant l’onglet ou en cliquant n’importe où
à droite dans la fenêtre Design en choisissant «View Code». Pour définir et enregistrer
un manipulateur d’événement pour lblOuput, IDE doit afficher le code de l’application
Windows.
Tout en regardant le code, il faut noter les deux «drop-down menus» dans le
haut de l’éditeur. Le «drop-down menus» à gauche est appelé «Class Name» et
contient la liste de tous les composantes contenues dans notre formulaire. On devrait y
apercevoir lblOuput. Sélectionner cet élément dans le menu. Le «drop-down menus»
à droite est appelé «Méthod Name» et permet au programmeur d’accéder, modifier et
de créer de manipulateur d’événement pour les composantes du formulaire. Cette liste
affiche les méthodes possibles de l’élément sélectionné à gauche.
Nous voulons que le «Label» agisse lorsque nous le cliquons. Sélectionnez

l’événement «Click» dans la «Method drop-down menus». Cette action va créer un
manipulateur d’événement vide dans le code.
Private Sub lblOuput_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles lblOuput.Click
End Sub
C’est cette méthode (procédure) qui sera appelée lorsque l’utilisateur appuiera sur
le «Label». Maintenant, nous voulons ajouter dans cette procédure le code nécessaire

Page 19
pour afficher notre boîte de message. Ajouter la ligne suivante dans le manipulateur
d’événement lblOuput_Click :
MessageBox.Show("Le label a été cliqué")
Votre code doit ressembler à ceci :
Private Sub lblOuput_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles lblOuput.Click
MessageBox.Show("Le label a été cliqué")
End Sub
Compiler le programme et le faire exécuter. Lorsque vous cliquer sur le «Label»,

une boîte de message apparaît et contient «Le label a été cliqué».
2.5. PREMIERS CONTROLES USUELS

«Labels», «TextBoxes» et «Buttons»
Les «Labels» servent à donner des instructions ou de l’information et sont définis
avec la classe Label, qui est dérivé de la classe Control. Un «Label» affiche un texte
qui peut se lire seulement (read-only). L’utilisateur ne peut modifier le texte. Lorsqu’un
programme s’exécute, le «Label» peut être changé avec la propriété «Text». Voici les
principales propriétés de «Label» :
Propriété de «Label» Description
Font Police utilisée pour le texte du « Label»
Text Le texte qui apparaît sur le «Label»
TextAlign L’alignement du texte dans le «Label». Les valeurs possibles sont :

horizontal (à gauche, au centre et à droite) et verticale (en haut,
centre et en bas).
Figure 71 : propriétés et événements principaux de Label
Un «TextBox», classe TextBox, est un endroit dans lequel on peut entrer ou afficher du
texte par le programme ou un utilisateur à l’aide du clavier. Un «password textbox»
est un «TextBox» qui cache l’information entrée par l’utilisateur. Lorsque l’utilisateur
entre des caractères, le «password TextBox» masque les caractères avec un astérisque
(*). Si une valeur est fournit à la propriété «PasswordChar», la «TextBox» devient un
«password TextBox». Les utilisateurs rencontrent souvent les deux types de
«TextBox», lorsqu’ils se loggent in sur un ordinateur ou un site Web dont la page est
protégée.

Page 20
Propriété de «TextBox» Description
AcceptsReturn Si True, en appuyant sur Enter une nouvelle ligne est créée.
«TextBox» doit être multiligne. Si False, appuyant sur
Enter c’est le bouton par défaut du formulaire qui est pressé.
Multiline Si True, «TextBox» permet plusieurs lignes. La valeur par

défaut est False.
PasswordChar Si un caractère est fourni à cette propriété, le «TextBox»

devient un «password TextBox» et le caractère spécifié
devient le masque de chaque caractère entré dans le
«TextBox».
ReadOnly Si True, l’arrière plan de «TextBox» decient gris et le texte

ne peut pas être changé. La valeur par défaut est False.
Scrollbars Pour «TextBox» avec mutiligne, indique si on veut des

«scrollbars». Valeur possible : none, horizontale, verticale ou
les deux.
Text Le texte du «TextBox».
Événement de Description
«TextBox»
TextChanged Lorsque le texte change, cet événement est déclenché.
Figure 72 : propriétés et événements principaux de TextBox
Un bouton est un contrôle que l’utilisateur peut cliquer afin de déclencher une
action spécifique. Un programme peut employer plusieurs types de bouton, comme par
exemple un «checkbox» ou un «radio button». Tous les boutons sont dérivés de la
classe «ButtonBase». Le texte sur un bouton s’appelle «button label».
Propriété de «Button» Description
Text Spécifie le texte sur le bouton.
Événement de «Button» Description
Click Lorsque le bouton est appuyé, cet événement est déclenché.
Figure 73 : propriétés et événements principaux de button
«GroupBoxes» et «Panels»

Page 21
«GroupBoxes» et «Panels» arrangent les contrôles GUI. Par exemple, un bouton

peut être placé dans un «GroupBox» ou dans un «Panel». Tous les objets bougent si on
bouge le «GroupBox» ou le «Panel». La différence entre «GroupBox» et «Panel» est
que «GroupBox» peut afficher du texte et n’inclut pas de «scrollbars». Le «Panel» lui,
ne peut pas afficher de texte mais contient des «scrollbars». «GroupBox» a une petite
bordure par défaut. Le «Panel» a pas de bordure par défaut, mais on peut en ajouter
une avec la propriété «BorderStyle». Les «GroupBoxes» et les «Panels» peuvent
contenir des «GroupBoxes» et des «Panels». On recommande lors du développement
de GUI d’utiliser «anchoring» et «docking» pour les contrôles. Le «GroupBox» et le
«Panel» eux, doivent être «anchorés» ou «dockés» au formulaire.
Lorsqu’un contrôle est placé à l’intérieur d’un «GroupBox», le contrôle est ajouté
à la propriété «GroupBox Control» et devient membre de la classe «GroupBox». La
propriété «GroupBox Control» n’est pas accessible à l’intérieur de la fenêtre propriété.
Cette propriété peut-être accédée à l’intérieur de l’éditeur de code. Cette propriété utilise
un argument qui indique l’index du contrôle. Voici un exemple :
Private Sub Bouton1_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles Bouton_GroupBox3.Click
Dim control_1 As Control
Dim nom As String
control_1 = GroupBox3.Controls(0)
nom = control_1.Name
MessageBox.Show(nom, "Contrôle dans GroupBox3")
End Sub
Propriété de «GroupBox» Description
Controls Liste les contrôles qui sont à l’intérieur de la «GroupBox»

Text Spécifie le texte affiché dans le «GroupBox»
Propriété de Description
«Panel»
AutoScroll Indique si les «scrollbars» apparaît si le «Panel» est trop petit

pour afficher tous les contrôles.
BorderStyle Ajuste les bordure du «Panel».
Controls Liste les contrôles qui sont à l’intérieur de la «Panel»
Figure 74 : propriétés principales de GroupBox et panel

Page 22
«CheckBoxes» et «RadioButtons»
Visual Studio .Net possède deux types de boutons d’état : «CheckBoxes» et

«RadioButtons». Ces deux boutons dérivent de la classe «ButtonBase». Un
«RadioButton» est ordinairement regroupé avec d’autres «RadioButtons», et
seulement un «RadioButton» peut-être sélectionné à la fois. La valeur du
«RadioButtons» sélectionné est vrai (True). Les «RadioButtons» sont utilisés lorsque
l’utilisateur peut choisir une option dans un groupe.

Page 23
Propriété de Description
«RadioButtons»
Checked Indique si le «RadioButtons» est sélectionné.

Text Spécifie le texte disposé à la droite du
«RadioButtons».
«RadioButton»
Click Généré quand l’utilisateur clique sur le

«RadioButtons»
CheckedChanged Généré chaque fois que le «RadioButtons» est
sélectionné ou désélectionné.
Figure 75 : propriétés et événements principaux de RadioButton
Le «CheckBox» est une petite boîte carrée qui peut être cochée ou pas. Lorsque qu’un
«CheckBox» est sélectionné, une petite coche noire apparaît dans la boîte. Il n’y a
aucune restriction comment les «CheckBoxes» sont utilisées : une ou toutes les
«CheckBoxes» peuvent être cochées. Les «CheckBoxes» sont utilisés lorsque
l’utilisateur peut choisir plusieurs options dans un groupe.
Propriété de «CheckBoxes» Description
Checked Indique si le «CheckBoxes» est coché ou pas.

CheckState Indique si le «CheckBoxes» est «Checked»,
«Unchecked» ou «Indeterminate».
Text Spécifie le texte disposé à la droite du «CheckBox».
«CheckBoxes»
CheckedChanged Généré chaque fois que le «CheckBoxes» est

sélectionné ou désélectionné.
CheckedStateChanged Généré chaque fois que la propriété
«CheckedStateChanged» change.
Figure 76 : propriétés et événements principaux de CheckBox
«PICTUREBOXES»
Un «PictureBoxes», classe PictureBox, affiche une image. Une image, objet de la
classe Image, peut être un bitmap, un GIF, un JPEG, un icône ou un format métafichier.
La propriété «Image» spécifie l’image qui sera affiché, la propriété «SizeMode» indique
comment l’image doit être affiché (Normal, StretchImage, Autosize ou CenterImage).
Propriété de «PictureBoxes» Description

Page 24
Image Affiche l’image sélectionnée sur le «PictureBox».

SizeMode Énumération qui contrôle la grosseur et la position de
l’image. La valeur par défaut est Normal. Les autres
options sont StrechImage, AutoSize et CenterImage.
Normal place l’image dans le coin en haut à gauche
de la PictureBox et CenterImage place l’image au
milieu de la PictureBox. L’image est tronquée si elle
est trop grande. StretchImage redimensionne
l’image pour quelle entre dans la PictureBox.
AutoSize redimensionne PictureBox pour contenir
l’image.
«PictureBoxes»
Click Généré chaque fois que l’image est cliqué.
Figure 77 : propriétés principales et événement de PictureBox
2.6. ÉVÉNEMENTS DE LA SOURIS

Dans cette section nous allons couvrir les événements déclenchés par la souris. Tous les
événements de la souris peuvent être détectés par les contrôles qui dérivent de la classe
System.Windows.Forms.Control. L’information de la souris est passée avec
l’argument MouseEventArgs, et le délégué utilise pour créer un manipulateur
d’événement de la souris MouseEventHandler. Chacune des méthodes qui
comprennent un événement de la souris, doit contenir un Object et un
MouseEventArgs. Par exemple, l’événemenrt «Click» utilise le délégué EventHandler
et l’argument EventArgs.
La classe MouseEventArgs contient l’information de la souris, comme les coordonnées x

et y du pointeur, le bouton qui a été appuyé (gauche, droite ou milieu), le nombre de fois
que le bouton a été cliqué et le nombre de cran que la roue de la souris a tourné. Il faut
noter que les coordonnées x-y sont relatives au contrôle. En d’autres mots les
coordonnées (0,0) représentent le coin supérieur gauche du contrôle.
Événement de «Mouse» Description
Délégué : EventHandler
Argument : EventArgs
MouseEnter Généré lorsque le curseur de la souris entre à l’intérieur

de la surface d’un contrôle.
MouseLeave Généré lorsque le curseur de la souris quitte la surface

d’un contrôle.

Page 25
Événement de «Mouse» Description
Délégué : MouseEventHandler
Argument : MouseEventArgs
MouseDown Généré si le bouton est appuyé sur le contrôle.

MouseHover Généré si le curseur de la souris est sur la surface du
contrôle.
MouseMove Généré si le curseur de la souris est bougé pendant qu’il

est sur la surface du contrôle.
MouseUp Généré si le bouton est relâché quand le curseur de la

souris est sur la surface du contrôle.
Propriétés de la classe Description
MouseEventArgs
Button Spécifie le bouton de la souris qui a été appuyé. Bouton
de gauche, bouton de droite, bouton du milieu ou aucun.
Clicks Indique le nombre de fois qu’un bouton à été cliqué.
X Coordonnée x de l’événement sur le contrôle.
Y Coordonnée y de l’événement sur le contrôle.
Figure 78 : événements de la souris
2.7. ÉVÉNEMENTS DU CLAVIER

Cette section explique les manipulateurs lorsque nous appuyons sur une touche. Ces
événements sont hérités de la classe System.Windows.Forms.Control. Il existe deux
types d’événements touches. Le premier est «KeyPress», cet événement est déclenché
lorsqu’une clé représentant un caractère ASCII est appuyé (déterminé par
KeyPressEventArgs propriété de KeyChar). KeyPress événement ne nous permet pas de
déterminer les clés modificatrices quand Shift, Alt et Control ont été appuyés. Le deuxième
type d’événement, KeyUp et KeyDown, nous donne cette possibilité. La classe
KeyEventArgs contient l’information des clés modificatrices. La valeur de l’énumération de
la clé «Key» peut-être retourné, elle donne l’information sur les clés non-ASCII. Souvent les
modificateurs sont utilisés avec la souris afin de sélectionner de l’information.
KeyEventHandler et KeyPressEventHandler sont les délégués pour ces deux classes.

Page 26
Événement de «Keyboard» Description
Délégué : KeyEventHandler
Argument : KeyEventArgs
KeyDown Généré quand une clé est appuyé.
KeyUp Généré quand une clé est relâché.
Événement de «Keyboard» Description
Délégué :
KeyPressEventHandler
Argument : KeyPressEventArgs
KeyPress Généré lorsqu’une clé (touche) est appuyée. Cet

événement arrive répétitivement, tout dépendamment du
taux spécifié dans le système d’exploitation.
KeyPressEventArgs
KeyChar Retourne le caractère ASCII de la clé pressée.
Handled Indique si l’événement de la clé appuyée a été déclenchée.
KeyEventArgs
Alt Indique si la clé Alt a été appuyée.
Control Indique si la clé Control a été appuyée.
Shift Indique si la clé Shift a été appuyée.
Handled Indique si l’événement à été prit en main.
KeyCode Retourne le code de la clé comme une énumération de

Key, combiné sans l’information du modificateur. Utilisé
pour tester une clé spécifique.
KeyData Retourne le code de la clé comme une énumération de

Key, combiné avec l’information du modificateur. Contient
toutes les informations sur la clé appuyée.

Page 27
KeyValue Retourne le code de la clé comme un entier au lieu d’une

énumération de Key. Utilisé afin d’obtenir la représentation
numérique de la clé appuyée.
Modifiers Retourne l’énumération Key des modificateurs appuyés.

Utilisé afin de déterminé l’information de la clé
modificatrice seulement.
Figure 79 : événements principaux du clavier

Page 28
Chapitre 3 LES STRUCTURES DE CONTRÔLE

Afin de pouvoir manipuler l’information, il existe des structures de contrôle. Les
structures de contrôle sont constituées avec des mots-clé. Les mots-clé ne doivent en
aucun cas être utilisés comme identificateur ni comme nom de variable.
III.1. MOTS CLÉS DU LANGAGE VISUAL BASIC

Mot clé de Visual Basic
AddHandler AddressOf Alias And
AndAlso Ansi As Assembly
Auto Boolean ByRef Byte
ByVal Call Case Catch
CBool Cbyte CChar CDate
CDec CDbl Char CInt
Class CLng CObj Const
CShort CSng CStr CType
Date Decimal Declare Default
Delegate Dim DirectCast Do
Double Each Else ElseIf
End Enum Erase Error
Event Exit False Finally
For Friend Function Get
GetType GoTo Handles If
Implements Imports In Inherits
Integer Inteface Is Lib
Like Long Loop Me
Mod Module MustInherit MustOverride

Page 29
MyBase MyClass Namespace New
Next Not Nothing NotInheritable
NotOverridable Object On Option
Optionnal Or OrElse Overload
Overridable Overrides ParamArray Preserve
Private Property Protected Public
RaiseEvent ReadOnly ReDim REM
RemoveHandler Resume Return Select
Set Shadows Shared Short
Single Static Step Stop
String Structure Sub SyncLock
Then Throw To True
Try TypeOf Unicode Until
When While With WithEvents
WriteOnly Xor
Figure 39 : Liste des mots clés ou réservés
III.2. STRUCTURES DE CHOIX

La structure «If…Then»
If condition Then If Nombre < 0 Then
Bloc de code Nombre = -Nombre
End If End If
où condition est une expression booléenne.
Fig 40 : structure « if … then … endif »

Page 30
Structure de contrôle «If … else … end if »

If condition Then If moyenne>=10 Then
Bloc de code 1 Decision =’’admis’’
Else Else
Bloc de code 2 Decision =’’refusé’’
End If End If
Fig 41 : structure « if … then …. Else … end if »
Imbrication
« if … else if … else … endif » , peut être emplacée par « if … elseif … else …

end if »
If moyenne >= 16 Then
mention = “TB”
ElseIf moyenne >= 14 Then
mention = “B”
mention = “AB”
mention = “Passable”
Else
mention = “Rattrapage”
End IF
Fig 42 : simplification d’imbrication de structure « if … else … endif»
Structure de sélection multiple «Select Case»

Page 31
La structure «Select Case» permet d’effectuer une sélection (branchement)

multiple. Voici la syntaxe du «Select Case» :
Exemple :
Select Case variable Select Case nbre
Case condition1 Case 1
Case condition2 mois=”janvier”
… Case 2
Case conditionN mois=”Février”
Case Else Case ...
End Select ...
Case Else
où variable contient la valeur avec laquelle Messagebox.show(“mauvaise

on veut comparer avec les conditions. Si valeur”)
aucune des conditions ne retourne vrai,
«Case Else» sera exécuté. End Select
Fig 43 : utilisation des branchements case (switch en C)

Page 32
On peut utiliser la clause select avec l’un des mots clé To, Is, Is et To. Par exemple :
Select case N Select case N Select case N Select case mot
Case 12 Case Is <12 Case 1, 5 to 7, Is >10 Case ‘‘Abel’’, ‘‘Max
….. ….. ….. …..
Case 13 to 16 Case 12 to 20 Case else Case else
… … … …
Structure «switch(…)»
Elle prend les couples expression, valeurs. Reponse=switch(expr1, valeur1, expr2,
valeur2, …) Exemple : Monnaie=switch(pays= ‘‘USA’’, ‘‘$’’, pays= ‘‘France’’, ‘‘€’’, …)
Structure «iif(…)»
Elle évalue la condition et prend la 1ère valeur si vraie ou la 2ème valeur si fausse.
Exemple : décision =iif(moyenne>= 12, ‘‘Admis’’, ‘‘Refusé’’)
Structure «choose(…)»
Elle choisit la valeur spécifiée avec l’index ou numéro. Exemple :
Pays =choose(2, ‘‘France’’, ‘‘Cameroun’’, ‘‘Angleterre’’, ‘‘USA’’)
Le numéro 2 pourrait être à travers une variable, l’index commence à 1
Fig 44 : autres cas de structure de choix.
III.3. STRUCTURES DE REPETITION

Une structure de répétition donne la possibilité au programmeur d’exécuter
répétitivement une action tout dépendamment d’une condition. Il existe des structures
de répétition telles que : le «while … end while», le «Do While … Loop», le «Do Until …
Loop», le «Do … Loop While», le «Do … Loop until», le « For … next », le « For each …
next ».
Structure de contrôle «While … end while»
La boucle «While» s’exécute tant que la condition spécifiée est vraie. Syntaxe :
While condition i=0

Page 33
Bloc de code While i<10
End While Console.write(i & ’’ ’’)
où le Bloc de code est exécuté jusqu’à ce i++

que condition soit fausse.
end while
Fig 45 : structure “while … end while”
Structure de contrôle «Do While … Loop»

Cette structure a exactement la même fonction que la boucle «While». Syntaxe :
Do While condition i=0
Bloc de code do while i<10
loop Console.write(i & ’’ ’’)

que condition soit fausse.
loop
Fig 46 : structure “do while … loop”
Structure de contrôle «Do Until …Loop»

Cette boucle est différente du «While» et du «Do While». Le «Do Until», s’exécute
tant et autant que la condition est fausse. Syntaxe » :
Do until condition d’arrêt i=0
Bloc de code do until i=10
loop Console.write(i & ’’ ’’)

que condition soit vraie.
loop
Fig 47 : structure “do until … loop”

Page 34
Structure de répétition «Do … Loop While»
Cette structure de répétition est similaire à la boucle «While», sauf que la condition est
évaluée après l’exécution du Bloc de code. Syntaxe :
Do Exemple
Bloc de code i=0
loop while condition do
Console.write(i & ’’ ’’)
le bloc de code sera toujours exécuté au i=i+1

moins une fois, par la suite, condition est
évaluée. Tant et autant que condition loop while i<10
retourne vraie, la boucle s’exécutera.
Fig 48 : structure “do … loop while”
Structure de répétition «Do …Loop Until»

La boucle «Do …Loop Until» est similaire à la boucle «Do Until …Loop», sauf que la
condition est évaluée après l’exécution du Bloc de code. Syntaxe :
Do i=0
Bloc de code do
loop until condition Console.write(i & ’’ ’’)
i++
le Bloc de code sera toujours exécuté au loop until i=10

moins une fois, par la suite, condition est
évaluée. Tant et autant que condition est
fausse, la boucle s’exécutera, et s’arrêtera
dès que la condition retourne vraie
Fig 49 : structure “do … loop until”

Page 35
Structure de contrôle «For … Next»

Cette structure de contrôle s’exécute tout dépendant d’un compteur. Syntaxe :
For compteur = début To fin Step For i=0 to 9 [step 1]

incrémentation/décrémentation
Bloc de code
Next next i
où début est le départ de la boucle et fin est la terminaison de

la boucle. «Step», indique de combien le compteur s’incrémente
ou décrémente à chaque exécution de la boucle. «Step» est
optionnel, s’il n’est pas utilisé, par défaut le compteur
augmentera ou diminuera de 1. «Next» indique la fin de la
structure.
Fig 50 : structure “for … next”
On peut représenter la structure «For …Next» avec la structure «While … end while» :
compteur = début i=0

While i <= 9 ‘ ou >=fin
While compteur <= fin ‘ ou >=fin
Bloc de code
i+=1 ‘ou i++
compteur +=
End While
incrémentation/décrémentation
End While
Fig 51 : représentation de la structure «For …Next» avec la structure «While …

end while»
Structure de contrôle «For each… Next»

Cette structure de contrôle permet de parcourir les éléments d’une collection du
début jusqu’à la fin. La collection peut être un tableau ou tout autre liste d’objets.
Syntaxe :
On peut représenter la structure «For …Next» avec la structure «While … end while» :

Page 36
For each elt in nomCollection Dim elt as integer
Bloc de code For each elt in Tableau ‘tableau d’entiers

Next
Console.write(elt & ’’ ’’)
où elt est une variable de type des
éléments de la collection. Elt prendra donc Next
chaque fois la valeur d’un élément de la
collection.
Fig 52 : la structure «For each …Next»
Exercice 6 : Améliorer les exercices d’applications windows en associant un meilleur

contrôle de l’interactivité avec l’utilisateur.
Exercice 7 : Créer une application console pour la résolution d’une équation de 2nd degré
en prenant en compte les degrés 0 et 1 dans le programme.
Exercice 8 : Application Windows pour faire idem qu’à l’exercice 7
Exercice 9 : Application Windows pour calculer les factoriels des différents nombres <=
à un nombre donné au clavier.
III.4. PROCEDURE « SUB … »

Dans les programmes application console (et même les applications), il existe un
minimum d’un module et d’une procédure qui appelle une méthode de FLC afin
d’accomplir une tâche. Si un programme contient une seule procédure, elle doit s’appeler
Main().
Exemple d’appels de procédure

'Ce module calcule et imprime la paie, ce pourrait se faire dans une classe
Module modPaiement
Sub Main()
'appel 4 fois de la procedure Paie
paie(40, 3500)
paie(38, 4250)

Page 37
paie(20, 3750)
paie(50, 4250)
End Sub
Sub paie(ByVal heures As Double, ByVal tauxhoraire As Decimal)
'calcul et affichage de la paie
Console.WriteLine("La paie est {0:C}", heures * tauxhoraire)
End Sub
End Module
Fig 53 : exemple d’appel de procédure
Le programme précédent contient deux procédures : Main et paie. Le Main est

toujours la première procédure à être exécutée dans tous les programmes application
console. Cette procédure appelle ensuite la procédure paie. Lorsque cette procédure est
appelée, elle est exécutée. Dans ce programme, la procédure paie, est appelé quatre
fois, donc elle est exécutée quatre fois. Cette procédure accepte deux arguments, copiés
(transmis) par valeur, «heures» de type double et «tauxhoraire» de type decimal. La
méthode «WriteLine» de la classe «Console» permet d’afficher le résultat. Voici le format
de la définition d’une procédure :
Forme générale d’une procédure

Sub nom-de-la-procédure (liste de paramètres)
déclaration et bloc de code
End Sub
où nom-de-la-procédure est le nom par lequel il faut appeler la procédure, et liste de

paramètres, est une liste de paramètres séparés par des virgules.
Remarque : La déclaration des variables dans la liste de paramètre ne commence pas

avec «Dim», mais bien avec le mot clé «ByVal». Cette déclaration indique que les valeurs
seront copiées dans les variables. Lors de l’appel de la procédure, les arguments n’ont
pas besoin d’avoir le même nom que les paramètres, mais ils doivent être du même
type. «End Sub» termine la procédure. On peut aussi utiliser les mots clé «Return» ou

Page 38
«Exit Sub» n’importe où dans la procédure, afin de redonner le contrôle où la procédure

a été appelée.
Cet exemple comme celui qui va suivre, montre une procédure dans une application
console. Ce serait écrit de la même façon dans une applications Windows, mais
généralement le code serait rattaché à la survenue d’un événement : La programmation
événementielle est l’habileté à répondre lorsque l’état d’un objet change dans une
interface graphique. (voir fig 6.4, page 190)
III.5. FONCTION « FUNCTION …»

Les fonctions sont similaires aux procédures mais il existe une différence. Une
fonction retourne une valeur.
Exemple d’appels de fonction

Module modCarre
Sub Main()
Dim i As Integer
Console.WriteLine("Nombre" & vbTab & "Carré" & vbCrLf)
For i = 1 To 10
Console.WriteLine(i & vbTab & carre(i))
Next
End Sub
'Function carre
Function carre(ByVal y As Integer) As Integer
Return y ^ 2
End Function
End Module
Remarque : la fonction retourne un entier, ceci par l’instruction «Return».
Fig 54 : exemple d’appel de fonction

Page 39
Forme générale d’une fonction

Fonction nom-de-la-fonction (liste de paramètre) As type-retourné
déclaration et bloc de code
End Fonction
Si la valeur retournée n’est pas du même type que celle définie dans la définition de la
fonction, Visual Basic essaye de la transformer. Si la valeur ne peut pas être convertie,
une erreur lors de l’exécution sera générée.
Les Méthodes
Une méthode est n’importe quelle procédure ou fonction inclue dans une
classe. On a toujours besoin de la classe lorsque nous utilisons une méthode. Par
exemple, le tableau ci-après présente les méthodes de la classe prédéfinie «Math»:
Méthodes Description Exemple
Abs(x) Retourne la valeur absolue de x. Abs(23.7) = 23.7
Abs(0) = 0
Abs(-23.7) = 23.7
Ceiling(x) Arrondie x à la prochaine valeur mais pas Ceiling(9.2) = 10.0

plus petit que x
Ceiling(-9.8) = -9.0
Cos(x) Calcule le cosinus de x Cos(0.0) = 1.0
Exp(x) Retourne l’exponentielle de ex Exp(1) = 2.71828…
Floor(x) Arrondie x à la valeur précédente mais Floor(9.2) = 9.0

pas plus grand que x
Floor(-9.8) = -10.0
Log(x) Retourne le logarithme de x (base e) Log(2.71828…) = 1.0
Max(x,y) Retourne la valeur la plus grande entre x Max(2.3,12.7) = 12.7

et y.
Max(-2.3, -12,7) = -2.3
Min(x,y) Retourne la valeur la plus petite entre x Min(2.3,12.7) = 2.3

et y.

Page 40
Min(-2.3, -12,7) = -12.7
Pow(x,y) Calcule x à la puissance y. Pow(2,7) = 128
Sin(x) Calcule le sinus de x Sin(0.0) = 0.0
Sqrt(x) Retourne la racine carrée de x. Sqrt(9.0) = 3
Tan(x) Retourne la tangente de x. Tan(0.0) = 0.0
Figure 55 : Les méthodes de la classe « math »
III.6. PROMOTION D’ARGUMENTS

Lorsqu’on utilise les arguments il faut de respecter la définition des procédures et
fonctions (prédéfinies ou écrites par le programmeur). C’est à dire, forcer l’argument à
être du bon type pour qu’il soit passé à la procédure. Visual Basic supporte la conversion
pour obtenir plus d’espace mémoire et au aussi de la conversion à moins d’espace
mémoire. La conversion de plus d’espace mémoire arrive lorsqu’un type de donné est
convertie à un autre type, généralement un type contenant plus de bits, sans perde la
donnée. La conversion à moins d’espace mémoire arrive lorsqu’une donnée a le potentiel
de perdre sa valeur durant sa conversion. Généralement, lorsque le type de la donnée
est plus petit que le type de l’argument, la conversion est supportée avec Visual Basic.
Voici la liste des conversions lorsqu’une donnée acquiert plus d’espace :
Type Conversion aux types
Boolean Object
Byte Short, Integer, Long, Decimal, Single, Double ou

Object
Char String ou Object
Date Object
Decimal Single, Double ou Object
Double Object
Integer Long, Decimal, Single, Double ou Object
Long Decimal, Single, Double ou Object
Object None

Page 41
Short Integer, Long, Decimal, Single, Double ou Object
Single Double ou Object
String Object
Figure 56 : Liste des conversions lorsqu’une donnée acquiert plus d’espace
Par exemple, la méthode Sqrt de la classe Math, peut être appelé avec un entier
comme argument, même si la définition de la méthode indique qu’il faut utiliser un
argument de type Double. Lorsque cette méthode est appelée avec l’argument 4 :
Console.Write(Math.Sqrt(4))
Cette ligne évalue la fonction et retourne 2. Visual Basic interprète l’integer 4

comme étant 4.0 de type Double. Dans ce cas, la valeur de l’argument ne correspond
pas au paramètre défini dans la méthode, implicitement Visual Basic change la valeur au
bon type et appelle la méthode. Le deuxième cas est la conversion à moins d’espace. Ici,
si l’argument est de type String, donc la valeur est “4”, la méthode Math.Sqrt(number)
évalue correctement la racine de 4 = 2. Cette conversion peut échouer, car elle peut
donner une erreur d’exécution ou une erreur de logique. Par exemple, Math.Sqrt(“Allo”)
causera une erreur d’exécution. Il existe quelques mesures pour le programmeur d’éviter
ces erreurs (voir ChapII, §2, - les clauses de déclaration Option).
Pour performer une conversion explicitement, le programmeur doit utiliser la

classe «Convert». Le nom de chaque méthode est le mot «To» suivie du nom du type
de donnée dans laquelle est performée la conversion. Par exemple, pour emmagasiner
une valeur du type String entrée par un utilisateur dans une variable number de type
Integer avec «Option Strict» active (ON), il faut utiliser :
number = Convert.ToInt32(Console.ReadLine()).
Avec «Option Strict» désactivée (OFF), Visual Basic performe la conversion

implicitement, dont le programmeur ne réalise pas tout le temps qu’une conversion a été
réalisée. Si une donnée ne peut être convertie et devient incompatible avec son nouveau
type, une erreur d’exécution arrivera.
III.7. PASSAGE D’ARGUMENT PAR VALEUR ET PASSAGE PAR REFERENCE

Pour comprendre les arguments passés par valeur et les arguments passés par
référence, il faut faire la distinction entre les types de données. Tous les types de
données avec Visual Basic peuvent être classés comme type de valeur ou comme type
de référence. Une variable avec un type valeur contient une donnée de ce type.

Page 42
Normalement, les types valeur, sont utilisés pour une « pièce » de donnée, comme
Integer ou Double. Une variable de type référence, contient une location dans sa
mémoire ou est emmagasiné la donnée. La location dans la mémoire contient plusieurs
« pièces » de données. Les types référence sont connus comme étant un objet.
Les types valeur et les types référence contiennent des types déjà construits et
des types que le programmeur peut construire. Les types valeur déjà construits
contiennent les types intégraux (Byte, Short, Integer et Long), les types réels
(Single et Double) et les types Boolean, Date, Decimal et Char. Les types référence
déjà construits contiennent Object et String. Les types valeur qui peuvent être
construits par le programmeur contiennent les Structures et les Enumérations. Les
types référence qui peuvent être construits par le programmeur sont les classes, les
interfaces et les délégués. (voir fig 21 : les types de données)
Les arguments peuvent être passés de deux façons : par valeur ou par référence.
Quand un argument est passé par valeur, le programme fait une copie de la valeur de
l’argument et passe à la procédure cette copie. Si la procédure change la valeur de cette
copie, elle n’affecte pas du tout la valeur originale. Quand un argument est passé par
référence, le programme donne accès à la procédure de changer la valeur originale
directement. Lorsque que nous voulons passer un argument par valeur, il faut utiliser le
mot clé ByVal. Lorsque que nous voulons passer un argument par référence, il faut
utiliser le mot clé ByRef.
III.8. RÈGLES D’ACCÈS ET VISIBILITE (SCOPE) D’UNE VARIABLE

La règle d’accès (accessibilité) d’une variable est la portion du programme dans
laquelle un identificateur peut-être accédé. Les accès possibles sont : «class scope»,
«module scope», «namespace scope» et «block scope».
Les membres d’une classe ont un accès au niveau de la classe (class

scope). Une classe débute avec le mot clé Class et termine avec End Class. À
l’intérieur de cette classe, toutes les méthodes et membres de cette classe peuvent être
accédés. Les membres d’une classe sont globaux aux méthodes de la classe dans laquelle
ils ont été définis. En d’autres mots, les méthodes peuvent modifier l’instance des
variables directement et appeler d’autres méthodes de la classe (variable déclarée dans
la classe mais en dehors des méthodes). Si une variable locale a le même identificateur
qu’une variable globale, la variable globale devient «cachée», et elle est seulement
accessible lorsque la procédure termine.
Les variables déclarés à l’intérieur d’un bloc, comme dans une procédure
ou dans une structure IF/Then, ont un accès bloc (block scope). Ce genre d’accès
débute à la déclaration de l’identificateur et termine à la fin du bloc (End ou Next). Les
variables locales d’une procédure ont un accès bloc. Les paramètres d’une procédure ont

Page 43
aussi un accès bloc, parce qu’ils sont considérés comme des variables locales de la
procédure.
Les variables déclarées dans un module ont un accès module (module

scope). Ce type d’accès est similaire à l’accès au niveau d’une classe. Les variables
déclarés dans un module sont accessibles à toutes les procédures définies dans le
module. Même règle qu’une classe lorsqu’une variable locale a le même nom qu’une
variable globale.
Par défaut, une procédure définie dans un module a un accès

«namespace» (namespace scope). Ce type d’accès est au niveau du projet. Ce genre
d’accès est utile lorsqu’un projet contient plusieurs morceaux (modules et classes). Si un
projet contient un module et une classe, les méthodes dans la classe peuvent accéder
aux procédures du module.
Les variables déclarées dans un module ont un accès au niveau module,

elles peuvent avoir un accès «namespace» en remplaçant le Dim par Public
dans la déclaration.
III.9. GÉNÉRATION DE NOMBRE ALÉATOIRE

Pour pouvoir générer des nombres aléatoires, il faut utiliser la classe Random qui
fait partie du «namespace» System. Pour déclarer une variable de type Random, il faut
utiliser la syntaxe suivante :
Dim objetAléatoire As Random = New Random()
Cette déclaration créée une variable, objetAléatoire, de type Random. Le mot clé
New permet la création d’une instance de la classe Random (Objet Random).
Pour créer un nombre entier aléatoire :
Dim nombreAléatoire As Integer = objetAléatoire.Next()
La méthode objetAléatoire.Next() génère un nombre entier positif entre 0 et la

constante Int32.Maxvalue (2,147,483,647). Si Next génère un nombre aléatoire, chaque
valeur dans la plage a un nombre égal de chance d’être choisi. Si on veut un nombre
aléatoire entre 1 et 6, il faut ajouter 1 à objetAléatoire.Next() et indiquer l’échelle de
graduation dans la méthode. Donc, valeur = 1 + objetAléatoire.Next(6), génère un
nombre entier aléatoire entre 1 et 6. Valeur sera toujours :
x  x + objetAléatoire.Next(y) < x+y
La méthode Next accepte aussi deux arguments. Le premier argument représente

la valeur minimum et le deuxième argument représente valeur maximum +1. Donc,

Page 44
l’énoncé, valeur = objetAléatoire.Next(1,7), donnera un nombre aléatoire entre 1 et 6.

L’échelle de graduation est y-x.
x  objetAléatoire.Next(x,y) < y
Le programme 6.15 de la page 209, affiche l’image du dé correspondant au

numéro aléatoire. Pour afficher le fichier image, on utilise la propriété image de label en
combinant la méthode Image.FromFile. Par exemple, pour assigner un fichier image à un
label nommé lbldé :
lbldé.Image = Image.FromFile(“de1.jpg”)
La méthode Image.FromFile, télécharge le fichier de1.jpg et l’assigne à la

propriété Image de label. Une autre méthode, Directory.GetCurrentDirectory, retourne la
location du projet courant (nom_projet/bin ou se retrouve l’exécutable). Cette classe se
retrouve dans le «namespace» System.IO. En combinant Image.FromFile et
Directory.GetCurrentDirectory, on va chercher les fichiers dans le dossier.
III.10. SURCHARGEMENT (OVERLOADING) DES PROCÉDURES ET ARGUMENTS

OPTIONNELS
Le surchargement, «Overloading», permet aux programmeurs de créer plusieurs

procédures avec le même nom mais avec une définition différente. Le nombre de
paramètres et le type de données sont différents. Cette technique donne une meilleure
flexibilité et réduit la complexité du programme. Les procédures peuvent aussi recevoir
des arguments optionnels. Un argument optionnel permet à la procédure appelée de
décider quels arguments passés. Ces arguments ont une valeur par défaut si aucun
argument n’est passé. Le surchargement est plus flexible que les arguments optionnels
car le programmeur peut spécifier le type de la valeur retournée. Quant aux arguments
optionnels, on peut spécifier seulement les valeurs par défaut.
Surchargement des procédures

Avec le surchargement, le programmeur peut définir plusieurs procédures avec le
même nom, tant et autant que ces procédures ont des définitions différentes (nombre de
paramètres et types de paramètres ou ordre des paramètres). Lorsqu’une procédure
surchargée est appelée, le compilateur sélectionne la procédure adéquate en examinant
le nombre, le type et l’ordre des arguments. Une procédure surchargée est utilisée afin
de créer plusieurs procédures avec le même nom, qui performe des tâches similaires sur
des données de types différents.
Arguments optionnels
Un paramètre peut être déclaré comme étant optionnel. Le programmeur aura le
choix de passer un argument ou pas lorsqu’il appelle cette procédure. Les arguments

Page 45
optionnels, sont déclarés avec le mot clé «Optional» dans la définition des procédures.
Voici un exemple :
Sub ExempleProcedure (ByVal valeur1 As Boolean, Optional _
ByVal valeur2 As Long = 0)
Le dernier paramètre est optionnel. Lorsque ExempleProcedure est appelé, il doit

y avoir un minimum d’un argument, sinon une erreur de syntaxe sera générée. Un
deuxième argument peut-être ajouté mais il n’est pas obligatoire. Donc, la procédure
peut-être appelée de deux façons : ExampleProcédure (True) ou ExampleProcédure
(True, 10).
Dans la première situation, il n’y a aucune valeur pour le deuxième paramètre, donc par
défaut il sera 0.
Modules
Les programmeurs utilisent les modules afin de regrouper les procédures. Ces modules
peuvent être réutilisés dans un autre projet. Pour utiliser les modules il faut avoir une
bonne connaissance des règles d’accès. En générale, les modules doivent être auto
contenu, ce qui veut dire que les procédures dans un module ne doivent pas accéder les
variables et les procédures en dehors du module, excepté les valeurs passées comme
arguments. Pour ajouter un module, il suffit de sélectionner Project>Add Module.

Page 46
IV. LES TABLEAUX
IV.1. TABLEAUX À UNE DIMENSION

Un tableau est une structure qui occupe de l’espace mémoire. L’espace mémoire
utilisé dépend de la longueur du tableau et du type de donnée qui y est emmagasiné. La
déclaration d’un tableau crée une variable qui peut emmagasiner une référence à un
tableau mais ne crée pas un tableau dans la mémoire. Pour déclarer un tableau, le
programmeur doit donner un nom et un type de donnée. La déclaration et l’initialisation
d’un tableau respectent différentes syntaxes, mais il faut d’abord comprendre le
fondamental :
Dim T As Integer () ‘ ou Dim T() As Integer
Les parenthèses indiquent au compilateur que la variable est un tableau. Le nom du

tableau est T. Avant d’utiliser un tableau, le programmeur doit spécifier sa taille et lui
allouer de la mémoire en utilisant New(). La valeur emmagasinée dans le tableau est la
référence à la location dans la mémoire de l’ordinateur où l’objet tableau sera créé. Pour
allouer de la mémoire au tableau, il faut utiliser la syntaxe suivante :
T = New Integer (11) {}
Dans notre exemple, le chiffre 11 indique la borne supérieure du tableau. La

borne inférieure est 0. Donc, on peut accéder aux éléments du tableau de 0 à 11. Ces
chiffres représentent l’index du tableau. La taille du tableau est la borne supérieure + 1.
Dans notre situation le tableau à une taille de 12, c’est-à-dire qu’il peut contenir 12
éléments. Les accolades sont utilisées pour d’assigner des valeurs lors de l’initialisation.
Dim T() As Integer = New Integer() {1, 2, 3}
Cette déclaration crée une variable nommée numbers initialisée avec les chiffres 1, 2 et
3. Visual Basic peut déterminer la grosseur du tableau lorsque nous lui assignons une
liste. On peut déclarer et initialiser le tableau avec une commande : Dim T() As
Integer = New Integer(11) {}
On peut simplement déclarer un tableau en spécifiant la taille allouée en

mémoire sans la clause new, on ne donne donc pas des valeurs initiales :
Dim T1(), T2() As Integer Dim T(5) as integer ou Dim T1(5), T2(4) as
integer
En résumé, on peut :

Page 47
1. Spécifier la longueur initiale du tableau dans les parenthèses qui suivent le

nom du tableau, ne donc pas assigner un objet new (si oui dans une autre
instruction)
Ex: Dim T() as integer ou Dim T(5) as integer
2. Assigner un objet tableau avec new en précisant le type suivi des parentheses
et des accolades (les parentheses et les accolades peuvent être vides)
Ex. Dim T() As Integer = New Integer() {}
comprenant la taille et des accolades vides
Ex: Dim T() As Integer = New Integer(2) {}
vides et des accolades comprenant les valeurs initiales
Ex : Dim T() As Integer = New Integer() {1, 2, 3}
5. Faire les 3 et 4 à la fois Ex : Dim T() As Integer = New Integer(2) {1, 2, 3}
Plusieurs méthodes existent avec l’objet tableau. Voici les plus communes :
Méthode Définition
T.Length Retourne le nombre d’index ou d’éléments
T.GetUpperBound(0) Retourne la borne supérieur index max)

Page 48
IV.2. PASSER UN TABLEAU A UNE PROCEDURE

On peut passer deux types d’information : Le tableau au complet ou La valeur
à un index
Pour passer un tableau comme un argument à une procédure, il faut spécifier le nom du
tableau sans utiliser les parenthèses. Par exemple, pour passer un tableau T qui a été
déclaré comme suit : Dim T As Integer() = New Integer() {50,100,150}
l’appel de la procédure sera : proc(T). Cette commande passe le tableau T à la procédure

proc.
Mais il faut faire attention, car lorsque nous passons un objet, comme le
tableau, c’est l’adresse de l’objet qui est passée, non une copie. Les définitions
des deux procédures suivantes on le même effet sur le tableau Tab :
Sub proc(ByVal tab As Integer ( )) et Sub proc(ByRef tab As Integer ( ))
On peut aussi passer à une procédure la valeur d’un index. Par exemple, T(2) qui
contient la valeur 150 : proc(T(2))
Cette commande passe la valeur 150 venant de l’index 2 du tableau T.
Lorsque nous passons la valeur d’un index et que la définition de la procédure

utilise ByVal, nous recevons une copie de la valeur. Donc, la valeur originale de l’index ne
sera pas changée. Par contre, si on utilise ByRef, c’est l’adresse mémoire qui est passé
donc la valeur originale de l’index changera.
N.B. :
1. La classe array du namespace system permet certains traitements sur un

tableau. Array.sort(Tab) tri le tableau dans l’ordre croissant.
Array.reverse(Tab) inverse l’ordre des éléments dans un tableau
2. Les données d’un tableau sont en principe du même type. Mais le type object
permet d’emmagasiner les données numériques, string, etc.
3. Après la déclaration (et même l’initialisation d’un tableau), il est possible
d’allouer de l’espace : redim Tab(n) attribue de l’espace pour n (+1)
éléments. Mais ceci est susceptible d’écraser les éléments déjà existants dans
le tableau. Pour les conserver, on ferait : redim preserve Tab(n)
4. Parcours du tableau avec for … et for each ...
For i=0 to For each elt in T
T.getUpperBound(0) Console.writeline(elt)
Console.writeline(T(i)) Next
Next i

Page 49
IV.4. LONGUEUR VARIABLE DE LA LISTE DE PARAMÈTRES

Il est possible de créer des procédures qui reçoivent un nombre variable d’arguments en
utilisant le mot clé «ParamArray» avec la syntaxe suivante :
Sub proc(ByVal ParamArray T As Integer())
La procédure proc peut être appelée avec un nombre différent d’arguments. Voici
un exemple :
proc() ou proc(2, 3) ou proc(7, 8, 9, 10)
Devoir : rechercher l’utilisation de paramarray

Page 50

Programmation Evenementielle Et IHM 1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programmation Evenementielle Et IHM 1

Transféré par

Droits d'auteur :

Formats disponibles

Support de cours de Programmation Evénementielle et IHM 1

La connaissance ne signifie pas

Elle est une combinaison de trois

1) Le savoir savant : Je sais que

2) Le savoir faire : je sais

3) Le savoir être : Je sais

PROGRAMMATION EVENEMENTIELLE ET IHM 1

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Notions de base en programmation événementielle 2

A la fin de ce module l’étudiant sera capable de :

Profil : Brevet de Technicien Supérieur

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

TABLE DES MATIERES

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Structure de contrôle «For each… Next» ...................................................................................... 36

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

VII.5. Événements de la souris .......................................................................................................... 25

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Chapitre 1 : NOTIONS GENERALES SUR L’IDE VISUAL STUDIO .NET

Avantages de l’IDE Visual Studio .NET

 Développement visuel design de formulaire avec la technologie glisser-déposer

I.2. L’ENVIRONNEMENT VISUAL STUDIO .NET

Fig 15 : écran d’accueil de VS 2008: l’on peut ouvrir un projet existant ou en

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

L’écran d’un projet en développement

Fenêtre qui contient tous les

Onglets Objet projet :

Fig 18 : fenêtre du projet « test03 » en développement

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

II.5. OPERATEURS ARITHMETIQUES

Opér Opération Ordre d’évaluation Expression dans VB

() Parenthèse Les parenthèses sont évaluées en a - (b (c + d) )

^ Exposant Évalué en deuxième. S’il existe 10^3 = 103

*,/ Multiplication Évalué en quatrième, si plusieurs, 4 * 5 =20

\ Division Évalué en cinquième position. Si 10 \ 2 = 5

Mod Modulo Sixième évalué, si plusieurs, évalué 10 Mod 7 = 3

+,- Addition Dernière opération évalué, si 10 + 5 =15

Fig 30 : Tableau des opérateurs arithmétiques

II.6. OPERATEURS RELATIONNELS ET LOGIQUES

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Opérateur Opérateur dans VB Exemple d’une Interprétation de l’opération

= = x=y x est égal à y

 <> x <> y x est pas égal à y

> > x>y x est plus grand que y

< < x<y x est plus petit que y

 >= x >= y x est plus grand ou égal à y

 <= x <= y x est plus petit ou égal à y

Fig 31 : Tableau des opérateurs relationnels

II.7. LES TYPES DE DONNÉES

Type Taille en bits Plage de valeurs

Boolean 16 True ou False

Char 16 Un caractère Unicode

Date 64 1 Janvier 0001 à décembre 9999

0 :00 :00 à 23 :59 :59

Decimal 128 1.0E-28 à 7.9E+28

Short 16 -32,768 à 32,767

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Integer 32 -2,147,483,648 à 2,147,483,647

Single 32  1.5E-45 à  3.4E+38

String Nombre de caractères 0 à ~2000000000

II.8. LES NOMS DE VARIABLES

II.9. LA DÉCLARATION DE VARIABLES

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

,/ Multiplication Évalué en quatrième, si plusieurs, 4 5 =20