Visual Basic ENVIRONNEMENT DE DÉVELOPPEMENT INTÉGRÉ (EDI)

Visual Basic

ENVIRONNEMENT DE DÉVELOPPEMENT INTÉGRÉ (EDI)

L’environnement de développement intégré de Visual Basic permet de créer, exécuter et déboguer des programmes Windows dans une seule application (à savoir Visual Basic).

Présentation de l’Environnement de Développement Intégré (EDI)

Au démarrage de Visual Basic, la boîte de dialogue suivante, intitulée Nouveau projet (cf. barre de titre), s’affiche. Elle permet de choisir le type de projet que l’on souhaite créer.
Double-cliquer sur l’option EXE Standard (surlignée par défaut) de l’onglet Nouveau afin de créer un projet (ensemble de fichiers permettant de créer une application Windows). Certaines options de cette boîte de dialogue sont brièvement décrites en annexe B. L’interface de l’EDI de Visual Basic s’affiche (voir la recopie d’écran dans la figure suivante).
Cet environnement, situé dans une fenêtre intitulée Projet1 – Microsoft Visual Basic [création] (cf. barre de titre), est formé d’une barre de menu, d’une barre de contrôles et de plusieurs fenêtres.
! Le tableau suivant récapitule les menus accessibles à partir de la barre de menu, située en haut de l’écran. En dessous sont situés, dans une barre d’outils, les raccourcis graphiques (icônes) représentant les commandes les plus courantes.
! La barre de contrôles, située dans la partie gauche de l’écran, contient des contrôles permettant de réaliser l’Interface Utilisateur Graphique (IUG) (i.e., la partie de la feuille visible par l’utilisateur). Ces derniers permettent une programmation accélérée. La figure et le tableau suivants résument les contrôles contenus dans cette barre.
! L’EDI d’un projet EXE Standard contient les fenêtre suivantes :
– Projet1 – Form1 (Form)
– Présentation des feuilles
– Propriétés – Form1
– Projet – Projet1
• La fenêtre Projet1 – Form1 (Form) contient une feuille (en anglais form) vierge nommée, par défaut, Form1, dans laquelle le programme de l’IUG sera conçu. L’IUG est la partie visible du programme (boutons, cases à cocher, cases à option, zones de saisie, etc.), elle permet :
– à un utilisateur de fournir des données (appelées entrées) au programme,
– au programme de restituer des résultats (appelés sorties) à l’utilisateur.
• La fenêtre Présentation des feuilles (en anglais Form Layout) permet de spécifier – à l’aide de la souris – la position souhaitée de la feuille (dans le cas présent Form1) sur l’écran lors de l’exécution du programme.
• La fenêtre Propriétés – Form1 décrit les propriétés (taille, position, couleur, etc.) d’une feuille ou d’un contrôle. Dans le cas présent, sont listées les propriétés liées à la feuille Form1. Chaque type de contrôle a son propre ensemble de propriétés. Certaines propriétés, telles que Height et Width sont communes aux feuilles et aux contrôles, alors que d’autres propriétés sont uniques à une feuille, ou un contrôle.
• La fenêtre Projet – Projet1 est l’explorateur de projets, elle regroupe par type les différents fichiers composant le projet en cours. La barre de menu de cette fenêtre comporte 3 boutons : Code afin de visualiser la fenêtre contenant le code du programme, Afficher l’objet pour faire apparaître la feuille, Basculer les dossiers cache, ou montre, le dossier Feuilles. Par défaut, le projet a pour nom Projet1 et est constitué d’une seule feuille, nommée Form1.

Un premier exemple : Affichage d’une ligne de texte

