2025

Visual Basic

JIMMY FRANCICE MENAVOARA

IFT |Toamasina Madagascar

I. Les principaux concepts de Visual Basic ........................................................................... 4
I.1 Présentation générale .................................................................................................. 4
I.2 Le modèle événementiel ............................................................................................. 4
I.3 La notion d’objet ........................................................................................................ 5
I.4 Les notions de méthode et de propriété ...................................................................... 5
II. La syntaxe de Visual Basic ................................................................................................ 5
II.1 Les types de données .................................................................................................. 6
II.1.1 Les types prédéfinis ............................................................................................ 6
II.1.2 Les tableaux ...................................................................................................... 11
II.1.3 Les types définis par le programmeur .............................................................. 12
II.2 Les instructions ........................................................................................................ 13
II.2.1 La déclaration ................................................................................................... 13
II.2.2 L’affectation ..................................................................................................... 13
II.2.3 Les instructions exécutables ............................................................................. 13
II.2.4 Vérification des erreurs de syntaxe .................................................................. 15
II.2.5 Les instructions sur plusieurs lignes................................................................. 15
II.3 Les modules.............................................................................................................. 16
II.3.1 Ecriture d’une procédure .................................................................................. 16
II.3.2 Ecriture d’une fonction ..................................................................................... 16
II.3.3 Appel des modules ........................................................................................... 17
III. Exploration de la Boîte à Outils de Visual Basic ......................................................... 18
III.1 Présentation de la Boîte à Outils .............................................................................. 18
III.2 Catégories Principales de la Boîte à Outils .............................................................. 18
III.2.1 Contrôles Windows Forms ............................................................................... 18
III.2.2 Conteneurs ........................................................................................................ 19
III.2.3 Menus et Barres d’outils .................................................................................. 19
III.2.4 Composants de Gestion des Données ............................................................... 19
III.2.5 Contrôles de Dialogue ...................................................................................... 20
III.2.6 Composants de Gestion du Système ................................................................ 20
III.3 Manipulation des Contrôles de la Boîte à Outils ...................................................... 20
III.3.1 Ajout d’un Contrôle sur un Formulaire ............................................................ 20
III.3.2 Modification des Propriétés des Contrôles....................................................... 20
III.3.3 Gestion des Événements ................................................................................... 20
III.4 Personnalisation Avancée des Contrôles .................................................................. 21
III.4.1 Création Dynamique de Contrôles ................................................................... 21
III.4.2 Utilisation des Contrôles Personnalisés ........................................................... 21
I. Les principaux concepts de Visual Basic
I.1 Présentation générale
Visual Basic est un langage de programmation « orienté objet » de Microsoft qui permet
de programmer des applications indépendantes sous l’environnement Windows. Il est intégré
dans tous les logiciels de Bureautique de MicroSoft (Word, Excel, Access) sous le nom de :
VBA (Visual Basic Application). Visual Basic est un langage interprété. Pour comprendre le
processus de développement d’une application, il est utile d’assimiler certains concepts sur
lesquels est fondé Visual Basic. Comme il s’agit d’un langage de développement Windows, il
convient également de s’être familiarisé avec l’environnement Windows. Le fonctionnement
de Windows s’articule autour de trois concepts essentiels.

• Les fenêtres ;
• Les événements ;
• Les messages.

Considérons qu’une fenêtre est une zone rectangulaire dotée de ses propres limites. Nous
connaissons tous une fenêtre de document dans un programme de traitement de texte ou une
fenêtre de boite de dialogue quelconque. S’il s’agit là des exemples les plus courants, il existe
bien d’autres types de fenêtres. Un bouton de commande, les icônes, les zones de texte, les
boutons d’options, les barres de menus constituent tous des fenêtres. Windows gère ces
nombreuses fenêtres en affectant à chacune d’elles un numéro d’identification unique (« hWnd
»). Le système surveille en permanence chacune de ces fenêtres de façon à déceler le moindre
événement. Les événements peuvent être engendrés par des actions de l’utilisateur, par un
contrôle programmé, voire par des actions d’une autre fenêtre. Chaque fois qu’un événement
survient, un message est envoyé au système d’exploitation, qui traite le message et le diffuse
aux fenêtres concernées. La plupart de ces messages de bas niveau sont gérés par Visual Basic
tandis que d’autres sont mis à votre disposition sous forme de procédures événementiels.

I.2 Le modèle événementiel

Dans les applications traditionnelles, dites « procédurales », les instructions commencent
à la première ligne de code et se déroulent suivant un chemin défini dans l’application, appelant
les procédures au fur et à mesure des besoins. Dans une application « événementielle », le code
ne suit pas un chemin prédéterminé. Différentes sections du code sont exécutées en fonction
des événements qui se produisent. Vous ne pouvez prévoir l’ordre des événements, en revanche
 vous devez prévoir les événements qui peuvent se produire et votre code doit être en mesure de
les traiter.

I.3 La notion d’objet

Un objet représente un élément d'une application. Une feuille de calcul, une cellule, un
graphique pour Excel, un formulaire, une table ou un état pour Access sont des objets. Dans un
code Visual Basic, vous devez identifier un objet avant de pouvoir appliquer l'une des méthodes
de l'objet ou modifier la valeur de l'une de ses propriétés. Une collection est un objet contenant
plusieurs autres objets, généralement, mais pas toujours, du même type. Dans Microsoft Excel,
par exemple, l'objet Workbooks contient tous les objets Workbook. Dans Visual Basic, la
collection Forms contient tous les objets Form d'une application. Les éléments d'une collection
peuvent être identifiés par numéro ou par nom. Vous pouvez également manipuler toute une
collection d'objets si les objets partagent des méthodes communes.

I.4 Les notions de méthode et de propriété

Une méthode est une action qu'un objet peut exécuter. Par exemple, Add est une méthode
de l'objet ComboBox qui ajoute une nouvelle entrée à une liste modifiable. Une propriété est
un attribut d'un objet définissant l'une des caractéristiques de l'objet telle que la taille, la couleur
ou la position à l'écran, ou un aspect de son comportement, par exemple s'il est activé ou visible.
Pour changer les caractéristiques d'un objet il faut changer les valeurs de ses propriétés. Pour
définir la valeur d'une propriété, faites suivre la référence d'un objet d'un point, du nom de la
propriété, d'un signe égal (=) et de la nouvelle valeur de propriété. Certaines propriétés ne
peuvent pas être définies. La rubrique d'aide de chaque propriété indique si vous pouvez la
définir (lecture-écriture), seulement la lire (lecture seule) ou seulement y écrire (écriture seule).
Vous pouvez extraire des informations sur un objet en renvoyant la valeur de l'une de ses
propriétés.

II. La syntaxe de Visual Basic