Réalisons un programme qui écrit le texte  » Premier exemple  » à l’écran. Ce programme, de part sa simplicité, se fait sans écrire une seule ligne de code. En fait, nous allons utiliser les techniques de la programmation visuelle dans laquelle, à travers différentes manipulations (tel qu’un clic de souris), vont être fournies les informations suffisantes à Visual Basic pour qu’il puisse automatiquement générer le code de notre programme.
Voici la démarche. Nous allons ajouter un contrôle Label sur l’IUG d’une feuille : Le fait de double-cliquer sur ce contrôle fait apparaître un contrôle Label, nommé de manière standard Label1, au centre de l’IUG de la feuille. L’utilisation de la souris permet de le positionner et de le dimensionner à volonté (la grille, visible en mode création, permet un alignement des contrôles, cf. onglet Général du menu Outils | Options).
La propriété Caption du contrôle Label1, visible dans la fenêtre des propriétés (fenêtre Propriétés – Label1), détermine le texte affiché par ce contrôle. Il suffit donc de remplacer le texte  » Label1 « , mis par défaut, par celui souhaité (à savoir  » Premier exemple « ).
Remarques :
– La propriété Caption ne doit pas être confondue avec la propriété Name du contrôle, bien que leurs contenus soient par défaut les mêmes !
– Le fait de préfixer le Name de chaque Label avec les lettres (minuscules) lbl permet une meilleure identification des contrôles Label. Il en sera de même pour les autres contrôles. Cette convention, largement adoptée, permet une meilleure  » lisibilité  » du programme.
Attention : Avant de tenter une exécution, il est prudent de sauvegarder le projet (cf. menu Fichier | Enregistrer le projet sous …). En ce qui concerne notre exemple, la sauvegarde du projet, nommé Projet1 par défaut, donne lieu à la création de deux fichiers (texte) :
– l’un, avec l’extension .frm, pour mémoriser les propriétés de la feuille, nommée Form1 par défaut. En fait, à chaque élément du projet (feuille ou module) va correspondre un fichier (.frm ou .bas).
– l’autre, avec l’extension .vbp, pour mémoriser les paramètres des variables d’environnement et des noms de fichiers des éléments constituant le projet.
Jusqu’à présent, nous avons travaillé dans le mode création de l’EDI (i.e., le programme n’est pas exécuté). En plaçant l’EDI en mode exécution (obtenu en cliquant le bouton Exécuter, ou en activant le menu Exécution | Exécuter), le programme est exécuté (avec une possible interaction via le programme de l’IUG). Il s’ensuit alors que :
– la fenêtre de l’EDI est intitulée Projet1 – Microsoft Visual Basic [exécution] (cf. barre de titre),
– la plupart des fenêtres utilisables dans le mode création sont indisponibles (c’est le cas, par exemple, de la fenêtre Propriétés). Notons l’apparition d’une fenêtre nommée Exécution, habituellement utilisée pour déboguer le programme.

INTRODUCTION A LA PROGRAMMATION DE VISUAL BASIC

La réalisation d’une application s’appuie essentiellement sur l’association de deux éléments : Les objets et les événements.

La programmation orientée objet

Visual Basic permet le développement orienté objet. Au lieu de résoudre un problème en le décomposant en problèmes plus petits, il s’agit de le scinder sous forme d’objets qui existent chacun indépendamment les uns des autres. Chaque objet possède certaines caractéristiques (appelées propriétés) et fonctions qu’il serait en mesure d’effectuer (appelées méthodes).
A titre d’illustration, la feuille  » Form1  » est un objet ayant, entre autres, une propriété appelée
 » Caption  » qui permet de spécifier le texte affiché dans la barre de titre de la feuille, et deux méthodes appelées  » Show  » et  » Hide  » qui permettent respectivement d’afficher et de cacher la feuille.
Très brièvement, on peut dire que les objets  » encapsulent  » les données (les attributs) et les méthodes (les comportements), sachant que les données et les méthodes sont intimement liées. Les objets ont la propriété de  » cacher l’information « , au sens où la communication d’un objet avec un autre ne nécessite pas de connaître comment ces objets sont  » implémentés  » (à titre d’illustration, il est possible de conduire une voiture sans connaître en détail son fonctionnement mécanique).
Alors que dans un langage procédural, la fonction joue le rôle de l’unité de programmation (les fonctions en langage objet sont appelées méthodes), l’unité de programmation en langage objet est la classe à partir laquelle les objets sont  » instanciés  » (créés) (tout objet appartient à une classe). En fait, la communication avec un objet se fait notamment à travers ses propriétés et ses méthodes. Une propriété a une valeur que le programmeur peut consulter, ou modifier ; une méthode est une procédure permettant d’agir sur les objets d’une classe. Le programmeur peut faire référence à la propriété prop, respectivement à la méthode meth, de l’objet obj en écrivant obj.prop, respectivement obj.meth.
De nombreuses classes sont prédéfinies dans Visual Basic. Par exemple, chaque icône de contrôle, situé dans la barre de contrôles de l’EDI, représente en fait une classe. Lorsqu’un contrôle est déplacé vers une feuille, Visual Basic crée automatiquement un objet de cette classe, vers lequel votre programme pourra envoyer des messages ; ces objets pouvant aussi générer des événements. Les versions récentes de Visual Basic permettent le développement de ses propres classes (et contrôles).