Un programme écrit en Visual Basic est un ensemble de fichiers textes documentés
(appelés sources) respectant une syntaxe précise. Les commentaires sont des caractères, de
préférence non accentués, ignorés par l’interpréteur et ne servant qu'à documenter le
programme. Les lignes de commentaires débutent par une apostrophe (') ou par le mot Rem
suivi d'un espace et peuvent être insérées n'importe où dans une procédure Les commentaires
peuvent expliquer une procédure ou une instruction particulière au lecteur de votre code. Par
défaut, les commentaires s'affichent en vert.

Règles d’affectation des noms :

Utilisez les règles suivantes pour nommer des procédures, des constantes, des variables
et des arguments dans un module Visual Basic :

➢ Utilisez une lettre comme premier caractère ;

➢ N'utilisez pas d'espace, de point (.), de point d'exclamation (!) ou les caractères @, &,
$, # dans le nom ;
➢ Un nom ne peut compter plus de 255 caractères ;
➢ Généralement, vous ne devriez pas utiliser des noms identiques aux noms de fonction,
d'instruction et de méthode de Visual Basic. Vous feriez double emploi des mots clés du
langage. Pour utiliser une fonction, une instruction ou une méthode du langage
intrinsèque en conflit avec un nom attribué, vous devez l'identifier explicitement. Faites
précéder la fonction, l'instruction ou la méthode intrinsèque du nom de la bibliothèque
de types associée. Par exemple, si vous avez une variable nommée Left, pour invoquer
la fonction Left, vous devez employer [Link] ;
➢ Vous ne pouvez pas employer deux fois le même nom au même niveau de portée. Par
exemple, vous ne pouvez pas déclarer deux variables nommées age dans la même
procédure. Cependant, vous pouvez déclarer une variable privée nommée age et une
variable de niveau procédure nommée age dans le même module.

Note : Visual Basic ne différencie pas les majuscules des minuscules, mais conserve la casse
dans l'instruction de déclaration du nom.

II.1 Les types de données

II.1.1 Les types prédéfinis
Boolean
Les variables de type « Boolean » sont stockées sous la forme de nombres de 16 bits (2
octets), mais elles ne peuvent avoir pour valeur que True ou False. Elles s'affichent sous la
forme True et False (avec l'instruction Print) ou #TRUE# et #FALSE# (avec l'instruction Write
#). Utilisez les mots clés True et False pour faire passer d'un état à l'autre des variables de type
« Boolean ». Lorsque d'autres types de données numériques sont convertis en valeurs de type
Boolean, 0 devient False et toutes les autres valeurs deviennent True. Lorsque des valeurs de
type Boolean sont converties en d'autres types de données, False devient 0 et True devient -1.
Byte
Les variables de type « Byte » sont stockées sous la forme d'un nombre de 8 bits (1 octet
unique), non signé, compris entre 0 et 255. Le type de données « Byte » est utile pour le stockage
d’entiers de petite taille.

Currency
Les variables de type « Currency » sont stockées sous la forme de nombres de 64 bits (8
octets) au format entier, avec un décalage de 10 000 afin d'obtenir un nombre à virgule fixe
comprenant 15 chiffres à gauche du séparateur décimal et 4 chiffres à droite. Cette
représentation offre une plage comprise entre -922 337 203 685 477,5808 et 922 337 203 685
477,5807. Le caractère de déclaration de type pour les variables de type « Currency » est le
signe @. Le type de données « Currency » est utile pour les calculs monétaires et pour les
calculs à virgule fixe dans lesquels la précision revêt une importance particulière.

Date

Les variables de type « Date » sont stockées sous la forme de nombres à virgule flottante
de 64 bits (8 octets) IEEE représentant des dates comprises entre le 1er janvier 100 et le 31
décembre 9999, et des heures allant de [Link] à [Link]. Toute valeur de littéral de date peut
être attribuée à une variable de type « Date ». Les littéraux date doivent être délimités par le
signe #, par exemple #January 1, 1993# ou #1 Jan 93#. Les variables de type « Date » affichent
les dates au format de date abrégé reconnu par votre ordinateur. Les heures s'affichent au format
horaire (plage de 12 ou 24 heures) défini dans votre ordinateur. Lorsque d'autres types de
données numériques sont convertis en données de type « Date », les valeurs situées à gauche
du séparateur décimal représentent la date, tandis que celles situées à droite correspondent à
l'heure. Minuit est représenté par 0 et midi par 0,5. Les nombres entiers négatifs représentent
des dates antérieures au 30 décembre 1899.

Decimal

Les variables de type « Decimal » sont stockées sous la forme d'entiers de 96 bits (12
octets), non signés, décalés d'une puissance de 10 variable. Le facteur de décalage (puissance
de 10), qui définit le nombre de chiffres situés à droite du séparateur décimal, est compris entre
0 et 28. Avec un décalage de 0 (pas de décimales), la valeur maximale est +/ 79 228 162 514
264 337 593 543 950 335. Avec 28 décimales, la valeur maximale est +/
7,9228162514264337593543950335 et la valeur minimale différente de zéro est +/
0,0000000000000000000000000001. Pour le moment, le type de données « Decimal » ne peut
être utilisé qu'avec une donnée de type « Variant ». En d'autres termes, il est impossible
d'attribuer à une variable le type « Decimal ». Vous pouvez en revanche créer une variable de
type « Variant » dont le sous-type est « Decimal » à l'aide de la fonction CDec.

Double

Les variables de type « Double » (à virgule flottante en double précision) sont stockées
sous la forme de nombres à virgule flottante de 64 bits (8 octets) IEEE dont la valeur est
comprise entre -1,79769313486232E308 et -4,94065645841247E-324 pour les nombres
négatifs et entre 4,94065645841247E-324 et 1,79769313486232E308 pour les positifs. Le
caractère de déclaration de type pour une variable de type « Double » est le signe #.

Integer

Les variables de type « Integer » sont stockées sous la forme de nombres de 16 bits (2
octets) dont la valeur est comprise entre -32 768 et 32 767. Le caractère de déclaration de type
pour les variables de type « Integer » est le signe %. Les variables de type « Integer » permettent
également de représenter des valeurs énumérées. Celles-ci peuvent contenir un ensemble fini
d'entiers uniques possédant tous une signification particulière dans le contexte où ils sont
utilisés. Elles permettent d'opérer facilement une sélection parmi un nombre connu de choix,
du type noir = 0, blanc = 1, etc. Il est conseillé de définir des constantes pour chaque valeur
énumérée via l'instruction Const.

Long

Les variables de type « Long » (entier long) sont stockées sous la forme de nombres
signés de 32 bits (4 octets) dont la valeur est comprise entre -2 147 483 648 et 2 147 483 647.
Le caractère de déclaration de type pour les variables de type « Long » est le signe &.

Object

Les variables de type « Object » sont stockées sous la forme d'adresses 32 bits (4 octets)
qui font référence à des objets. L'instruction Set permet d'affecter une référence d'objet à une
variable déclarée comme « Object ». Une variable déclarée comme « Object » est suffisamment
flexible pour contenir une référence à n'importe quel type d'objet, mais la liaison à l'objet
désigné par la variable est effectuée au moment de l'exécution. Pour obtenir une liaison au
moment de la compilation, attribuez la référence d'objet à une variable déclarée avec un nom
de classe spécifique.
 Single

Les variables de type « Single » (à virgule flottante en simple précision) sont stockées
sous la forme de nombres à virgule flottante de 32 bits (4 octets) IEEE dont la valeur est
comprise entre -3,402823E38 et -1,401298E-45 pour les nombres négatifs et entre 1,401298E-
45 et 3,402823E38 pour les positifs. Le caractère de déclaration de type pour les variables de
type « Single » est le point d'exclamation (!).

String

Il existe deux types de chaînes : les chaînes de longueur variable et les chaînes de longueur
fixe. Les chaînes de longueur variable peuvent contenir environ 2 milliards (2^31) de caractères.
Les chaînes de longueur fixe peuvent contenir de 1 à environ 64 Ko (2^16) de caractères. Une
chaîne de longueur fixe déclarée comme Public ne peut être utilisée dans les modules de classe.
Les codes de caractères de type « String » sont compris entre 0 et 255. Les 128 premiers
caractères (0 à 127) du jeu de caractères correspondent aux lettres et symboles d'un clavier
américain standard. Ces 128 caractères sont identiques à ceux du jeu de caractères ASCII. Les
128 caractères suivants (128 à 255) représentent des caractères spéciaux, comme les lettres de
certains alphabets, les accents, les symboles monétaires et les fractions. Le caractère de
déclaration de type pour les variables de type String est le signe $.