Programmation événementielle

Visual Basic permet la création d’IUG, sous une forme standard dans l’environnement Windows, par simple pointage et cliquage de la souris, ce qui a pour intérêt d’éliminer l’écriture du code permettant de générer l’IUG d’une feuille, de fixer ses propriétés, de créer les contrôles contenus dans l’IUG.
Il s’agit pour le programmeur de créer l’IUG d’une feuille et d’écrire le code décrivant ce qui se produit lorsque l’utilisateur interagit avec l’IUG (clic, double-clic, appuie sur une touche, etc.). Ces actions, appelées événements (en anglais events), sont reliées au programme via le système d’exploitation de Microsoft Windows (voir l’annexe C pour plus de précisions). En fait, il est possible pour chacun des contrôles contenus dans l’IUG de répondre, de manière appropriée, aux différents événements auxquels sont sensibles les contrôles.
Pour cela, il va correspondre à chacun de ces événements une procédure de réponse (en anglais event procedure), dans laquelle le programmeur insérera des lignes de code approprié. Une telle programmation de code en réponse à ces événements est dite programmation événementielle.
Ainsi, ce n’est plus le programmeur mais l’utilisateur qui maîtrise l’ordre d’exécution du programme (le programme ne dicte plus la conduite de l’utilisateur).
Dans un programme Visual Basic, tous les contrôles (zones de texte, boutons de commande, etc.) possèdent un ensemble d’événements prédéfinis auxquels on peut lier du code (pour ne pas réagir à un événement prédéfini, il suffit de ne pas écrire de code correspondant). A titre d’illustration, l’événement appelé  » Load  » de la feuille  » Form1  » est déclenché à chaque premier chargement de la feuille (ici
 » Form1 « ), juste avant son affichage. Il sert habituellement à fixer les valeurs des propriétés de la feuille, ou à exécuter du code lors de son apparition. Voir l’annexe D pour plus de précisions.
En bref, un programme (une application) Visual Basic est créé à partir d’un projet constitué, notamment, de feuilles, lesquelles comprennent :
– une IUG composée de contrôles,
– les procédures de réponses aux événements associées à ces contrôles.
Notons qu’une feuille peut aussi contenir des procédures et des déclarations locales à la feuille, sans lien direct avec un contrôle contenu dans l’IUG. Nous verrons par la suite, qu’en plus des feuilles, un projet peut être constitué de modules.

Deux exemples

Écriture d’une ligne de texte sur une feuille

L’IUG consiste en deux boutons : Ecrire et Sortir. Il s’agit d’écrire la ligne  » Deuxième exemple  » autant de fois que l’utilisateur clique sur le bouton Ecrire. Le fait de cliquer sur le bouton Sortir permet de terminer l’exécution du programme. Les recopies d’écran qui suivent montrent, à gauche, la feuille avant un clic sur le bouton Ecrire, à droite, la feuille après plusieurs clics sur ce bouton.
La propriété TabIndex permet de contrôler l’ordre dans lequel les contrôles, constituant l’IUG, reçoivent le focus (i.e., deviennent actifs). Le contrôle, ayant une valeur de TabIndex égale à 0, a le focus au départ.
Le code programme qui suit permet :
– d’afficher dans la feuille le texte  » Deuxième exemple  » avec la police de caractères souhaitée lors d’un clic sur la touche Ecrire (cf. la procédure de réponse à l’événement, nommée cmdDisplay_Click).
– de terminer le programme lors d’un clic sur la touche Sortir (cf. la procédure de réponse à l’événement, nommée cmdExit_Click).
___________________________________________________
Private Sub cmdDisplay_Click()
‘ A chaque fois que le bouton « Ecrire » est cliqué,
‘ le message « Deuxième exemple » est affiché sur la feuille Print « Deuxième exemple »
End Sub
Private Sub cmdExit_Click()
End ‘ Termine l’exécution du programme
End Sub
___________________________________________________
Private Sub et End Sub marquent respectivement le début et la fin d’une procédure. Le code que le programmeur veut exécuter lors d’un clic sur la touche Ecrire, est placé entre le début et la fin de la procédure, i.e., Private Sub cmdDisplay_Click() et End Sub.
‘ A chaque fois que le bouton « Ecrire » est cliqué,
‘ le message « Deuxième exemple » est affiché sur la feuille
sont des lignes de commentaires.
La ligne
Print « Deuxième exemple »
affiche le texte  » Deuxième exemple  » sur la feuille (en cours) en utilisant la méthode Print. En toute rigueur, il faudrait faire précéder la méthode Print du nom de la feuille, soit la ligne
frmExemple2.Print « Deuxième exemple » (nom de l’objet.nom de la propriété)
Notons que cette méthode n’est pas la plus appropriée lorsque la feuille contient des contrôles, il serait préférable d’écrire le texte dans un contrôle de type TextBox (détaillé au § 8.2).
La ligne
End
située dans la procédure cmdExit, termine l’exécution du programme (i.e., place l’EDI en mode création).