Variant « Variant » est le type de données attribué à toutes les variables qui ne sont pas
explicitement déclarées comme étant d'un autre type (à l'aide d'instructions telles que Dim,
Private, Public ou Static). Le type de données « Variant » ne possède aucun caractère de
déclaration de type. Variant est un type de données spécial pouvant contenir des données de
toutes sortes, à l'exception des données de type « String » de longueur fixe et de types définis
par l'utilisateur. Une variable de type « Variant » peut également contenir les valeurs Empty,
Error, Nothing et Null. Vous pouvez déterminer la procédure de traitement d'une donnée de
type « Variant » à l'aide des fonctions VarType et TypeName. Les données numériques
correspondent à n'importe quel nombre entier ou réel dont la valeur est comprise entre -
1,797693134862315E308 et -4,94066E-324 pour les négatifs et entre 4,94066E 324 et
1,797693134862315E308 pour les positifs. En général, les données numériques de type «
Variant » conservent leur type de données original au sein de la valeur de type « Variant ». Par
exemple, si vous attribuez une valeur de type « Integer » à une donnée de type « Variant », cette
dernière sera ultérieurement traitée comme une valeur de type « Integer ». Cependant, si une
opération arithmétique est exécutée sur une donnée de type « Variant » contenant une valeur
detype « Byte », « Integer », « Long » ou « Single » et si le résultat excède la plage de valeurs
du type de données, le résultat se voit automatiquement affecté le type de données « Variant »
immédiatement supérieur. Une donnée de type « Byte » est transformée en « Integer », une
donnée de type « Integer » est transformée en « Long » et une donnée de type « Long » ou «
Single » en « Double ». Une erreur se produit lorsque des variables de type « Variant » contenant
des données de type « Currency », « Decimal » ou « Double » dépassent leur plage de valeurs
respective. Le type de données « Variant » peut remplacer un autre type de données lorsque
vous recherchez plus de souplesse dans le traitement de celles-ci. Si une variable de type «
Variant » contient des chiffres, il peut s'agir, selon le contexte, de leur valeur réelle ou de leur
représentation sous forme de chaîne. Exemple :

Dans l'exemple précédent, MyVar contient une représentation numérique, c'est-à-dire la

valeur réelle 98052. Les opérateurs arithmétiques peuvent être utilisés avec des variables de
type « Variant » contenant des valeurs numériques ou des chaînes de caractères pouvant être
interprétées comme des nombres. Si vous utilisez l'opérateur + pour ajouter MyVar à une autre
donnée de type « Variant » contenant un nombre ou à une variable de type numérique, vous
obtiendrez comme résultat une somme arithmétique. La valeur Empty désigne une variable de
type « Variant » qui n'a pas été initialisée. Une variable de type « Variant » contenant la valeur
Empty équivaut à 0 si elle est utilisée dans un contexte numérique et à une chaîne de longueur
nulle ("") dans un contexte de chaînes. Ne confondez pas Empty et Null. La valeur Null indique
que la variable de type « Variant » ne contient intentionnellement aucune donnée valide. Dans
une donnée de type « Variant », la valeur Error permet d'indiquer qu'une condition d'erreur s'est
produite dans une procédure. Cependant, aucune gestion d'erreur normale de niveau application
n'a lieu dans ce cas. Le programmeur ou l'application peuvent donc appliquer un certain
traitement en fonction de la valeur d'erreur. Les valeurs de type Error sont créées par conversion
de nombres réels à l'aide de la fonction CVErr.

II.1.2 Les tableaux

Savoir manipuler des données isolées est intéressant mais il est parfois nécessaire de gérer
des longues listes d’informations. Les tableaux sont de simples listes d’un seul type de données
(un tableau d’entiers, un tableau de nombres à virgule flottante …). Visual Basic permet de
créer des tableaux de longueur fixe appelés tableaux statiques et des tableaux de longueur
variable appelés tableaux dynamiques.
 Les tableaux statiques Il s’agit d’un tableau dont le nombre maximum d’éléments est fixé