Addition d’entiers

A partir d’entiers introduits par l’utilisateur, il s’agit d’afficher leur somme successive. L’IUG consiste en deux étiquettes (Label), deux zones de saisie (TextBox) et deux boutons (CommandButton), cf. la recopie d’écran dans la figure suivante.
Le tableau qui suit liste les objets et certaines de leurs propriétés (seules les propriétés ayant été modifiées sont listées).
Le contrôle TextBox permet à l’utilisateur, via la propriété Text, d’entrer du texte (cf. TextBox txtEntree), il permet aussi d’afficher du texte (cf. TextBox txtSomme).
La propriété Enabled du contrôle TextBox txtSomme positionnée à False fait que ce contrôle ne réagit à aucun événement, il s’ensuit que le texte représentant la somme est de couleur grise.
Le code du programme est le suivant :
___________________________________________________
Dim sum As Integer
Private Sub cmdAjouter_Click()
sum = sum + txtEntree.Text
txtEntree.Text = «  »
txtSomme.Text = sum
End Sub
Private Sub cmdSortir_Click()
End
End Sub
___________________________________________________
La ligne
Dim sum As Integer
déclare une variable, nommée sum, de type entier (2 octets, entre –32768 et 32767), initialisée par défaut à 0.
Remarque : La déclaration des variables dans Visual Basic est facultative, une variable non déclarée sera par défaut de type Variant (cf. § 4.4). Toutefois, il est conseillé, pour des raisons d’aide à la mise au point de programmes, de rendre obligatoire la déclaration des variables. Pour cela, il faut la présence dans la partie  » déclaration générale  » de la ligne suivante :
Option Explicit
Cette ligne peut être soit tapée directement dans la partie  » déclaration générale « , soit introduite automatiquement par Visual Basic en ouvrant, avant toute programmation, le menu Outils | Options, puis en cliquant l’onglet nommé Editeur et en cochant la case Déclaration des variables obligatoire (case non cochée par défaut).
La ligne
sum = sum + txtEntree.Text
ajoute le texte de txtEntree à la variable sum, puis place le résultat dans la variable sum. Avant l’opération
d’addition (+), la chaîne de caractères située dans la propriété Text est convertie implicitement en une
valeur entière.
La ligne
txtSomme.Text = sum
met le contenu de la variable sum dans txtSomme.Text, Visual Basic convertit implicitement la valeur entière contenue dans sum en une chaîne de caractères.
Remarque : De manière plus rigoureuse que les conversions implicites (qui peuvent donner lieu à des méprises), il existe des fonctions Visual Basic permettant de convertir une chaîne de caractères en une valeur entière, et réciproquement (cf. fonctions Val et Str$).
Ces opérateurs permettent au programme de prendre une décision basée sur la vérification, ou non, (True ou False) d’une condition.

STRUCTURES DE CONTRÔLE

Afin de concevoir un programme, nous allons décrire les différents types de blocs de construction possibles et rappeler les principes de la programmation structurée. N’importe quel problème informatique peut-être résolu en exécutant une série d’actions dans un ordre spécifique, une telle procédure est appelée un algorithme.
Lorsque les instructions d’un programme sont exécutées l’une à la suite de l’autre, dans l’ordre où elles ont été écrites, l’exécution est dite séquentielle. Certaines instructions permettent au programmeur de spécifier que la prochaine instruction à exécuter peut être différente de celle qui est située dans la séquence, ces instructions effectuent un transfert de contrôle.
Durant les années 1960, l’utilisation de l’instruction de transfert de contrôle goto fut bannie comme étant la source de nombreux problèmes de programmation (difficultés vis-à-vis de la compréhension, du test, de la modification d’un programme). La programmation dite structurée ( » sans goto « ) fut présentée comme une alternative. En fait tous les programmes peuvent être construits par combinaison de seulement trois structures de contrôle : La structure en séquence, la structure de sélection et la structure de répétition.
Visual Basic propose :
– trois types de structures de sélection : If/Then, If/Then/Else, Select Case,
– six types de structures de répétition : While/Wend, Do While/Loop, Do/Loop While, Do Until/Loop, Do/Loop Until, For/Next.
La figure suivante récapitule les différentes structures de contrôle de Visual Basic.
…….
1 INTRODUCTION
2 ENVIRONNEMENT DE DÉVELOPPEMENT INTÉGRÉ
2.1 Présentation de l’Environnement de Développement Intégré (EDI)
2.2 Un premier exemple : Affichage d’une ligne de texte
3 INTRODUCTION À LA PROGRAMMATION DE VISUAL BASIC
3.1 La programmation orientée objet
3.2 Programmation événementielle
3.3 Deux exemples
3.4 Règles de priorité des opérateurs arithmétiques
3.5 Opérateurs de comparaison
4 STRUCTURES DE CONTRÔLE
4.1 Structures de sélection
4.2 Structures de répétition
4.3 Opérateurs logiques
4.4 Types de données
5 PROCÉDURES ET FONCTIONS
5.1 Introduction
5.2 Les modules
5.3 Les procédures Sub
5.4 Les procédures Function
5.5 Appel par valeur, appel par référence
5.6 Exit Sub et Exit Function
5.7 Durée de vie d’une variable
5.8 Portée d’une variable, d’une procédure, d’une fonction
5.9 Les constantes
5.10 Paramètres optionnels
5.11 Fonctions mathématiques de Visual Basic
5.12 Module standard
6 LES TABLEAUX
6.1 Leurs déclarations
6.2 Les tableaux dynamiques
6.3 Passage de tableaux dans les procédures
7 LES CHAÎNES
7.1 Concaténation avec & (esperluette) et +
7.2 Comparaison de chaînes
7.3 Manipulation de caractères dans une chaîne
7.4 Left$, Right$, InStr, InStrRev, Split, Join
7.5 LTrim$, RTrim$ et Trim$
7.6 String$ et Space$
7.7 Autres fonctions de traitement de chaînes
7.8 Fonctions de conversion
8 INTERFACE UTILISATEUR GRAPHIQUE : LES BASES
8.1 Le contrôle Label
8.2 Le contrôle TextBox
8.3 Le contrôle CommandButton
8.4 Les contrôles ListBox, ComboBox
8.5 Les contrôles Frame, CheckBox, OptionButton
8.6 Les menus
8.7 La fonction MsgBox
8.8 Le contrôle Timer
9 BASE DE DONNÉES : ACCÈS
9.1 Introduction de l’ADO Data Control 6.0 et du DataGrid Control 6.0
9.2 Survol du langage SQL
9.3 Description de l’ADO Data Control 6.0 et du DataGrid Control 6.0
9.4 L’objet Recordset
10 MULTIPLE DOCUMENT INTERFACE
11 RÉSEAUX, INTERNET ET WEB
11.1 Le contrôle WebBrowser
11.2 Le contrôle Internet Transfer
11.3 Le contrôle Winsock
12 PROGRAMMATION ORIENTÉE OBJET
12.1 Les modules de classe
12.2 Accès aux membres d’une classe : Public, Private
12.3 Composition : Objets en tant que variables d’instance d’autres classes
12.4 Evénements et classes
Annexes :
A : Code de compilation
B : Types de projet
C : Eléments clés de Windows : Fenêtres, événements et messages
D : Description du modèle événementiel
E : Description (notamment) des paramètres de MoveComplete
F : Les types de variables objet
G : Traitement de fichiers avec d’anciennes instructions et fonctions d’E/S de fichiers
Bibliographies