a priori. La déclaration se fait de la manière suivante (pour un tableau « public » de 11 éléments
de type « Integer ») :

Les tableaux dynamiques Par opposition aux tableaux statiques, les tableaux dynamiques
n’ont pas de taille fixe. Il est possible de les « agrandir » ou de les « réduire » en intervenant
sur le code et d’utiliser certaines instructions de Visual Basic pour obtenir des informations les
concernant (leur taille, bornes inférieure et supérieure …). Les tableaux dynamiques doivent
être déclarés « privés » dans la feuille, le module ou le module de classe où ils sont utilisés. Il
ne faut pas spécifier la taille du tableau à la déclaration. Pour définir la taille du tableau il faut
utiliser la fonction ReDim. Un tableau dynamique se déclare comme suit :

La taille est définie a posteriori :

II.1.3 Les types définis par le programmeur

Ces types de données sont définis à l'aide de l'instruction Type. Les types de données
définis par l'utilisateur peuvent contenir un ou plusieurs éléments d'un type de données, un
tableau ou un type de données précédemment défini par l'utilisateur. Exemple :
II.2 Les instructions
Les instructions Visual Basic sont complètes. Elles contiennent des mots clés, des
opérateurs, des variables, des constantes et des expressions. Chaque instruction appartient à
l'une des trois catégories suivantes : déclaration, affectation, exécution.

II.2.1 La déclaration
Les instructions de déclaration nomment une variable, une constante ou une procédure et
peuvent également spécifier un type de données (Const, Dim, Private, Public, New, Static).

Ici on déclare une variable « privée » de type « String » et de nom « myVar ».

II.2.2 L’affectation
Les instructions d'affectation attribuent une valeur ou une expression à une variable ou à une
constante (=, Let).

II.2.3 Les instructions exécutables

Ces instructions exécutent des lignes de codes (structures alternatives, structures
répétitives, débranchements, appels de modules …).

Comme dans la plupart des langages, les mots clés correspondant à ces structures sont If,
Then,
 Les « If multilignes » On utilise les mots clés « Else If » autant de fois que nécessaire.

Le « Case »

Les structures répétitives

Visual Basic utilise les mots clés For, To et Next pour les boucles « Pour », Do While et
Loop pour la boucle « Tant que » (il existe également While et Wend), Do et Loop Until pour
la boucle « Jusqu’à ce que ». Quelques exemples d’utilisation de ces boucles.
II.2.4 Vérification des erreurs de syntaxe
Si une ligne s'affiche en rouge (avec un éventuel message d'erreur) après sa saisie et la
frappe de la touche ENTRÉE, l'instruction correspondante comporte une erreur. Identifiez celle-
ci et corrigez-la.

Attention : Par défaut Visual basic ne vous oblige pas à déclarer les variables, ce qui est
une source d’erreur importante. Afin de remédier à cet inconvénient, il est fortement conseillé
d’utiliser au début de chaque module l’instruction « Option Explicit » de façon à obliger VBA
à détecter les variables non déclarées.

II.2.5 Les instructions sur plusieurs lignes

Une instruction tient généralement sur une ligne, mais il est possible de la continuer sur
la ligne suivante à l'aide du caractère de continuité de ligne « _ » (blanc + blanc souligné).
II.3 Les modules
II.3.1 Ecriture d’une procédure
Une procédure est une série d'instructions délimitée par les instructions Sub et End Sub
exécutant des actions mais ne renvoyant pas de valeurs. Une procédure prend des arguments
tels que des constantes, des variables ou des expressions passées par un module appelant. Si
une procédure n'a pas d'argument, l'instruction Sub doit comporter des parenthèses vides.

II.3.2 Ecriture d’une fonction

Une fonction est une série d'instructions délimitée par les instructions Function et End
Function. Une fonction est similaire à une procédure mais peut également renvoyer une valeur.
Une fonction peut prendre des arguments, tels que les constantes, les variables ou les
expressions qui lui sont passées par un module appelant. Si une fonction n'a aucun argument,
son instruction Function doit comporter des parenthèses vides. Une fonction renvoie une valeur
en affectant une valeur à son nom dans une ou plusieurs instructions de la procédure. Dans
l'exemple suivant, la fonction Celsius convertit des degrés Fahrenheit en degrés Celsius.
Lorsque la fonction est appelée depuis la procédure Main, une variable contenant la valeur de
l'argument est passée à la fonction. Le résultat du calcul est renvoyé à la procédure appelante et
affiché dans un message.
II.3.3 Appel des modules
Pour appeler une procédure depuis une autre procédure, il faut simplement taper le nom
de la procédure sans oublier les valeurs des arguments obligatoires. L'instruction « Call » n'est
pas obligatoire, mais si vous l'utilisez, vous devez mettre les éventuels arguments entre
parenthèses. Vous pouvez utiliser une procédure pour organiser d'autres procédures de manière
à simplifier leur interprétation et leur débogage.

Dans l'exemple suivant, la procédure « Main » appelle la procédure « MultiBeep »,

passant la valeur 56 comme argument. Après l'exécution de MultiBeep, le système redonne la
main à « Main » qui appelle la procédure « Message ». « Message » affiche un message ; lorsque
l'utilisateur clique sur OK, la main revient à « Main » qui se termine.

Appel de procédures avec plusieurs arguments

L'exemple suivant illustre deux manières d'appeler une procédure avec plusieurs
arguments. Lors du second appel de HouseCalc, les arguments doivent être mis entre
parenthèses parce que l'instruction « Call » est employée.
 Utilisation des parenthèses lors d'appel de fonctions
Pour utiliser la valeur renvoyée par une fonction, il faut affecter la fonction à une variable
et mettre les arguments entre parenthèses, comme le montre l'exemple suivant :

Si la valeur renvoyée par une fonction ne vous intéresse pas, vous pouvez appeler une
fonction de la même manière qu'une procédure, il suffit d’omettre les parenthèses, d’indiquer
les arguments et de ne pas affecter la fonction à une variable, comme le montre l'exemple
suivant :

Attention Si vous incluez des parenthèses dans l'exemple précédent, l'instruction cause une
erreur de syntaxe.

III. Exploration de la Boîte à Outils de Visual Basic

L’exploration de la boîte à outils est une étape essentielle pour tout développeur
travaillant avec Visual Basic, car elle permet d’accéder à des éléments préconçus facilitant la
conception et le développement d’applications.

III.1 Présentation de la Boîte à Outils

La boîte à outils est une fenêtre latérale de Visual Studio qui contient une liste de
contrôles graphiques et d’outils de programmation que l’on peut faire glisser sur un
formulaire Windows Forms ou WPF (Windows Presentation Foundation). Ces éléments
permettent de créer des interfaces utilisateur dynamiques et interactives.

La boîte à outils peut être affichée en accédant à Affichage → Boîte à outils (View →
Toolbox) ou en utilisant le raccourci clavier Ctrl + Alt + X.

Elle se compose de plusieurs sections regroupant différents types de contrôles.

III.2 Catégories Principales de la Boîte à Outils

III.2.1 Contrôles Windows Forms
Ces contrôles sont les plus couramment utilisés pour concevoir des interfaces utilisateur sous
Windows Forms. Parmi eux, on retrouve :

• Button (Bouton) : Permet de déclencher une action lorsqu’il est cliqué.

 • Label (Étiquette) : Affiche un texte statique sur l’interface.

• TextBox (Zone de texte) : Permet la saisie de texte par l’utilisateur.

• ListBox (Liste déroulante simple) : Affiche une liste d’éléments parmi lesquels
l’utilisateur peut sélectionner un ou plusieurs choix.

• ComboBox (Liste déroulante avec saisie possible) : Fournit une liste déroulante dans
laquelle l’utilisateur peut également saisir une valeur personnalisée.

• CheckBox (Case à cocher) : Offre un choix binaire (activé ou désactivé).

• RadioButton (Bouton radio) : Permet de sélectionner une seule option parmi plusieurs
choix.

• PictureBox (Zone d’image) : Permet d’afficher des images.

• ProgressBar (Barre de progression) : Indique la progression d’un processus.

III.2.2 Conteneurs
Les contrôles de conteneur servent à organiser les autres éléments de l’interface :
• GroupBox (Groupe de contrôles) : Encadre plusieurs éléments pour les regrouper.
• Panel (Panneau) : Contient et gère un ensemble de contrôles.
• TabControl (Onglets) : Permet d’organiser l’interface sous forme d’onglets.

III.2.3 Menus et Barres d’outils

Ces composants permettent d’ajouter des menus et des barres de navigation :
• MenuStrip : Crée un menu déroulant classique.
• ToolStrip : Ajoute une barre d’outils avec des boutons.
• StatusStrip : Affiche des informations en bas de la fenêtre.

III.2.4 Composants de Gestion des Données

Visual Basic intègre des outils facilitant la manipulation de bases de données :
• DataGridView : Permet d’afficher et de gérer des données sous forme de tableau.
• BindingSource : Sert d’intermédiaire entre les données et l’interface utilisateur.
• BindingNavigator : Ajoute des boutons de navigation dans une base de données.
III.2.5 Contrôles de Dialogue
Ces contrôles permettent d’afficher des boîtes de dialogue standard :
• OpenFileDialog : Ouvre une boîte de sélection de fichier.
• SaveFileDialog : Permet d’enregistrer un fichier.
• ColorDialog : Affiche une boîte de sélection de couleur.
• FontDialog : Permet de choisir une police de caractères.

III.2.6 Composants de Gestion du Système

• Timer : Exécute des actions répétées à intervalles réguliers.

• BackgroundWorker : Permet l’exécution de tâches en arrière-plan.

III.3 Manipulation des Contrôles de la Boîte à Outils

III.3.1 Ajout d’un Contrôle sur un Formulaire
L’ajout d’un contrôle se fait en glissant-déposant l’élément depuis la boîte à outils vers le
formulaire.
Exemple :
1. Ouvrir Visual Studio et créer un projet Windows Forms.
2. Sélectionner un Button dans la boîte à outils et le glisser sur le formulaire.
3. Modifier ses propriétés via la fenêtre Propriétés (exemple : changer le texte en
"Cliquez ici").
4. Double-cliquer sur le bouton pour écrire le code qui s’exécute lors du clic.

III.3.2 Modification des Propriétés des Contrôles

Chaque contrôle possède des propriétés que l’on peut modifier pour personnaliser son
apparence et son comportement :
• Text : Définit le texte affiché.
• Name : Identifie l’objet dans le code.
• Size (Taille) : Détermine la largeur et la hauteur.
• Location : Indique la position du contrôle sur le formulaire.
• BackColor / ForeColor : Change les couleurs d’arrière-plan et du texte.

III.3.3 Gestion des Événements

Chaque contrôle peut réagir à des événements tels que les clics, la saisie de texte ou le survol
de la souris.
III.4 Personnalisation Avancée des Contrôles
III.4.1 Création Dynamique de Contrôles
On peut créer et ajouter un contrôle par programmation :

III.4.2 Utilisation des Contrôles Personnalisés

On peut créer des contrôles personnalisés pour ajouter des fonctionnalités spécifiques.

Exemple de classe personnalisée héritant de Button :

I. L’apprentissage de Visual Basic (VB) constitue une excellente entrée dans

le développement d’applications Windows grâce à sa simplicité de syntaxe,
son interface intuitive et son intégration fluide avec l’environnement
Visual Studio.