Programmation Graphique Et Ev Avec Vbnet - Missway2022

i
Josué MISSWAY KINDIA
PROGRAMMATION GRAPHIQUE ET EVENEMENTIELLE

AVEC VISUAL BASIC.NET
(Syntaxes et illustrations)
Préfacé par le Prof. Emmanuel Tshibaka Katumonangani

ii
Pensée pieuse aux professeurs :
Emmanuel Kanga Matondo ;
Marcel Musangu Luka ;
Alphonse Christian Ivinza Lepapa.

i
PREFACE
A l’heure actuelle, la mondialisation impose à l’humanité

un rythme de travail très dynamique. Dans notre nouveau monde
transfrontalier, le fonctionnement harmonieux de toutes les
organisations est dicté par l’utilisation des programmes
informatiques.
La mise sur pied d’un programme exige l’application

stricte de normes informatiques qui ne sont rien d’autres que les
méthodes utilisées par l’informaticien et le langage de
programmation lié à cette méthode.
La résolution d’un problème en informatique exige

toujours l’émission d’un raisonnement pour arriver au résultat
escompté. Ce raisonnement est rendu visible par la rédaction de
l’algorithme et opérationnalisé par la traduction dans un langage
compréhensible par l’ordinateur.
Ainsi, à travers cet ouvrage, les lecteurs tireront profit des

différentes étapes nécessaires au développement d’un
programme informatique à travers Visual basic.NET.
Ce manuel s’adresse aux étudiants débutants en

programmation, aussi à tous les passionnés de développement
des logiciels. A cet effet, il présente les bases de programmation
dans le but d’initier les apprenants à la conception et la
réalisation des applications graphiques et événementielles.
Au regard du contenu de cet ouvrage, le Chef de Travaux

Josué Missway Kindia devient aussi un auteur de références à
la matière et développeur .NET.
Emmanuel TSHIBAKA KATUMONANGANI
Professeur des universités

ii
AVANT-PROPOS
La mise au point d’une application en informatique appelle

à la maitrise de préalables en rapport avec le de développement.
Cependant, un programme en informatique est un

ensemble d’instructions que l’on soumet à l’ordinateur pour
résoudre un problème donné. Il peut être écrit dans un langage
exploitable ou compréhensible par l’ordinateur. En substance, le
langage de programmation et l’ordinateur ne sont que des
moyens, le but étant bien sûr l’exécution de l’algorithme et le
déroulement du traitement correspondant.
Pour montrer le rôle éminemment important de

l’algorithme, les spécialistes de l’informatique affirment qu’un
langage de programmation n’est qu’un moyen pratique
d’énoncer un algorithme, et un ordinateur est un simple
processeur qui l’exécute.
L’algorithme a un rôle fondamental en programmation. Il

est à la fois indépendant du langage de programmation dans
lequel il est énoncé et de l’ordinateur qui l’exécute. Toutefois, un
même problème peut être résolu au moyen de plusieurs
algorithmes.
Un même algorithme peut être traduit en plusieurs

langages de programmation (C, C++, Delphi, Pascal, Java,
Vbasic etc.) et exécuté sur différents ordinateurs.
Il va sans dire qu’écrire un programme correct suppose

donc la parfaite connaissance du langage de programmation et
de sa syntaxe, qui est en quelque sorte la grammaire du langage.
Mais cela n’est pas suffisant.
Puisque le programme est la représentation d’un

algorithme celui-ci doit être correct pour que le programme le soit
aussi. Un programme correct résulte donc d’une démarche
iii
logique (algorithme correct) et de la connaissance de la syntaxe
d’un langage de programmation.
Le présent manuel vise à faire acquérir à l’apprenant

débutant au développement, les connaissances de base
nécessaires à la programmation graphique et événementielle. Il
permettra de maîtriser le processus de mise en œuvre d'une
application VB.Net à interface graphique ainsi que les méthodes
de connexion à une base de données.
Avec tous les avantages que présente l’environnement

Dot.Net, apprendre la programmation avec le Visual basic est
plus aisé.
Ceci dit, place à présent aux uns d’apprendre et aux

autres de perfectionner.
L’auteur
iv
TABLE DES MATIERES
PREFACE ............................................................................................................................... i
AVANT-PROPOS................................................................................................................... ii
CHAPITRE I........................................................................................................................... 1
GENERALITES SUR LA PROGRAMMATION .......................................................................... 1
0. Introduction ............................................................................................................ 1
1.1. Le langage de programmation ..................................................................................... 1
1.2. Paradigme de programmation ............................................................................ 3
CHAPITRE II.......................................................................................................................... 8
PRESENTATION DE VISUAL BASIC.NET ................................................................................ 8
0. Introduction ................................................................................................................ 8
I. Framework.Net ................................................................................................................ 8
II. Visual basic .................................................................................................................... 15
2.1. Notions ....................................................................................................................... 15
III. Prise en main de Visual Basic.NET......................................................................... 17
3.1. Installation de Visual basic 2012 Ultimate ............................................................ 17
3.3. Environnement de Développement Intégré ......................................................... 19
3.4. Etude des contrôles et propriétés......................................................................... 26
3.4.1. Les contrôles : ......................................................................................................... 26
3.4.2. Les propriétés communes aux contrôles en VB.NET .............................................. 33
CHAPITRE III....................................................................................................................... 35
ELEMENTS DE BASE DE PROGRAMMATION...................................................................... 35
0. Introduction .............................................................................................................. 35
I. Variable ..................................................................................................................... 35
2. Les constantes ........................................................................................................... 38
3. Les tableaux................................................................................................................... 38
4. Identificateur............................................................................................................. 43
5. Commentaires ........................................................................................................... 43
a. Opérateurs arithmétiques .............................................................................. 44
b. Opérateurs de comparaison ...................................................................... 45
c. Opérateurs logiques .................................................................................... 45
v
d. Opérateur d’affectation ............................................................................... 46
CHAPITRE IV ...................................................................................................................... 54
STRUCTURE DE CONTROLE ............................................................................................... 54
0. Introduction .............................................................................................................. 54
I. Structures conditionnelles ........................................................................................ 54
II. Structures répétitives (itératives) ............................................................................. 61
2.1. Boucle For ... Next ................................................................................................. 61
2.2. Boucle While … End while ..................................................................................... 63
2.3. Boucle Do while... Loop......................................................................................... 63
2.5. Boucle Do loop …. While ....................................................................................... 65
2.6. La boucle Do loop … Until ..................................................................................... 65
III. Gestion des exceptions ......................................................................................... 71
CHAPITRE V ....................................................................................................................... 73
PROGRAMMATION EVENEMENTIELLE .............................................................................. 73
0. Introduction .................................................................................................................. 73
I. Principes .................................................................................................................... 73
II. Etapes de développement d’une application ........................................................... 75
III. Procédures événementielle .................................................................................. 76
IV. Quelques instructions particulières ............................................................................. 76
IV. Manipulation des quelques éléments................................................................... 81
CHAPITRE VI ...................................................................................................................... 90
ACCES A LA BASES DE DONNEES ....................................................................................... 90
O. Introduction .................................................................................................................. 90
III. ETUDE DE CAS ....................................................................................................... 97
3.1. Conception du formulaire ..................................................................................... 98
3.2. Création de module............................................................................................. 101
3.3. Ecriture de codes................................................................................................. 103
BIBLIOGRAPHIE ............................................................................................................... 125
a) Ouvrages ................................................................................................................. 125
1
CHAPITRE I
GENERALITES SUR LA PROGRAMMATION
0. Introduction
Un programme n’est rien d’autre que la représentation

d’un algorithme dans un langage plus technique compris par un
ordinateur. Ce type de langage s’appelle langage de
programmation. En d’autres mots, un programme est une
description codée d’un algorithme. Cette description est donnée
en respectant des règles strictes de combinaison d’éléments
simples. Ces règles définissent ce que l’on convient d’appeler un
langage de programmation.
1.1. Le langage de programmation

En informatique, la théorie des langages a pour objectif
de décrire les langages formels. D'un point de vue
mathématique, un langage formel est un ensemble de mots, le
mot étant une suite finie de symboles. L'ensemble de ces
symboles est appelé alphabet, les symboles eux- mêmes sont
des lettres. Un langage (formel) est décrit et analysé par une
méthode formelle. Plusieurs sortes de mécanismes existent pour
arriver à cette fin.
L’intérêt du programme provient de l’utilisation d’un

langage de programmation. Les règles strictes qui définissent le
langage de programmation sont préétablies et standardisées. On
dispose, en général, d’un système qui permet de transformer la
description d’un algorithme, donnée par un programme, en un
ensemble d’instructions élémentaires d’une machine de
traitement d’information. Ce système de transformation est
appelé compilateur ou interpréteur. Par exemple, Pascal, C,
C++, java, Visual basic sont des langages de programmation
pour lesquels on trouve facilement des compilateurs et des
interpréteurs.
2
Un environnement moderne de programmation comprend
une interface utilisateur, des outils (compilateur, éditeur de liens,
débogueur, méthode d’analyse.) et la base de données centrale.
Des méthodes sont apparues pour formaliser les étapes de
développement. On retiendra notamment la méthode Merise et
le langage de modélisation comme UML.
En résumé, un langage de programmation se

compose de quatre parties, à savoir:
 Son vocabulaire qui définit la liste des mots acceptables

issus de son alphabet. Cette couche est dite structure
lexicale. Elle décrit les lexèmes ou unités lexicales du
langage, c’est-à-dire la façon dont sont écrits les mots-
clés, les identificateurs, les nombres, les opérateurs et
autres symboles utilisés par le langage. Chacun de ces
lexèmes est écrit avec un ou plusieurs caractères. Par
exemple, les caractères + et = servant à représenter en
C l’opérateur d’addition et l’opérateur d’affectation
définissent, lorsqu’ils sont utilisés seuls, deux lexèmes
que l’on pourra par exemple appeler PLUS et ASSIGN.
Par contre, utilisés ensemble sous la forme +=, ils
correspondent à un autre lexème que l’on pourra par
exemple appeler PLUSASSIGN.
De même un nombre entier, un nombre flottant ou un

identificateur correspondront chacun à un lexème (CST_INT,
CST_FLOAT ou IDENT) bien qu’ils puissent être formés d’un
nombre arbitraire de caractères. L’analyse lexicale d’un
langage consiste à regrouper de façon convenable en lexèmes
la suite de caractères représentant un programme.
 Sa grammaire qui donne la syntaxe des phrases à
formuler. C’est la couche dite la structure syntaxique.
L’analyse syntaxique extrait de la suite de lexèmes
produite la structure syntaxique du programme qui est
3
définie par une grammaire.
 Sa sémantique, c'est-à-dire la signification des

instructions à produire.
 Son exécution, « l’intelligence» à répondre aux
commandes de l’utilisateur.
1.2. Paradigme de programmation
Un paradigme est une façon d'approcher la

programmation. Chaque paradigme amène sa philosophie de la
programmation ; une fois qu'une solution a été imaginée par un
programmeur selon un certain paradigme, un langage de
programmation qui suit ce paradigme permettra de l'exprimer.
Chaque langage de programmation reflète un ou plusieurs
paradigmes, apportant un ensemble de notions qui peuvent être
utilisées pour exprimer une solution à un problème de
programmation. Au cours de l'histoire, les scientifiques et les
programmeurs ont identifié les avantages et les limitations d'un
style de programmation et apporté de nouveaux styles. La
plupart des langages de programmation contemporains
permettent d'adopter plusieurs paradigmes de programmation à
condition que ceux-ci soient compatibles.
Un paradigme de programmation fournit (et détermine)

la vue qu’a le développeur de l’exécution de son programme.
Les paradigmes de programmation permettent de "classer" les
langages entre eux selon des critères centrés autour
essentiellement de l'abstraction. Si cette abstraction
représente la démarche principale qui guide l'apparition de ces
paradigmes...elle cache de multiples dimensions qui se
révèlent en étudiant tant les paradigmes liés aux langages de
programmation qu'au développement lui-même.
4
1.2.1.Programmation ascendante
Dans ce type de programmation, les fonctions de plus bas

niveau sont développées, programmées et testées en premier,
puis assemblées pour former les fonctions de niveau plus élevé.
1.2.2.Programmation descendante
La méthodologie de la programmation descendante

définit, en premier lieu, les fonctionnalités du programme à son
niveau le plus élevé pour subdiviser ensuite chacune d’entre
elles en tâches de niveau inférieur.
1.2.3.Programmation linéaire
La programmation linéaire correspond à l’écriture de

programmes permettant de déterminer les solutions optimales
de systèmes d’équations ou d’inéquations linéaires. Si vous
utilisé un langage traditionnel de programmation Qbasic, Cobol,
pascal…) vous avez mis en œuvre une programmation linéaire.
Le programme est souvent constitué de trois phases :
Initialisation
Boucle
Finalisation
 L’initialisation où l’on peut préparer l’écran ; initialiser les

données, ouvrir les fichiers ;
 La boucle, qui peut être l’attente d’un caractère en
provenance du clavier ou lecture d’un enregistrement du
5
fichier. Le caractère ou l’enregistrement est traité, puis le
programme se remet en attente du suivant ;
 La finalisation, qui effectue les opérations inverses de
l’initialisation et essentiellement une remise en état du
système.
Imaginez que le déroulement du programme soit effectué

par une araignée qui déroule son fil derrière elle. Quel que soit
la complexité de l’application, si l’on considère l’exécution du
programme depuis son lancement jusqu’au moment où il se
termine, un seul fil est déroulé, et on pourrait théoriquement le
démêler pour n’obtenir qu’un fil rectiligne.
Cela justifie l’appellation linéaire donnée à ce type de

programmation on parle également de programmation
procédurale dans la mesure où ce déroulement linéaire utilise en
général des procédures, ensemble d’instructions pouvant être
appelés à partir des divers endroits.
La structure générale d’une programmation traditionnelle

est résumée de la manière suivante :
 Il y a un point de sortie ;
 Entre les deux, il n’y a qu’un fil pour une exécution de
l’application ;
 Des appels à des procédures ou fonctions peuvent être
faits.
1.2.4.Programmation logique
En programmation logique, un programme se compose

de faits et de relations logiques, aboutissant à des conclusions
par déduction. Le langage de programmation Prolog permet
ainsi de développer un programme selon ce type de
programmation.
6
1.2.5.Programmation modulaire
En programmation modulaire, un programme est

décomposé en plusieurs modules qui sont compilés séparément.
Chaque module exporte des éléments spécifiés (constantes,
types de données, variables, fonctions, procédures), tous les
autres demeurant internes au module.
Les modules clarifient et régularisent les interfaces entre les

grandes parties du programme, favorisant par conséquent la
fiabilité de l’ensemble.
1.2.6.Programmation structurée
Un programme écrit en programmation structurée

présente un déroulement net, une conception claire et un certain
degré de structure hiérarchique. Ce type de programme offre
plusieurs avantages, comme celui d’être facilement
compréhensible et modifiable par d’autres programmeurs.
1.2.7.Programmation orientée objet
En programmation orientée objet, un programme est

considéré comme un ensemble d’objets distincts, constitués eux-
mêmes d’ensembles de structures de données et de routines
(sous-programmes) intégrées. Chaque objet appartient à une
classe qui définit les structures de données et les routines qu’il
contient.
Si, par exemple, on crée une classe nommée « cartable »,

l’objet « mon cartable » faisant partie de la classe « cartable »
est appelé instance de « cartable ». Toute classe peut donc être
utilisée comme variable dans ce type de programme, dont les
objets ainsi définis interagissent.
7
a) Objectifs :
 Lier les données et les fonctions qui les manipulent afin
d’éviter des accès aux données par des fonctions non
autorisées ;
 Obtenir une meilleure abstraction en cachant
l’implémentation des techniques utilisées et en ne rendant
visible que des points d’entrée. Ainsi, si l’implémentation
change, le code utilisateur n’est pas affecté ;
 Réutiliser l’existant dans un souci de productivité ;
 Traiter les erreurs localement au niveau des objets sans
que cela ne perturbe les autres parties du programme ;
 Faciliter la maintenance.
1.2.8.Programmation de macros
De nombreux programmes comprennent des macro-

instructions, séquences d’instructions prédéfinies auxquelles on
accède par une combinaison de touches ou par une commande
très simple. Ces macros offrent l’avantage de supprimer les
manipulations répétitives et d’accéder plus facilement aux
opérations courantes.
1.2.9. Programmation événementielle
La programmation événementielle est un paradigme de

programmation dans lequel l'exécution d'actions est déclenchée
automatiquement lorsqu'un événement survient.
Un événement correspond en général à un changement d'état
dans l'univers, ou bien à une intervention explicite de l'utilisateur
(ou d'un système externe).
8
CHAPITRE II
PRESENTATION DE VISUAL BASIC.NET
0. Introduction
Le développement de ce chapitre donne au lecteur les astuces

nécessaires de développement des applications dot Net, ainsi
comprendre l’environnement de développement intégré.
I. Framework.Net
1.1. Quid du Framework
Le Framework.Net est un Framework (un kit de

composants) créé par Microsoft en 2001. Il a pour but de faciliter
la tâche des développeurs en proposant une approche unifiée à
la conception d’application Windows, Web et mobile.
Il s’appuie sur la norme CLI (Common Language

Infrastructure) qui est indépendante du langage de
programmation utilisé. Ainsi tous les langages compatibles
respectant la norme CLI ont accès à toutes les bibliothèques
installées.
Son implémentation se fait dans la norme CLR (Common

Language Runtime), le composant de machine virtuelle de .Net.
C’est l’équivalent de la JVM de java. Le CLR fait tourner
un bytecode nommé Common Intermediate Language (CIL). Le
compilateur à la volée transforme le code CIL en code natif
spécifique au système d'exploitation.
9
Présentation des normes qui régissent le Framework.Net
La programmation est faite avec du code dit « managé »

en opposition au code dit « natif ». Les langages les plus connus
sont le C#. Concurrent de Java, VB.NET mais également J#,
Delphi.Net ou Cobol.Net.
1.2. Structure d’une application .NET et exécution
L'unité de base d'une application .NET est appelée un

assemblage (assembly). Il s'agit d'un ensemble de code, de
ressources et de métadonnées. Un assemblage est toujours
accompagné par un manifeste (assembly manifest) qui décrit ce
qu'il contient : nom, version, types de données exposées, autres
assemblages utilisés, instructions de sécurité. Un assemblage
est composé d'un ou plusieurs modules qui contiennent le code.
Tout comme en Java, quand une application .NET est

compilée, elle n'est pas compilée en code binaire machine, mais
dans un code binaire intermédiaire CIL. Une application consiste
donc en un ensemble d'assemblages contenus dans un ou
10
plusieurs fichiers exécutables ou fichiers DLL en Common
Intermediate Language (CIL). Au moins un de ces assemblages
doit contenir un point d'entrée afin de démarrer l'application.
Quand l'exécution d'un programme démarre, le premier
assemblage est chargé en mémoire. Le CLR commence par
examiner les permissions demandées par cet assemblage et les
compare à la politique de sécurité (security policy) du système.
Puis, si l'assemblage est autorisé à s'exécuter, un processus est
créé pour exécuter l'application. Le premier morceau de code
nécessaire à l'exécution est chargé en mémoire et est compilé
en code binaire natif par le compilateur juste à temps (Just-In-
Time, JIT). Une fois compilé, le code est exécuté et stocké en
mémoire sous forme de code natif, garantissant ainsi que chaque
portion de code n'est compilée qu'une seule fois lors de
l'exécution de l'application.
a. Avantages d’un Framework
Le Framework présente un certain nombre d’avantages,

nous pouvons y citer quelques-uns :
 La liberté : pouvoir d’exercer sa volonté en agissant ou

pas ;
 La rapidité : permet d’accélérer la réaction des
applications ;
 La qualité : la Framework octroie une aptitude aux
applications ;
 La cohérence : stipule la cohésion, une liaison étroite ;
 La pérennité : caractère de ce qui dure toujours.
1.4. Code natif et code managé
Le code managé vous permet de développer des

applications plus rapidement car vous avez accès à un nombre
d’éléments déjà créés très facilement dans des bibliothèques.
11
Exemple : vous souhaitez intégrer une vidéo dans votre
projet ? Pour la démarrer, vous n’avez juste qu’à écrire
« mavidéo. start () » ou pour la stopper, «mavideo.stop()».
Si vous développer en code natif (ASM, C, C++, Pascal…)

sachez que votre application prendra plus de temps à être mise
en place mais vous aurez un accès plus approfondi au niveau de
la machine (processeur, Ram) comme pouvoir gérer la mémoire
allouée à l’aide des pointeurs.
Cependant, la sécurité est accrue avec du code managé

par la présence par exemple d’un « ramasse-miette » qui permet
de vider la mémoire si l’utilisateur oublie de le faire.
1.4. Evolution du Framework
Version 1.0
Cette version a vu le jour en date du 13 février 2002 et est

disponible sous Windows 98, NT4, 2000 et XP. Le
développement se fait avec Studio.Net (version 7.0).C# fait son
apparition.
Version 1.1.
Elle est sortie le 3 avril 2003 et inclue par défaut dans

Windows Server 2003. Le support pour les contrôles ASP.NET
est intégré. Les Windows forms peuvent s’exécuter dans un
environnement à partir d’internet. Le support pour ODBC, les
bases de données Oracle et IPv6 sont pris en charge.
Une version du Framework destinée aux appareils

mobiles (notamment Windows CE, puis Windows Mobile)
appelée Compact Framework fait son apparition. Le
développement se fait sous Visual studio 2003 (version 7.1).
Version 2.0
12
La version 2.0 en version redistribuable est disponible
gratuitement sur le site de Microsoft a été publié le 22 janvier
2006. Il est aussi inclus sous forme d’option gratuite à Windows
Server 2003 R2. Il s’agit de la dernière compatible avec Windows
2000, Windows ME.
C’est mise à jour vers la version 2.0 et VB.NET vers la

version 7.0, ce qui fait que CLR passe à sa version 2.0 comme
les langages ont été mis à jour.
Le développement se fait avec Visual Studio 2005 (8.0) et

le Framework est disponible avec Microsoft SQL Server 2005 et
BizTalk Server 2006.
Les nouveautés sont l’ajout de nouvelles API, le support

64 bit, des nouveaux Web contrôles pour ASP.NET et pour la
gestion de données.
Des possibilités de personnalisation comme les thèmes

ou les Web parts font leur apparition pour ASP.NET.
Version 3.0
La version 3.0 est intégrée par défaut sur Windows Vista

et Windows Server 2008. Il est disponible en téléchargement
pour Windows XP et Windows Server 2003.
Il inclut des nouvelles API mais ne constitue pas une mise

à jour majeure.
Le CLR reste inchangé. Cependant, on note quelques

apparitions importantes comme :
 WPF (Windows présentation foundation) remplaçant des

Windows Forms qui permet d’exploiter DirectX et d’utiliser
la 3D.
13
 WWF (Windows Workflow Foundation) qui permet la
construction de transaction ou tâches automatisées à l’aide
de workflows.
 WCF (Windows Communication Foundation)
anciennement Indigo ; WCF est un système de messagerie
orienté services qui permet aux programmes de
communiquer localement ou à distance.
 Les Windows CardSpace destinés à mémoriser de façon
sécurisée les informations numériques relatives à une
personne et fournit une interface unifiée pour le choix des
identités pour une transaction particulière.
Le développement se fait avec Visual Studio 2008

(version 9.0).
Silverlight fait son apparition en 2007 et permet d’exploiter

la CLR dans les navigateurs Web. On peut le considérer comme
une version allégée de WPF. Il est ensuite mis à jour vers la
version 2.0 et 3.0.
Version 3.5
Cette version est sortie le 19 novembre 2007. C’est un

changement mineur puisque cette version utilise toujours le CLR
2.0. On voit l’apparition de LINQ (langage Integrated Query) qui
ajoute des capacités d’interrogation sur les Data, des
Collections, du XML ou des DataSets. Elle intègre également le
Framework AJAX.NET pour ASP.NET.
La version 4.0 est sortie en même temps que Visual

Studio 2010 le 13 avril 2010. C’est un changement majeur car le
CLR a été changé en version 4.0 (et non 3.0).
 Traitement parallèle des informations (utilisation des multi-

cœurs) ;
 C# passe à la version 4.0 et VB.NET, quant à lui, à la
version 10.0 ;
14
 ASP.NET et Silverlight passent à la version 4.0 ;
 Le support du IronPython, du IronRuby et du F# (nouveau
langage destiné à la recherche) font leur apparition ;
 Nouveaux assembly ;
 Nouveaux types.
Version 4
Le 29 septembre 2008, Microsoft a annoncé que la

prochaine version du Framework .Net se nommerait .NET
Framework 4.0. Bien que tous les détails exacts n'aient pas été
communiqués, certaines directions de la compagnie ont alors été
rendues publiques.
L'une de ces directions était notamment le traitement
parallèle de l'information, applicable aux systèmes multi-core
ou distribués. Dans cette optique, ils prévoyaient de publier la
technologie PLINQ (Parallel Language Integrated Query), une
implémentation de la bibliothèque LINQ, qui exécute les
requêtes en tirant profit des capacités parallèles du système.
Début 2010, le .Net Framework 4.0 est disponible dans sa
version 4.0.30319 pour plateformes Windows XP SP3, Windows
Server 2008, Windows Vista et Windows 7.
Microsoft a également annoncé sa volonté d'inclure le .NET
Framework et ASP.NET dans la version « Server Core » du
système d'exploitation qui suivra Windows Server 2008.
Version 4.5
Inclus dans Visual studio2012 et installé par défaut sur Windows

10.
Nota :
Le Framework.net a suffisamment évolué. Pendant que

nous éditons cet ouvrage, il est dans la version 4.8.1 ; son
évolution est due par l’avancée exponentielle des systèmes
d’exploitation Windows, Windows Server et le Visual studio.
15
De façon simpliste, un Framework, dans notre cas, le
Framework.NET de Microsoft est une sorte d’immense
bibliothèque informatique contenant des outils qui vont faciliter la
vie du développeur. Le Framework.NET est compatible avec le
Visual Basic et d’autres langages tels que le C#, F#, le J# etc.
II. Visual basic
2.1. Notions
Visual Basic (VB) est un langage de
programmation événementielle de troisième génération ainsi
qu'un environnement de développement intégré, créé
par Microsoft pour son modèle de programmation COM.
Visual Basic est directement dérivé du BASIC et permet

le développement rapide d'applications, la création d'interfaces
utilisateur graphiques, l'accès aux bases de données en utilisant
les technologies DAO, ADO et RDO, ainsi que la création de
contrôles ou objets ActiveX.
Il s’est développé à partir du langage BASIC (Beginner's

All purpose Symbolic Instruction Code) qui fut créé dans les
années 60 par des chercheurs de l'Université de Darmouth en
Nouvelle-Écosse (John G. Kemeny et Thoams E. Kurtz).
Lors de sa création, le langage BASIC était destiné aux

débutants en programmation, d'où le mot beginner. Avec
l'apparition des premiers ordinateurs domestiques au début des
années 80, Bill Gates et Paul Allen adaptèrent le langage BASIC
aux micro-ordinateurs de type PC. Ils fondèrent alors, la société
Microsoft afin de commercialiser ce langage.
Les premiers PC incluaient une version du langage Basic

dont la première fût GWBASIC, suivie de QuickBasic et
finalement QBasic, toutes ces versions étaient utilisables sous
DOS. Le langage BASIC avait pour but d’aider les gens à
16
apprendre la programmation. Son utilisation très répandue
conduisit à de nombreuses améliorations.
La dernière mise à jour de Visual Basic est la version 6.0,

sortie en 1998. Le support étendu Microsoft a pris fin en 2008. À
partir de la version 7, le Visual Basic subit des changements
substantiels le rapprochant de la plate-forme « dot Net », et qui
amènent Microsoft à le commercialiser sous le nom de Visual
Basic .NET.
VB.NET est le successeur désigné de Microsoft à Visual

Basic 6.0, et fait partie de la plate-forme Microsoft .NET. Celui-ci
se compile et s’exécute sur l'architecture .NET(le framework
.NET).
Nota : Visual Basic .NET n’est pas rétrocompatible avec

VB6. Un outil de conversion existe, mais pour de nombreux
projets, la conversion automatique est impossible.
2.2. Fonctionnalités
Visual Basic a été conçu pour être facile à apprendre et à

utiliser. Le langage permet de créer des applications
graphiques de façon simple, mais également de créer des
applications véritablement complexes.
Programmer en VB est un mélange de plusieurs tâches,

comme disposer visuellement les composants et contrôles sur
les formulaires, définir les propriétés et les actions associées à
ces composants, et enfin ajouter du code pour ajouter des
fonctionnalités.
Comme les attributs et les actions reçoivent des valeurs

par défaut, il est possible de créer un programme simple sans
que le programmeur ait à écrire de nombreuses lignes de code.
Les premières versions ont souffert de problèmes de
performance, mais avec l'apparition d'ordinateurs plus rapides et
17
grâce à la compilation en code natif, ce problème de
performance s'est estompé.
Bien que les programmes puissent être compilés en code

natif depuis la version 5, ils requièrent toujours pour fonctionner
la présence du moteur d'exécution ou runtime, pour une taille
d’environ 2 MB. Ce moteur d'exécution est inclus par défaut
dans Windows 2000 et versions ultérieures sous formes de
bibliothèques dynamiques. Pour les versions précédentes
de Windows, le moteur d'exécution doit être distribué avec
l’exécutable lui-même.
III. Prise en main de Visual Basic.NET
3.1. Installation de Visual basic 2012 Ultimate
Pour installer VB.Net, peu importe la version de Visual

Studio (10,12, 15, etc), il suffit de :
Double-cliquer sur le fichier « Setup.exe » contenu

dans le dossier Visual Studio. Après la boite de dialogue ci-après
apparait et cliquez sur le lien « Installer Microsoft Visual Studio
».
Après le premier chargement une autre fenêtre apparait,

vous demandant d’accepter les conditions d’utilisation de la
licence
18
Après avoir accepté les conditions d’utilisation de la

licence, la fenêtre ci-dessous apparait avec un bouton suivant.
19
Ensuite, la fenêtre ci-après apparait, vous suivrez pas à
pas les étapes de l’installation en lisant des recommandations
jusqu’à atteindre la page de fin d’installation et enfin cliquer sur
« Terminer ».
3.2. Lancement et activation de Visual Studio
Au premier lancement, une boite de dialogue apparait,

vous demandant de choisir les paramètres d’environnement par
défaut. MS Visual Studio comprend les paramètres de
développement : web, généraux, Visual basic, C#, C++, Visual
F# et de gestion des projets. Pour notre cas, nous allons opter
pour « paramètres de développement Visual Basic »
Pour son activation, il suffira tout simplement de cliquer

tour à tour sur le menu « Aide », « inscrire le produit » ; une boite
de dialogue apparait, dans laquelle on placera la clé d’activation
et cliquer sur « Activer ».
3.3. Environnement de Développement Intégré
L’environnement de développement intégré de Visual

Basic.NET permet de créer, exécuter et déboguer des
programmes Windows dans une seule application.
Ainsi, au sein même du programme VB, vous pouvez :
 Ecrire votre programme source ;

 Compiler votre code source;
 Corriger vos erreurs de syntaxe grâce à l’intégration de
l’éditeur et du compilateur ;
 Faire tourner l’exécutable issu de la compilation du code
source ;
 Exécuter le programme instruction par instruction, évaluer
le contenu des variables…
20
Pour accéder à l’EDI de Visual basic, il propose tout
d’abord la page de démarrage ci-après qui permet d’avoir des
options d’aide en ligne et celles liées au projet.
Cliquez sur « Nouveau projet », ce lien affiche la boite de

dialogue où « Application Windows Forms » est sélectionné par
défaut et permet
21
Également de spécifier la version du Framework utilisée ;

par défaut le Framework 4.5 est sélectionné. Il est utile de
spécifier le nom de la solution et cliquer enfin sur OK.
Après la fenêtre ci-dessous apparaitra :

22
a) La barre de titre
Elle reprend tout simplement le nom de l’application, suivi

du nom de logiciel qui est Microsoft Visual Studio.
b) La barre de Menu
Elle reprend toutes les tâches effectuables en Visual

basic.NET
c) Barre d’outils standards
Cette barre regorge tous les composants Visual basic.Net

les plus utilisés. Son affichage est à paramétrer selon le cas.
Pour l’afficher, cliquer sur « Affichage », « Barre d’outils » et enfin
« Standard ».
d) Explorateur de serveurs
C’est cette fenêtre qui gère les connexions de données,

SharePoint et les serveurs. On s’en sert pour créer des bases de
données SQL Server interne, attacher les bases de données
SQL Server externe au serveur.
23
e) Boite à outils
C’est une collection d’outils grâce auxquels nous

disposons les contrôles sur la feuille. Vous avez la possibilité
d’ajouter et de retirer les composants.
24
f) Fenêtre de propriétés
La fenêtre des propriétés va nous permettre, en mode

conception, de modifier les propriétés des objets.
Une feuille peut contenir plusieurs contrôles. Lorsqu’un

contrôle est sélectionné, la fenêtre des propriétés affiche toutes
les propriétés qui lui sont liées.
25
g) Explorateur de solutions
L’explorateur de solution présente la solution active

comme conteneur logique d’un ou de plusieurs projets et des
éléments qui leur sont associés. Il permet de voir et d’accéder au
contenu du projet en cours d’utilisation.
26
h) L’éditeur de codes
C’est une fenêtre ou l’endroit nécessaire d’écriture de

codes. Pendant ladite écriture, VB.net souligne toutes les erreurs
en bleu.
i) Structure du document
Elle indique la structure du document.
3.4. Etude des contrôles et propriétés
3.4.1. Les contrôles :
Le VB.NET regroupe les contrôles relativement à leur

fonctionnement utile. Certes nous avons :
1. Le Groupe « Tous les Windows Forms »

2. Le Groupe « Contrôles communs »
3. Le Groupe « Conteneurs »
4. Le Groupe « Menus et barres d’outils »
5. Le Groupe « Données »
6. Le Groupe « Composants »
7. Le Groupe « Impression »
8. Le Groupe « Boite de dialogue »
9. Le Groupe « interopérabilité WPF »
10. Le Groupe « Création de rapports »
11. Le Groupe « Visual Basic Power packs »
12. Le Groupe « Général»
Ci-dessous la représentation de différents groupes de

contrôles :
27
Dans toutes les catégories précitées, nous remarquons

que la catégorie de « Tous les Windows Forms » sera la plus
sollicitée car elle comprend les contrôles par défaut de VB.NET
et gère la plupart des contrôles des autres catégories. Nous
pouvons citer entres autres :
 Background Worker : exécute une opération sur un

thread séparé.
 Binding Navigator : Fournit une interface utilisateur
pour la navigation et la manipulation de contrôles liés
aux données sur le formulaire.
28
 Binding Source : Encapsule une source de données
pour un formulaire et offre de fonctionnalité de
navigation, de filtrage, tire et mise à jour.
 Button: déclenche un événement lorsqu’on clique
dessus.
 Checkebox : permet à l’utilisateur de sélectionner ou de
supprimer l’option associée.
 Checkedlistbox: Affiche une liste d’éléments avec une
case à cocher placée à gauche de chaque élément.
 Colordialog: Affiche les couleurs disponibles avec un
contrôle qui permet à l’utilisateur de définir des couleurs
personnalisées.
 Combobox: Affiche une zone de texte modifiable avec
une liste déroulante de valeurs autorisées.
 ContextMenuStrip: Affiche le menu contextuel
lorsqu’un click-droit est effectué sur le contrôle associé.
 DataGrid View: Affiche des lignes et des colonnes sur
une grille que vous personnalisez.
 DataSet: Représente un cache de donnée en mémoire.
 DateTimepicker: Permet de sélectionner une date et
une heure, et afficher une date et une heure au format
spécifié.
 DirectorEntry: Encapsule un objet ou un nœud dans
une hiérarchie Active Directory.
 DirectorSeacher: Exécute des requêtes sur Active
Directory.
 DomaineUpDown: Permet d’afficher une chaine de
valeur unique l’lorsqu’on clique sur les boutons
déroulant de contrôle.
 ErrorProvider: Fournit une interface pour indiquer
qu’une erreur est associée à un contrôle dans un
formulaire.
 EventLog: Fournit une interaction avec des journaux
des événements Windows.
29
 FileSystemWatcher: Analyse les notifications de
modifications du système de fichier et déclenche les
évènements l’lorsqu’un répertoire ou un fichier est
modifié.
 FlowLayoutPanel: gère la disposition des composants
et leur applique une mise en page automatiquement
fluide.
 FoldeerBrowserDialog: Permet à travers une boite de
dialogue de sélectionner un dossier.
 FontDialog: Permet de choisir à travers une boite de
dialogue une police parmi celles installées sur
l’ordinateur.
 GroupBox: Affiche un frame autour d’un groupe de
contrôles avec une légende facultative.
 HelpProvider: Permet à son collection d’image qui est
généralement utilisées par d’autres contrôles.
 HscrollBar: Permet à son composant parent de faire
défiler le contenu horizontalement.
 ImageList: gère une collection d’images qui sont
généralement utilisées par d’autres contrôles.
 Label: Fournit un texte descriptif pour un contrôle.
 LinkLabel: Affiche un contrôle label qui prend en
charge les fonctionnalités d’un lien hypertexte, la mise
en forme et le suivi.
 ListBox: Permet de sélectionner les éléments à travers
une liste.
 ListView: Affiche une collection d’éléments dans l’un de
cinq modes d’affiches.
 Masked Textbox: utilise un masque
 MenuStrip : Affiche des commandes et des options
d’applications groupées par fonctionnalité
 MessageQueue: Donne une file d’attente sur un
serveur message queue
30
 MonthCalendar : Affiche une icône dans la zone de
notification pendant l’exécution.
 NumériqueUpDown : Affiche une valeur numérique qui
peut être incrémenté ou décrémenté en cliquent sur les
boutons déroulant du contrôle.
 OpenfileDialog : Permet d’ouvrir un fichier à travers
une boite de dialogue.
 PageSetupDialog : Affiche une boite de dialogue qui
permet de modifier les paramètres d’impression liés à la
page notamment les marges et l’orientation de la page.
 Panel: Permet de grouper de collection de contrôles.
 PerformanceCounter: Présente un composant de
concepteur de performance Windows.
 PictureBox : Affiche une image.
 Printdialog : Permet à l’utilisateur de sélectionner une
imprimante et de choisir d’autres options d’impression
par le truchement d’une boite de dialogue.
 PrintDocument : définit un objet qui renvoie les sorties
vers une imprimante.
 PrintPreviewControl: Représente uniquement la partie
d’un aperçu avant impression.
 PrintPreviewDialog : Montre un aperçu qui
ressemblera à un document associé à une imprimante.
 Process : Fournit l’accès à des processus locaux et
distants.
 ProgressBar : Affiche une barre de remplissage qui
indique la progression d’une opération.
 ProppertyGrid : Fournit une interface qui permet de
parcourir les propriétés d’un objet.
 RadioButton : Permet de sélectionner une option
unique à partir d’un groupe de choix.
 RichTextBox : Fournit de fonctionnalité avancée
d’entrée et d’édition de textes, comme la mise en forme
des caractères et des paragraphes.
31
 SaveTextBox : Permet de sélection un emplacement
pour l’enregistrement d’un fichier.
 SerialPort : Représente une source de port série.
 ServiceContrôle : Fournit une possibilité de connexion
d’interrogation et de la manipulation de service
Windows.
 SplitContainer : divise la zone d’un conteneur en deux
panneaux redimensionnables auxquels vous pouvez
ajouter des contrôles.
 Splitter: Sépare la zone d’affichage d’un centenaire en
deux panneaux redimensionnables auxquels vous
pouvez ajouter des contrôles.
 Statutstrip: Affiche des informations sur les objets
visualisés, les composants d’objet.
 TabControl: gère et affiche une collection d’onglets
apparentés contenant des composants et des contrôles.
 TabletLayoutPanel : Manipule la disposition de ses
composants et le réorganise automatiquement sous
forme d’un tableau.
 TextBox: Permet d’entrer du texte et fournit des
fonctions d’édition multi ligne et de masquage de mot de
passe.
 Timer : Déclenche un événement à des intervalles de
temps définis.
 ToolStrip : Fournit des barres d’outils et d’autres
éléments de l’interface utilisateur qui prennent en
charge de nombreuses options d’apparence, et gèrent
le déplacement de capacité et le reclassement des
éléments au moment de l’exécution.
 ToolStripContainer : Fournit des panneaux sur chaque
côté du formulaire susceptibles de contenir un ou
plusieurs contrôles ToolStrip, StatutsStrip et MenuStrip.
 ToolTip : affiche les informations lorsque l’utilisateur
passe le pointeur sur le contrôle associé.
32
 TrackBar : Permet de choisir entre une plage de valeurs
en faissant glisser une petite barre le long d’une autre
barre.
 TreeView : Affiche une collection hiérarchique
d’éléments étiquetés qui contiennent éventuellement
une image.
 VScrollBar : Permet au composant parent de faire
défiler le contenu verticalement.
 WebBrowser : Permet de parcourir les pages web sur
votre formulaire.
La plupart de composants qui se figurent dans cette

catégorie sont originaires de tel ou tel autre groupe de
composants. Notons aussi que la boite à outil de Visual
Basic.NET n’est statique.
C’est alors Visual Basic.NET offre la possibilité d’insérer

d’autres contrôles en utilisant la démarche ci-après :
 Faire un click-droit à l’espace vide de la boite à outil ;

 Cliquer sur choisir un élément ;
 Sélectionner l’élément concerné et cliquer enfin sur Ok.
33
3.4.2. Les propriétés communes aux contrôles en VB.NET
Propriétés Description
Spécifie le nom du contrôle. La fenêtre des

propriétés affiche la propriété Name entre
Name
parenthèse afin qu’elle apparaisse en premier
lieu vu son importance dans la programmation
Spécifie la couleur de l’arrière-plan du contrôle.

Backcolor Vous choisissez cette valeur dans l’une de trois
palettes.
Détermine si le contrôle est entouré d’une

Borderstyle
bordure
Définie l’accessibilité du contrôle par

Enabled l’utilisateur en l’octroyant soit la valeur True ou
False selon les cas
Affiche une boite de dialogue dans laquelle

vous paramétré pour les textes d’une contrôle
Font
divers attributs de police, tels que le style ou la
taille.
Spécifie la couleur de premier plan du

contrôle. Vous choisissez cette couleur dans
Forecolor
l’une des palettes en ouvrant la liste déroulante
de la propriété.
Size Détermine la taille du contrôle
Text Contient le texte sur le contrôle
Détermine si le texte du contrôle, tel qu’un

label ou un bouton de commande, apparaît
TextAlign
comme aligné à gauche, centré ou aligné à
droite.
34
Détermine la visibilité du contrôle par
Visible
l’utilisateur selon les cas.
Pour la feuille, nous ferons appel à quelques propriétés

importantes :
MaximizeBox : de par ses valeurs True et

False, détermine si un formulaire dispose d’un bouton de
réduction au coin supérieur droit de la barre de légende.
MinimizeBox : à l’instar de la précédente,
détermine si un formulaire dispose d’un bouton de
réduction au coin supérieur droit de la barre de légende.
StarPosition : Détermine la position d’un
formulaire lorsqu’il s’affiche pour la première fois.
WindowState : détermine l’état visuel initial du
formulaire.
Quelques propriétés de paramétrage du contrôle TextBox.
 Locked : Détermine si le contrôle peut être

redimensionné ou déplacé par l’utilisateur.
 MaxLenght : Spécifie le nombre maximal des
caractères qui peuvent être entrés dans le contrôle
d’édition.
 Multiline : Contrôle si le texte du contrôle
d’édition peut s’étendre sur plusieurs lignes.
 Passwordchar : indique le caractère à
afficher pour la saisie du mot de passe pour les
contrôles d’édition sur ligne.
 Readonly : Contrôle si le texte du contrôle
d’édition peut être modifié ou non.
 TextAlign : Indique la façon dont le texte doit
être aligné pour les contrôles d’édition.
35
CHAPITRE III
ELEMENTS DE BASE DE PROGRAMMATION
0. Introduction
Rappelons-le, la conception d’un programme repose sur
l’usage des algorithmes. Un algorithme est une activité
intellectuelle qui se base sur un certain nombre des concepts que
le programmeur doit maitriser et traduire dans un langage de
programmation. Il va sans dire que l’algorithme est difficile,
beaucoup plus difficile que sa traduction en programme. Cela
requiert la créativité et l’intuition.
I. Variable
1.1. Notions
Une variable est un objet dont le contenu peut être modifié

par une action durant l’exécution d’un programme. Elle est
caractérisée par un nom fixe, un type fixe et une valeur variable
selon les spécifications du programmeur.
Le nom d’une variable est appelé identificateur. Une

variable peut recevoir une valeur à l’exécution du programme
par, entre autres, une affectation ou une lecture. Le type d’une
variable est associé à son nom par une déclaration de type qui
peut être explicite ou implicite.
Donc en résumé, une variable en informatique est un

triplet (identificateur, type, valeur) où seul le troisième élément
est variable. Avant de pouvoir utiliser une variable, il est
nécessaire de la déclarer, c’est-à-dire d’associer la variable à un
emplacement de la mémoire et de spécifier son type.
Une variable est une zone mémoire dans laquelle on

affecte les données et qui varient au cours de traitement. Elle
possède un nom, un type et une valeur.
Syntaxe : variable nom-variable : type ;

36
Types de variables
Lorsqu’on parle de type de variable, on fait allusion à la

nature donc des variables. Ainsi, nous distinguons les types des
variables ci-après :
Type Plage des valeurs Taille

Short (entier court) -32 768 à 32 767 2 octets
Integer (entier) - 2 147 483 648 à 2 147 483 647 4 octets
-9 223 372 036 854 775 808 à
Long (entier long) 8 octets
-9 223 372 036 854 775 807 à
-3,4028235E+38 à -1,401298E-45
Single (nombre à
pour les valeurs négatives
virgule flottante 4 octets
1,401298E-45 à 3,4028235E+38 pour
simple précision)
les valeurs positives
-1,79769313486231570E+308 à -
Double (nombre à 4,94065645841246544E-324
virgule flottante pour les valeurs négatives
8 octets
double -4,94065645841246544E-324 à -
précision) 1,79769313486231570E+308
pour les valeurs positives
+/- 79 228 162 514 264 337 593
543 950 335 sans chiffre décimal
12
Decimal +/- 7,922 816 251 426 433 759 354 395
octets
033 5
avec 28 positions à droite de la virgule
Byte 0 à 255 1 octet
Boolean True / False 2 octets
String de 0 à environ 230 caractères
Char (caractère
1 caractère 2 octets
unique)
Date 01/01/1 à 31/12/9999 8 octets
4 octets
Object référence à un objet
+ objet
37
1.2.2. Déclaration d’une variable
La déclaration d'une variable doit donc prendre en compte

deux aspects à savoir : un nom et le type de données qu'elle peut
contenir. Une variable est utilisable dans le bloc ou elle est
définie.
Sa syntaxe est la suivante :
Dim Nom_variable As Type_Variables
Exemple:
Dim NomClient As String
Public TVA as double
Normalement, les variables déclarées dans une procédure

sont détruites lorsqu'on quitte la procédure; si on veut les garder
on peut les déclarer avec Static au lieu de Dim comme:
Static A As Integer
Par défaut, le compilateur VB considère que toute variable

qui apparaît doit avoir été déclarée. Toutefois, si on ajoute la
ligne Option Explicit Off, VB sera permissif : il nous permet
d'utiliser des variables sans les déclarer. Ceci n'est pas
recommandé, il est préférable de laisser la valeur par défaut et
toujours déclarer les variables.
1.2.3.Portée des variables

a. Variable locale
Une variable est dite locale lorsqu’elle est déclarée dans

une procédure avec l'instruction Dim; 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;
elle est disponible pour toutes les autres procédures de la feuille.
38
b. Variable globale
Une variable est globale si on la déclare dans la section

General/Declarations d'un module (et non d'une feuille), avec
l'instruction Public au lieu de Dim, et elle est disponible à
l'application toute entière.
2. Les constantes
Une constante est une donnée fixe qui ne varie pas durant
l’exécution d’un programme. Elle est caractérisée par son nom
et sa valeur (fixe). Son objectif est d’éviter d’utiliser une valeur
d’une manière directe.
Imaginons qu’un programme utilise la valeur 3.14 une

vingtaine de fois et qu’on veut modifier cette valeur par une autre
valeur plus précise 3.14159. Dans ce cas, on est amené à
modifier toutes les occurrences de 3.14. Par contre, si on utilise
une constante Pi=3.14 on modifiera une seule fois cette
constante.
Syntaxe : constante nom-constante = valeur
On la déclare avec le mot clé Const.
Exemple : Const ValeurPi = 3.1416
3. Les tableaux
3.1. Définition
Un tableau est une structure de données contenant un

groupe de valeurs de même type. Par exemple, un tableau
accepte un groupe de valeur string, un groupe de valeur integer
ou un groupe de valeur boolean. Tant que les valeurs sont du
même type, elles peuvent être placées dans le même tableau.
Les tableaux sont caractérisés en VB.NET par des

parenthèses qui peuvent être placés après l’identificateur, et si
possible avec l’initialisation du nombre d’éléments qui les
39
constituent. La déclaration d’un tableau ne lui alloue pas de
mémoire. Dans la plupart de langages, la taille du tableau n’est
spécifiée qu’au moment de son utilisation pour que la mémoire
lui soit allouée.
2.2. Tableau à une dimension
La syntaxe de sa déclaration est la suivante:
Dim nomTableau(n) as type
ou Dim nomTableau () as type =New type(n) {}.
n est l'indice du dernier élément de tableau. La syntaxe

nomTableau (i) désigne la donnée de la case numéro i avec 0 ≤
i ≤ n. Si i n'appartient pas à l'intervalle [0,n], on va avoir une erreur
( appelée exception en VB).
On peut initialiser un tableau lors de sa déclaration. Dans

ce cas, on n'a pas besoin d'indiquer sa taille :
Dim entiers() As Integer = {0, 10, 20, 30}
Les tableaux ont une propriété Length qui est le nombre

d'éléments du tableau.
Cette propriété est surtout utilisée pour parcourir les

éléments d'un tableau.
Exemple:
Module TesterTableau
Sub Main()
Dim Tab(5) As Integer
'remplir le tableau
For i = 0 To Tab.Length - 1
Tab(i) = i * 10
Next
'affichage
40
Msgbox( "Taille du tableau: " & Tab.Length)
For i As Integer = 0 To Tab.Length - 1
Msgbox ( "Tab(" & i & ")=" & Tab(i))
Next
End Sub
End Module
Exécution
Taille du tableau: 6
Tab(0)= 0
Tab(1)= 10
Tab(2)= 20
Tab(3)= 30
Tab(4)= 40
Tab(5)= 50
Exercice :
Ecrire le code VB.NET permettant de demander les 4

matières le plus préférées pour un étudiant, les stocker dans un
tableau puis les afficher.
Solution:
Dim TabMatiere(3) As String
For i = 0 To TabMatiere.Length - 1
MsgBox("matière préférée n°" & i + 1)
TabMatiere(i) = InputBox("saisir la matière")
Next
MsgBox("Vos matières préférées sont: ")

41
For i As Integer = 0 To TabMatiere.Length - 1
MsgBox(i + 1 & ": " & TabMatiere(i))
Next
2.3. Tableau à plusieurs dimensions
On peut déclarer des tableaux de deux, trois, quatre,

dimensions ou plus. Un tableau à deux dimensions est déclaré
comme suit :
Dim nomTableau(n,m) as Type
ou Dim nomTableau(,) as Type=New Type(n,m) {}
ou n+1 est le nombre de lignes, m+1 le nombre de colonnes.

La syntaxe
Tableau(i,j) désigne l'élément j de la ligne i de Tableau.
On peut initialiser le tableau à deux dimensions comme suit

:
Dim tabReels( , ) As Double = {{0.5, 1.7}, {8.4, -6}}
Le nombre de éléments dans chaque dimension peut être

obtenue en utilisant la méthode GetLength(i) ou i=0 représente
la dimension correspondant au 1 er indice, i=1 la dimension
correspondant au 2 ième indice, …Voici un programme
d'exemple :
Dim tab( 2, 1) As Integer '3 lignes et 2 colonnes
For i As Integer = 0 To tab.GetLength(0) – 1 'i varit de 0à2
For j As Integer = 0 To tab.GetLength(1) – 1 'j varit de 0à1
tab(i, j) = i * 10 + j
Next
42
Next
For i As Integer = 0 To tab.GetLength(0) - 1
For j As Integer = 0 To tab.GetLength(1) - 1
Msgbox ( "tab(" & i& "," & j& ")=" & tab(i, j))
Next
Next
Execution:
tab(0,0)= 0
tab (0,1)= 1
tab (1,0)= 10
tab (1,1)= 11
tab (2,0)= 20
tab (2,1)= 21
Il est possible d'afficher un tableau grâce à une ListBox
Exemple : Affichage de 10 prénoms saisis
Dim TabNom(1 To 10) As String
Dim I As Integer
For I = 1 To 10
TabNom(I)=InputBox("Entrer prénom N° " & I)
Next
LstNom.Clear 'liste vide
For I = 1 To 10
43
LstNom.AddItem TabNom(I) 'ajout d'un élém. dans la liste
Next
Nota : nous reviendrons sur les exercices liés aux tableaux

après les boucles.
4. Identificateur
L’identificateur est le nom choisi pour appeler un élément
(une variable ou une constante). Le Visual basic accepte tout
identificateur correct. Pour cela, il est important d’utiliser un
terme simple du langage modifié pour répondre aux exigences
suivantes :
 Un identificateur doit commencer par une lettre ;

 Il peut contenir tous les caractères alphanumériques
(lettres ou chiffres), des caractères de soulignement (_) ou
des symboles monétaire Unicode (£ ou $), mais pas
d’autres caractères spéciaux ;
 Il doit être constitué d’un seul mot (sans espace ni tiret).
 Ne doit pas être un mot clé (mot réservé).
Nota : Visual basic n’est pas sensible à la casse, c’est-à-dire ne

différencie pas les majuscules des minuscules.
5. Commentaires
Ils ne sont pas pris en compte par le compilateur ni inclus
dans le pseudo code. 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.
Exemple :
Rem ceci est un commentaire

44
' Ceci est un commentaire
6. Mots clés
Les mots clés sont des mots réservés. Voici quelques

mots clés de VB:
And, As, ByRef, ByVal, Call, Case, Class, Const, Dim, Do,
Else, ElseIf, End, Exit, False, For, Function, GoTo, If, Is, Loop,
Me, Module, Next, Not, Nothing, Option, Or, Private, Public,
Resume, Select, Step, Sub, Then, To, True, Until, While …
Il sied de noter que ces mots clés ou mots réservés ne

peuvent en aucun cas servir d’identificateur.
7. Opérateurs
Un opérateur est un symbole ou signe utilisé entre deux

termes (nombres, variables, constantes) pour effectuer une
opération.
Il existe les types d’opérateurs suivants :
a. Opérateurs arithmétiques
Opérateur Définition
() Parenthèse
^ Exposant
- Négation
* Multiplication
/ Division
Mod Modulo
+/- addition/soustraction
\ Division entière
Nota : Il existe diverses fonctions mathématiques qui sont
définies dans une classe .NET appelée Math. Voici quelques-
unes:
45
▪ Sqrt (x) racine carrée
▪ Pow ( x, y ) x à la puissance y (x>0)
▪ Abs(x ) valeur absolue
▪ Cos(x) Cosinus
▪ Sin(x) Sinus
b. Opérateurs de comparaison
Opérateur Définition
< inférieur à
> supérieur à
<= inférieur ou égal à
>= supérieur ou égal à
= égal à
<> différent de
c. Opérateurs logiques
Les opérateurs logiques sont définis à partir du calcul des

propositions en suivant les règles d'une algèbre particulière,
algèbre logique ou algèbre de BOOLE.
Une proposition est l'énoncé d'une propriété telle que

l'on peut toujours lui affecter la valeur vrai ou la valeur faux.
a) Not
L'opérateur Not renvoie True quand la condition est

False sinon False :
46
If Not (1 = 2) Then
MessageBox.Show("(1 = 2) est False. Donc Not False = True")
End If
b)And
And retourne True quand ses deux opérandes sont True,

sinon False. Il les évalue toutes les deux avant de se prononcer.
If (1 = 1) And (2 = 2) Then
MessageBox.Show("(1 = 1) est True. (2 = 2) est True. Donc

True And True = True")
End If
c) Or
Or est True quand au moins l'une de ses opérandes

est True, sinon False. Il évalue les deux (comme And).
d)Xor
Xor ("ou exclusif", de l'anglais "exclusive or") est True

uniquement si l'une des deux opérandes est True, mais pas
quand elles le sont toutes les deux.
d. Opérateur d’affectation
Les instructions d'affectation attribuent une valeur ou

une expression à une variable ou à une constante (=).
e. Opérateur de concaténation
Le Visual basic admet l'opérateur + (plus) et & (esperluette)

comme opérateurs de concaténation de chaines de caractères.
Le signe & est utilisé pour une concaténation de chaines:
Exemple 1
47
Dim alpha, beta, chaine As String
alpha = "Chaine divisée "
beta = "en deux parties"
chaine = alpha + beta
Exemple 2
Dim Pren As string
Pren= " Ethan "
Dim Nom As string
Nom= "Missway"
Msgbox (Pren+" "+ Nom)
Le résultat après exécution donnera Ethan Missway
8. Instructions
a. Instructions d’entrée
Les instructions d’entrée permettent d’entrer de données

dans les variables à partir du clavier. Visual basic utilise la
fonction « inputbox » pour ce faire.
Exemple : inputbox("Entrez un nom")
b. Instructions de sortie
Pour afficher le résultat à l’écran, Visual basic utilise le

mot clé « msgbox ».
Exemple
Msgbox ("Bonjour")
EXERCICES SUR LA SYNTAXE DE BASE

48
Exercice 1. Ecrire un programme qui permet de calculer et
d’afficher la somme et le produit de deux nombres a et b.
Résolution
Dim a, b, somme, produit As Integer

a = InputBox("Entrez la valeur de a")
b = InputBox("Entrez la valeur de b")
somme = a + b
produit = a * b
MsgBox("Le somme est de" & somme)
MsgBox("Le produit est de" & produit)
Exercice 2. Ecrire un programme qui lit un nombre puis calcule

et affiche son carré.
Résolution
Dim n, carré As Integer

n = InputBox("Entrez un nombre")
carré = Math.Pow(n, 2)
MsgBox("le carré vaut:" & carré)
Exercice 3. Ecrire un programme qui lit deux nombres a et b, puis

affiche dans a la valeur de b et dans b la valeur de a.
Résolution
Dim a, b, c As Integer
a = InputBox("Entrez la valeur de a")
b = InputBox("Entrez la valeur de b")
c=a
a=b
b=c
MsgBox("la nouvelle valeur de a est:" & a)
MsgBox("la nouvelle valeur de b est:" & b)
49
Exercice 4. Ecrire un programme permettant de saisir le nom de
l’utilisateur puis affiche à l’écran le texte Bonjour suivi du nom
saisi.
Résolution
Dim nom As String
nom = InputBox("Entrez un nom")
MsgBox("Bonjour" + " " + nom)
Exercice 5. Ecrire un programme qui calcule le delta d’une

équation du second degré.
Résolution
Dim a, b, c, delta As Double

a = inputbox("Entrez la valeur de a ")
b = inputbox("Entrez la valeur de b ")
c = inputbox("Entrez la valeur de c")
delta = (b * b) - (4 * a * c)
MsgBox(delta)
9. Procédures et Fonctions
Un programme devient très rapidement complexe dès que

le nombre de traitements augmente (entrées de données,
calculs, traitements divers, impression etc.). De plus, il est très
souvent vérifié que certains traitements sont répétitifs et donc
utilisés à différents endroits du programme. Il devient alors
judicieux d’isoler ces traitements et d’en faire des modules
distincts, ce qui nous amène à un des concepts de la
programmation structurée, qui est la décomposition d’une tâche
complexe en tâches élémentaires.
La modularité offre des avantages importants: Tout

d’abord, elle épargne la programmation redondante (répétée) du
même jeu d’instructions, pour les tâches à exécuter plus d’une
fois.
50
De plus, le recours au module de programme réduit de
façon appréciable la longueur d’un programme.
Il faut aussi retenir la clarté logique résultant de la

décomposition d’un programme en modules individuels et
concis. De tels programmes sont faciles à écrire et à déboguer.
En bref, pour alléger l’écriture du programme, il est

possible de rédiger des procédures qui sont appelées dans le
corps du programme et des fonctions personnalisées chargées
d’effectuer des calculs plus ou moins complexes.
a. Procédure
Une procédure est une suite ordonnée d’instructions qui

ne retourne pas de valeur. Elle est identifiée par son nom et elle
peut avoir des paramètres. Ces derniers sont des informations
reçues par la procédure. Sa syntaxe est la suivante :
Sub nom procédure (arguments)
instructions
End Sub
Pour appeler une procédure, on écrit:
Call NomProcédure (paramètre1, …, paramètreN)
NomProcédure paramètre1, …, paramètreN
Exemple
Call Remplissage(n, T)
Remplissage n, T
Illustration 1 : Ecrire une procédure qui calcule la somme

de deux nombres.
Résolution en Visual basic

51
Sub somme()
Dim x, y, som as double
x=inputbox("Entrez le premier nombre")
y=inputbox("Entrez le deuxième nombre")
som=x+y
Msgbox (som)
End sub
Illustration 2 : Ecrire une procédure qui calcule le produit et le

quotient de deux nombres.
b. Fonction
Une fonction est un sous-programme qui retourne une

valeur à partir de données qu’on lui apporte (les paramètres
d’entrée). Elle peut être aussi définie comme étant une partie
autonome d’un programme, réalisant une tâche précise, à
laquelle on transmet des valeurs lors de son appel et qui retourne
une valeur à la fin de son action. Elle se déclare comme suit :
Function nom-de-la-fonction (argument) as type
Dim déclarations des éventuelles variables LOCALES (ou

constantes via CONST)
Corps de la fonction (liste des instructions)
End Function
Si aucun type n’est spécifié, la fonction est de type Variant.
L'appel de la fonction est de la forme :
variable = NomFonction (paramètre1, …, paramètreN)
Exemple
52
max = ValeurMaximale (n, T)
c. Passage de paramètres
Il existe deux modes de Passage des paramètres :
Par valeur (ByVal) : le contenu de la variable ne sera pas

modifié en sortie du sous-programme. On travaille sur une
copie de la variable passée en paramètre.
Par référence (ByRef) : le contenu de la variable pourra être

modifié en sortie de sous-programme. On travaille sur l'adresse
de la variable passée en paramètre.
Les paramètres d'une fonction/procédure sont par défaut

passés par valeur : c'est à dire que la valeur du paramètre
effectif est recopiée dans le paramètre formel correspondant.
EXERCICES PRATIQUES sur la notion de fonction
Enoncé 1 : Ecrire un algorithme de fonction permettant de

calculer le delta.
TD : Traduire cet algorithme en Visual basic.
Résolution énoncé 1 en algorithme
// Déclaration de la fonction delta
Fonction Delta ( )
a, b, c, d : Entier
Lire a, b, c
d=(b*b)-(4*a*c)
Retourner d
Fin fonction
Résolution énoncé 1 en Visual basic

53
Function Delta ( )
Dim a, b, c, d as integer
a=inputbox("Entrez la valeur de a ")
b=inputbox("Entrez la valeur de b ")
c=inputbox("Entrez la valeur de c")
d=(b*b)-(4*a*c)
msgbox(d)
End function
54
CHAPITRE IV
STRUCTURE DE CONTROLE
0. Introduction
Il existe en programmation des structures de contrôle de
séquences qui peuvent être conditionnelles ou répétitives. On
parle de la structure de contrôle conditionnelle lorsque pour
l’exécution d’un bloc d’actions, une condition est émise pour
permettre la prise de décision. La séquence répétitive n’est rien
d’autre que la boucle c.à.d. un ensemble d’instructions se
trouvant dans un même endroit du programme et s’exécutant de
façon répétitive.
I. Structures conditionnelles
Pour cela, il existe :
 La structure de contrôle conditionnelle simple

 La structure de contrôle conditionnelle alternative
 La structure imbriquée
1.1. Structure simple
La forme simple est la suivante:
Il s’agit à ce stade de tester si la condition est remplie et

d’exécuter le bloc d’instructions sans qu’il y ait un autre bloc
d’instructions en alternance.
Le formalisme de cette structure se présente comme suit :
If condition ou prédicat then
Bloc d’instructions
End if
Exemple : Accorder une prime de 50.000 FC à tous les

agents de sexe masculin.
55
Résolution
Sub prime()
Dim sexe as string
Sexe=inputbox("Veuillez saisir votre sexe")
If sexe= "M" then
Msgbox ("Votre prime est de 50.000 FC")
End if
End sub
1.2. Structure alternative
Les alternatives permettent de n’exécuter des instructions

que si une certaine condition est vérifiée. Dans ce registre, il est
nécessaire de pouvoir déclencher une séquence d'actions sous
certaines conditions.
D’où, le formalisme se présente comme suit:
If condition ou prédicat then
Bloc d’action 1
Else
Bloc d’actions 2
End if
Selon le résultat de l’évaluation d’une condition, on déclenchera

une action ou une autre ou une seule de deux. Une seule de
deux actions sera exécutée :
• Si la condition est vraie, bloc d’action1 sera exécuté.
• Si la condition est fausse, bloc d’action2 sera exécuté.

56
Le programme continuera en reprenant après End if.
Exemple : Accorder une prime de 50.000 FC aux hommes

et 25.000 FC aux femmes.
Résolution
Sub prime()
Dim sexe as string
Sexe=inputbox("Veuillez saisir votre sexe")
If sexe= "M" then
else
End if
End sub
1.3. Structure imbriquée
On parle de l’imbrication lorsqu’il y a plus de deux

alternatives c.à.d. on a dans la structure plus de deux possibilités
dont chacune représente une condition. Ainsi, deux possibilités
s’offre pour imbriquer une structure conditionnelle en Visual
basic.NET : soit avec l’instruction Elseif ou encore avec
l’instruction Select case.
a) Instruction if ….. Then ….. elseif …… then ….

Else …. End if
Cette construction permet d’effectuer de multiples

conditions à l’intérieur de la structure if….. then.
La forme imbriquée est reprise ci-dessous :

57
If expression_booléenne Then
instructions_si_vrai
Elseif expression_booléenne Then
etc.
Endif
Il est à noter que dans ce cas If/ElseIf permet de tester

plusieurs conditions dans l'ordre séquentiel programmé.
Exemple :
Dim x As Integer
Dim y As Integer
'...
If x = y Then
MsgBox("x = y")
ElseIf x < y Then
MsgBox("x < y")
Else
MsgBox("x > y")
End If
b) Select case…Case…End Select
La structure de cas est plus efficace qu'une série de If. On

l'utilise lorsqu'on doit exécuter plusieurs comparaisons. C'est
58
beaucoup plus facile de suivre la logique d'un Select Case que
de nombreux If ... Else ... imbriqués.
La règle de base: du moment que vous avez plus que 2

comparaisons, utilisez un Select Case. Ce procédé permet de
raccourcir la syntaxe de longues chaines If/ElseIf/.../ElseIf/Else.
Exemple
Dim CPU as Integer
Select Case CPU
Case 0
MsgBox "Aucun processeur"
Case 1
MsgBox "Un processeur"
Case 2
MsgBox "Deux processeurs"
Case 4
MsgBox "Quatre processeurs"
Case 3, 5 To 8
MsgBox "3, 5, 6, 7, ou 8 processeurs"
Case Else
MsgBox "> 8 processeurs"
End Select
59
EXERCICES SUR LES STRUCTURES CONDITIONNELLES
Exercice 1. Ecrire un programme qui saisit un nombre puis verifie

si ce nombre est pair ou impair.
Resolution
Dim n As Double
If n Mod 2 = 1 Then
MsgBox("nombre impair")
Else
MsgBox("nombre pair")
End If
Exercice 2. Ecrire un programme qui demande trois noms à

l’utilisateur et l’informe ensuite s’ils sont rangés ou non dans
l’ordre alphabétique.
Résolution
Dim a, b, c As String
a = InputBox("Entrez le premier nom")
b = ("Entrez le deuxième nom")
c = ("Entrez le troisième nom")
If a < b And b < c Then
MsgBox("ces noms sont classés alphabétiquement")
Else
MsgBox("ces noms ne sont pas alphabétiques")
End If
Exercice 3. Ecrire un algorithme qui lit au clavier l’heure et les

minutes, et affiche l’heure qu’il sera une minute plus tard.
Exemple, si l’utilisateur tape 18 puis 23, l’algorithme doit
répondre : ‘’ Dans une minute, il sera 18 heures 24’’. Notons bien
que l’utilisateur doit entrer une heure valide.
Résolution
60
Dim H, M As Integer
H = InputBox("Entre l'heure")
M = InputBox("Entre la minute")
M=M+1
If M = 60 And H = 24 Then
M=0
H=H+1
End If
MsgBox ("Dans une minute il sera" & Val(H) & "heure(s)" &
Val(M) & "minute")
Exercice 4. Ecrire un programme qui lit un nombre puis vérifie si

ce nombre est positif, négatif ou nul.
Résolution
Dim n As Double
n = InputBox ("Entrez un nombre")
If n > 0 Then
MsgBox ("nombre positif")
ElseIf n < 0 Then
MsgBox("nombre négatif")
Else
MsgBox ("nul")
End If
Exercice 5. Ecrire un programme qui saisit un nombre (1-7) et

affiche le jour de la semaine correspondant au numéro saisi
grâce à la structure avec Select case.
Résolution
Dim jour As Integer
jour = InputBox("Entrez un numéro du jour")
Select Case jour
Case 1
MsgBox("Lundi")
61
Case 2
MsgBox("Mardi")
Case 3
MsgBox("Mercredi")
Case 4
MsgBox("Jeudi")
Case 5
MsgBox("Vendredi")
Case 6
MsgBox("Samedi")
Case 7
MsgBox("Dimanche")
Case Else
MsgBox("Invalide")
End Select
II. Structures répétitives (itératives)
Si l'on désire effectuer plusieurs fois une opération, il

serait fastidieux de dupliquer plusieurs fois le traitement. Le
mieux à faire dans ce cas serait d’utiliser la boucle.
Ainsi, il existe plusieurs types de boucle en VB.NET, à

savoir :
- La boucle For … Next

- La boucle While … End while
- La boucle Do while …. Loop
- La boucle Do until ….. Loop
- La boucle Do loop …. While
- La boucle Do loop … Until
2.1. Boucle For ... Next
Cette boucle est beaucoup plus utilisée lorsqu'on veut

répéter les instructions un certain nombre de fois et qu’on connait
62
en amont la valeur de la borne inférieure et celle de la borne
supérieure. Il est beaucoup plus appliqué dans le cas de vecteur
et matrice.
La boucle For utilise un compteur de boucle (qu'on doit

déclarer) pour contrôler l'exécution.
For compteur = début to fin step incrément
Instructions
Next compteur
Exemple
Dim compteur as Integer
For compteur = 1 To 10
MsgBox(compteur)
Next compteur
For …Each… Next
Une boucle For Each itère pour chaque entrée d'un

tableau ou autre objet itérable, qui doit implémenter les interfaces
IEnumerable ou IEnumerator. L'implémentation de IList par Array
autorise un tableau à être utilisé comme un objet, car IList hérite
de IEnumerable.
For each element in groupe
Instructions
Loop
Exemple :
Dim Liste As Integer() = { 1, 2, 4 }

63
Dim Ligne As Integer
For Each Ligne In Liste
MsgBox(Ligne) ' affiche 1, puis 2, puis 4
Next
2.2. Boucle While … End while
While est une instruction qui permet d’exécuter un bloc

d’instructions tant que la condition est vraie. Cette boucle est dite
pré-testée parce que l’évaluation de la condition se fait avant les
actions.
While (condition vraie)

Instructions
End while
Exemple
Dim i as Integer
While (i<10)
i=i+1
Msgbox (i)
End while
2.3. Boucle Do while... Loop
Le Do ... Loop sert à exécuter un nombre d'instructions en

répétant selon une condition.
Initialisation du compteur
Do while (condition vrai)
Bloc d’ instructions
Incrémentation
64
Loop
Exemple
Dim cpt as integer
Cpt=1
Do While(cpt<10)
Msgbox (cpt)
cpt=cpt+1
Loop
2.4. Boucle Do Until...Loop
Le Do Until...Loop est une boucle qui itère tant que sa

condition de sortie est fausse, cette dernière est testée à chaque
début de boucle, donc le programme n'y passe pas forcément.
Initialisation compteur
Do Until(condition fausse)
Bloc d’ instructions
Incrémentation
Loop
Exemple
Dim cpt As Integer
cpt = 1
Do Until (cpt > 10)
Msgbox (cpt)
65
cpt = cpt + 1
Loop
2.5. Boucle Do loop …. While
Cette structure est similaire à la boucle Do while … Loop

si ce n’est que la condition de test de la boucle est faite après
que le corps de la boucle ait été exécuté.
Do
Incrémentation
Loop while (condition vrai)
Exemple
Dim cpt As Integer
cpt = 1
Do
Msgbox cpt
cpt = cpt + 1
Loop while (cpt <= 10)
2.6. La boucle Do loop … Until
Cette structure est similaire à la boucle Do Until … Loop

si ce n’est que la condition de test de la boucle est faite après
que le corps de la boucle ait été exécuté.

66
Do
Incrémentation
Loop until (condition fausse)
Exemple
Dim cpt As Integer
cpt = 1
Do
Msgbox cpt
cpt = cpt + 1
Loop until (cpt >=10)
EXERCICES SUR LES BOUCLES
1. Ecrire un programme qui lit un nombre n puis affiche tous

les entiers compris entre 1 et n.
Résolution
Dim i, n As Integer
For i = 1 To n
MsgBox(i)
Next
2. Ecrire un programme qui demande un nombre compris
entre 10 et 20 jusqu'à ce que la réponse convienne. En cas
de réponse inférieur à 10, le programme doit indiquer à
l'utilisateur qu'il doit saisir un nombre plus grand et en cas
67
de réponse supérieur à 20 indiquera qu'il doit saisir un
nombre plus petit.
Resolution
Dim nombre As Integer = 0

Do
nombre = InputBox("Donnez un nombre compris entre
10 et 20 ")
If (nombre < 10) Then
Msgbox("plus grand")
End If
If (nombre > 20) Then
Msgbox("plus petit")
End If
Loop While (nombre < 10 Or nombre > 20)
MsgBox("Le nombre est correct")
3. Ecrire un programme qui demande une suite de nombres

réels, le dernier nombre est 0(quand l'utilisateur saisit 0 on
arrête la saisie).
Le programme doit afficher le plus petit nombre de la suite
(0 est exclus) et la somme de tous les nombres de la suite.
Resolution
Dim nombre, plusPetit, somme As Double

nombre = InputBox("Donnez un nombre")
plusPetit = nombre
somme = somme + nombre
While nombre <> 0
nombre = InputBox("Donnez un nombre ")
somme += nombre
If nombre < plusPetit And nombre <> 0 Then
plusPetit = nombre
End If
68
End While
MsgBox("Le plus petit nombre de la suite est " & plusPetit)
MsgBox("La somme de la suite est " & somme)
4. Ecrire un programme qui demande successivement 20

nombres à l'utilisateur et qui lui dise ensuite quel est le plus
grand parmi ces 20 nombres et en quelle position il a tapé
ce nombre.
Resolution
Dim nombre, plusGrand As Double

Dim position As Integer = 0
nombre = InputBox("Donnez le nombre 1 ")
position = 1
plusGrand = nombre
For i As Integer = 2 To 20
nombre = InputBox("Donnez le nombre " & i & " ")
If (nombre > plusGrand) Then
plusGrand = nombre
position = i
End If
Next
MsgBox("Le plus Grand est " & plusGrand & " et il a été tapé a
la position " & position)
5. Ecrire un programme pour entrer un nombre de l’utilisateur

et comptez le nombre de chiffres dans l’entier donné en
utilisant une boucle.
Résolution
Dim n, i As Integer
n = InputBox("entre un nombre")
While (n <> 0)
i=i+1
69
n = n / 10
End While
MsgBox("nombre est" & i)
EXERCICE SUR LES TABLEAUX

1. Ecrire un programme calculant la somme des valeurs d'un
tableau de 10 entiers saisies par l'utilisateur.
Résolution
Const taille = 10
Dim tableau(taille - 1) As Integer
Dim somme As Integer = 0
For i As Integer = 0 To taille - 1
tableau(i)=InputBox ("Donnez la valeur de l'element " & (
i + 1) & " ")
'pour chaque élément saisi, on l'ajoute directement à la s
omme
somme += tableau(i)
Next
MsgBox("La somme des éléments du tableau est " & somme)
2. Ecrire un programme qui crée un tableau à deux

dimensions(5,3) qui sera rempli de valeurs numériques par
l'utilisateur et qui recherche la plus grande valeur au sein
du tableau.
Résolution
Sub Main()
Const ligne = 5
Const colonne = 3
Dim tableau(ligne - 1, colonne - 1) As Double
Dim plusGrand As Double = 0
For i As Integer = 0 To ligne - 1

Msgbx("Ligne numero " & (i + 1))
70
For j As Integer = 0 To colonne - 1
tableau(i, j)=InputBox ("Donnez la valeur " & (j + 1) & " ")
Next
Next
For i As Integer = 0 To ligne - 1
For j As Integer = 0 To colonne - 1
If plusGrand < tableau(i, j) Then
plusGrand = tableau(i, j)
End If
Next
Next
MsgBox("La plus Grande valeur est " & plusGrand)
3. Ecrire un programme qui demande à l'utilisateur de remplir d

eux tableaux de 10 entiers A et B. C est un tableau de 20 entier
s. Le programme doit mettre dans C la fusion des tableaux A et
B. On copiera dans 10 premières cases de C le tableau A et da
ns les 10 dernières le tableau B. Le programme affiche ensuite l
e tableau C.
Résolution
Const taille = 10
Dim A(taille - 1), B(taille - 1), C(2 * taille - 1) As Integer
MsgBox("Remplissage du premier tableau")
For i As Integer = 0 To A.Length - 1
A(i) =InputBox ("Donnez la valeur " & (i + 1) & " ")
Next
MsgBox("Remplissage du deuxieme tableau")
For i As Integer = 0 To B.Length - 1
B(i) =InputBox("Donnez la valeur " & (i + 1) & " ")
Next
'remplissage des 10 premières cases de C avec les valeur
s de A
For i As Integer = 0 To A.Length - 1
71
C(i) = A(i)
Next
'remplissage des 10 dernières cases de C avec les valeurs de B
For i As Integer = A.Length To C.Length - 1
C(i) = B(i - A.Length)
Next
For i As Integer = 0 To C.Length - 1
MsgBox(i + 1 & "--->" & C(i))
Next
III. Gestion des exceptions
Certains langages de programmation, dont le Visual

Basic.Net, proposent un mécanisme de prise en compte des
erreurs, fondé sur la notion d’exception.
Une exception est un objet qui peut être émis par une
méthode si un événement d’ordre « exceptionnel » (les erreurs
rentrent dans cette catégorie) se produit. La méthode en
question ne renvoie alors pas de valeur de retour, mais émet une
exception expliquant la cause de cette émission.
Try...Catch...Finally
Try
instructions susceptibles de provoquer une erreur
Catch variable as Type_Exception
instructions à exécuter en cas d'erreur
Finally
instructions finales à exécuter dans tous les cas
End Try
Exemple :
Dim Resultat As Integer = 5

72
Dim x = 1
Dim y = 0
Try
Resultat = x / y
Catch ex As Exception
MsgBox(ex.ToString)
Finally
MessageBox.Show(Resultat)
End Try
73
CHAPITRE V
PROGRAMMATION EVENEMENTIELLE
0. Introduction
En informatique, la programmation événementielle est

un paradigme de programmation fondé sur les événements. Elle
s'oppose à la programmation séquentielle. Le programme sera
principalement défini par ses réactions aux différents
événements qui peuvent se produire, c'est-à-dire des
changements d'état de variable, par exemple l'incrémentation
d'une liste, un déplacement ou un clic de souris, une saisie
au clavier...
La programmation événementielle peut également être

définie comme une technique d'architecture logicielle où
l'application a une boucle principale divisée en deux sections : la
première section détecte les événements, la seconde les gère.
Elle est particulièrement mise en œuvre dans le domaine
des interfaces graphiques.
À noter qu'il n'est pas ici question d'interruptions

logicielles : le traitement d'un événement ne peut pas être
interrompu par un autre, à part en des points précis explicitement
prédéterminés du code logiciel (points qui, en fait, créent une
seconde boucle événementielle au sein de la première).
I. Principes
Visual Basic permet la création d’IUG (Interface Utilisateur
Graphique), 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.
74
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 Evènements (en anglais events),
sont reliées au programme via le système d’exploitation de
Microsoft Windows.
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.
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.
Nota :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.
75
 En plus des feuilles, un projet peut être constitué de
modules.
II. Etapes de développement d’une application
 Le développement d’une application sous VB implique les

étapes ci-après:
 Création de l’interface utilisateur à l’aide des contrôles VB ;
 Définition des caractéristiques ou propriétés des éléments
qui composent l’interface ;
 Ecriture du code de programmation pour un ou plusieurs
éléments de l’interface en fonction des besoins.
Exemple 1 : Mini Calculatrice
L'utilisateur de l'application va interagir avec la fenêtre

de la mini-calculatrice.
 L'utilisateur saisit deux entiers A et B

 Il clique sur un bouton de la somme ou de soustraction
 Le système affiche le résultat.

76
Quand on clique sur le bouton de la somme, on voit
apparaitre le résultat. Le clic sur le bouton est un événement
qui a causé l'affichage de la somme.
Quand un événement a lieu, une procédure liée à cet

événement est appelée. Le développeur de l'application doit
développer le code VB.NET relatif à ces procédures. Une
procédure événementielle est donc une procédure classique
mais qui s’exécute quand un événement particulier se produit. (Il
est à noter qu'elle peut être aussi appelée dans du code comme
une procédure classique). Dans notre exemple, on doit par
exemple développer la procédure au clic sur le bouton de la
somme. Cette procédure va :
1. Récupérer l'entier A saisi par l'utilisateur

2. Récupérer l'entier B saisi par l'utilisateur
3. Faire la somme
4. Afficher le résultat.
III. Procédures événementielle
En pratique, la procédure événementielle générée pour un

objet suit la syntaxe suivante (à ne pas modifier ces
paramètres):
Private Sub NomObjet _ NomEvénement ( paramètres )
Instructions
End Sub
IV. Quelques instructions particulières
a. MsgBox()
La fonction MsgBox() est une fonction qui affiche une

boite de message. Une boite de message est un genre de petit
formulaire dans lequel on y trouve une icône, un message, et au
moins un bouton de commande qui permet de laisser le temps à
77
l'utilisateur de lire le message, et de refermer lui-même la boite
de message.
Exemple :
MsgBox("Bonjour Ethan Olivier!") permet d'afficher une

fenêtre simple contenant le texte "Bonjour! " avec un bouton OK.
Ceci peut se faire aussi en utilisant l'instruction suivante:
MessageBox.Show("Bonjour Ethan Olivier!") Ceci sert à
simplifier au développeur la création des fenêtres simples
couramment utilisées surtout pour informer l'utilisateur. On peut
ajouter d'autres paramètres en fonction du besoin.
Ci-dessous quelques cas d'utilisation:
1. MessageBox.Show( "bonjour! ","titre" )
Résultat :
2. MessageBox.Show( "Bonjour! " , "titre" ,

MessageBoxButtons.OKCancel)
78
Résultat :
3. MessageBox.Show( "Bonjour!" ,"titre" ,

MessageBoxButtons.YesNoCancel)
Résultat :
Dim reponse As String = InputBox( "Donnez votre nom:" ,

"titre de la fenetre" ) : Permet d'afficher une fenêtre pour
récupérer une réponse de la part de l'utilisateur. La réponse est
stockée dans la variable "reponse" de type String.
79
Résultat :
c. Timer
L'objet Timer (minuterie) permet de tester un événement

qui se produit à des intervalles de temps fixe.
Il apparaît en mode construction, mais il est invisible à

l'exécution. La propriété Enabled permet de le mettre en marche
(True) ou de l'arrêter (False).
Lorsqu'il est en marche, l'événement Timer se produit à

intervalles réguliers. Cet intervalle de temps est indiqué dans la
propriété Interval de l'objet (exprimé en millisecondes). C'est un
entier positif de 0 à 64767 (1 minute maxi).
Exemple : CREEZ UNE HORLOGE PARLANTE

80
Public Class Form1
Private Sub Timer1_Tick_1(sender As Object, e As

EventArgs) Handles Timer1.Tick
Label2.Text = TimeOfDay
If TimeOfDay = "17:32" Then
Dim sapi = CreateObject("sapi.spvoice")
sapi.speak("Il est maintenant 17 heures 32 Minutes ")
End If
Dim sapi
sapi = CreateObject("sapi.spvoice")
sapi.speak("Il est maintenant 1 heure Juste " & "Nous vous

remercions !!!")
End If
Dim sapi
sapi = CreateObject("sapi.spvoice")
sapi.speak("Il est maintenant 2 heures Juste " & "

Nous vous remercions !!!")
End If
d. TimeOfday
Renvoie l’heure système sous forme d’une valeur de type

variant.
81
e. Now
Renvoie la date et l’heure système sous forme d’une

valeur de type variant.
Une telle variable peut contenir les données de différents

types (entier, date, Date, etc.)
IV. Manipulation des quelques éléments
1. Formulaire
Un formulaire représente une fenêtre (Window). C'est le

conteneur principal des autres éléments graphiques. Il s'agit de
la classe System.Windows.Forms.Form de la plateforme .NET.
La classe Form dispose évidemment des propriétés

communes déjà vues, particulièrement, la propriété "text" permet
de manipuler le titre de la fenêtre (placé dans la barre de titre).
Les méthodes couramment utilisées sont :
 la méthode Show () qui permet d'ouvrir une fenêtre à partir

d'une autre
 la méthode Close () qui permet de fermer une fenêtre
 la méthode Hide () qui permet de rendre la fenêtre invisible.
Pour identifier le formulaire courant, on peut utiliser le mot

clé "Me".
Exemple: On se propose de modifier le titre, la taille et la

couleur de l'arrière-plan lors du chargement de la fenêtre.
On va donc développer la procédure liée à l'évènement

Form Load .
82
Public Class Form1

Private Sub Form1_Load( ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles MyBase .Load
Me .Text = "C'est le titre "
Me .Size = New System.Drawing.Size(250, 90)
Me .BackColor = Color.Blue
End Sub
End Class
Exercice:
Une fenêtre d'authentification contient un champ de saisie

pour l'identifiant et un autre pour le mot de passe de l'utilisateur.
Si le premier est égale à la chaine "Ethan" et le second à la
chaine "Olivier" alors on ouvre une autre fenêtre (la fenêtre
principale de l'application). Donner le code de la procédure
événementielle liée au click sur le bouton connexion.
83
Solution
Public Class frmAuthentification
Private Sub cmdConnexion_Click ( … )
If txtId.Text = "Ethan " And txtPassword.Text = "Olivier"

Then
Me .Hide() 'Fermer la fenêtre actuelle
frmBienvenue.Show() 'ouvrir la nouvelle fenetre
Else
MessageBox.Show( "Login ou mot de passe incorrect" )

84
End If
End Sub
End Class
2. Les étiquettes et les zones de texte
Une étiquette sert à afficher du texte sur la fenêtre alors

qu'une zone de texte sert à récupérer le texte saisi par
l'utilisateur. La première est une instance de la classe
System.Windows.Forms.Label de la plateforme .NET alors que
la deuxième représente une instance de la classe
System.Windows.Forms.TextBox. Puisqu'ils servent
principalement à afficher ou saisir du texte, la propriété
généralement utilisée pour ces deux contrôles est la propriété
Text. On peut éventuellement changer la police et la couleur des
caractères.
3. Check Box et radioButton
La propriété qui stock l’état de sélection d'un checkBox ou

un RadioButton est la propriété Checked, de type Booléen. La
valeur True veut dire que le contrôle est choisi.
Il est à noter bien que VB se charge de mettre à jour la

propriété checked une fois que la sélection est modifiée.
L'événement lié à la modification de l'état de la propriété

checked est :
" CheckedChanged ". Par exemple: " CheckBox1_

CheckedChanged " est le nom de la procédure événementielle
appelée quand la valeur de selection de l'objet a été changée.
Exercice: Donnez le code de la procédure

événementielle liée au clic sur le bouton qui permet d'afficher:
Bonjour+ DSI ou RSI selon le bouton Radio sélectionné.
85
Résolution
Private Sub cmdBonjour_Click( ByVal sender As

System.Object, ByVal e As System.EventArgs) Handles
cmdBonjour.Click
If optDSI.Checked Then
MessageBox.Show( "Bonjour DSI" )
Else
MessageBox.Show( "Bonjour RSI" )
End If
End Sub
4. Le contrôle group Box
Un GroupBox est une fenêtre qui peut être placée sur un

formulaire pour regrouper des contrôles. Tous les contrôles (qui
86
peuvent être différents: labels, boutons…) placés sur le
GroupBox appartiennent au même groupe. La propriété "Text"
permet de donner un titre au GroupBox.
On a vu que si plusieurs RadioButton sont placés dans un

formulaire, une seule option peut être choisie. Cependant, si on
a besoin d'utiliser deux groupes de choix dans lesquels on peut
sélectionner deux choix non exclusifs: un dans le premier groupe
et un dans le second, ceci n’est pas possible s'ils se trouvent
dans la même fenêtre. Pour résoudre ce problème, il suffit de:
 placer chaque groupe d’options dans un GroupBox à

part
 ou bien placer un groupe d’options sur le formulaire et
l'autre dans un groupe box.
Exercice :
Ajouter à l'interface de l'exercice précédent deux boutons

radio pour le niveau: 2 ème année et 3 ème année.
87
Public Class test
Private Sub test_Load( ByVal sender As System.Object,

ByVal e As
System.EventArgs) Handles MyBase .Load
optDSI.Checked = True
opt2.Checked = True
End Sub
Private Sub cmdBonjour_Click( ByVal sender As

System.Object, ByVal e As
System.EventArgs) Handles cmdBonjour.Click
Dim texte As String = "Bonjour"
If optDSI.Checked Then
texte += " DSI"
Else
texte += " RSI"
End If
If opt2.Checked Then
texte += " 2"
Else
texte += " 3"
End If
MessageBox.Show(texte)
End Sub
88
End Class
5. Les listes
Les types de listes que nous avons vues sont : listBox et

comboBox. Dans les deux cas, la liste des valeurs est stockée
dans la propriété Items.
On peut initialiser cette liste lors de la conception à partir

de la fenêtre Properties de l'IDE (une valeur par ligne). Cette liste
peut aussi être mise à jour (ajout, suppression) de manière
dynamique à partir du code VB.NET. Ci-dessous quelques
méthodes et propriétés utiles pour le cas de la listBox.
NomListBox. Items .Add(valeur) ajoute la valeur à la liste

NomListBox. Items .Remove enlève l’élément valeur de la
(valeur) liste
NomListBox. Items .RemoveAt enlève l’élément d’indice i de
(i) la liste (i commence à partir
de 0)
NomListBox. Items. Clear enlève tous les éléments de
List
ListBox.Items.Count donne le nombre d’éléments
dans List
NomListBox.items (i) retourne l’item d’indice i de la
liste(i commence à partir de
0)
NomListBox. SelectedItem retourne l’élément
sélectionné
NomListBox. Sorted Si elle est égale à True alors

la liste sera maintenue triée
par ordre alphabétique
croissant.
89
Exemple :
Solution
Private Sub Button1_Click(sender As Object, e As

EventArgs) Handles Button1.Click
Dim N As Integer
N = InputBox(" saisir la valeur à multiplier ")
For i = 1 To 12
ListBox1.Items.Add(" " & Val(N) & " x " & Val(i) & " = "
& Val(N * i))
Next i
End Sub
90
CHAPITRE VI
ACCES A LA BASES DE DONNEES
O. Introduction
Il existe plusieurs sources de données, tels que le fichier
XML, fichier texte, Excel, la base de données, etc.
L’on tache beaucoup plus sur la base de données, car de

nos jours, elle semble être la source la plus utilisée. Pour cela,
nous allons illustrer notre cas d’école avec le SGBD Ms Office
Access 2013. Pour cela, l’usage d’ADO.NET et du DATASET est
recommandé.
I. Usage d’ADO.NET
ADO.NET est indépendant de la base de données ; alors

qu’initialement chaque type de gestionnaire de base de données
avait ses instructions, sa manière de fonctionner, ADO.NET
utilise le langage SQL (Structured Query Language) pour ouvrir,
interroger, modifier une base de données.
Nota : on ouvre la base de données avec la méthode Open.
1.1. Création de la base de données avec MS Access 2013
Pour créer une base de données en Access, il suffit d’ouvrir

Microsoft Office puis choisissez Access, la fenêtre suivante
apparait :
91
Cliquez sur base de données vide, la fenêtre suivante

apparait, puis donnez-en un nom, pour notre cas
BDDGEST_ETUD, sélectionner un emplacement spécifique puis
cliquer sur Créer.
a) Création de la table
Pour créer une table en Access, il suffit de :
 Cliquer sur créer, puis création de table, une fenêtre de

structure apparait comme suit :
 Structurer vos champs, en y donnant un type et une taille ;

92
Pour le champ identifiant, tel que Matricule_Etudiant,
sélectionnez-en puis cliquer sur clé primaire ;
 Puis fermez-en sous un nom. Pour notre cas T_Etudiant.
1.2. Création de la source de données ODBC
La création de la source de données dépend du SGBD

utilisé. De ce fait, pour ce qui nous concerne, nous la créons avec
Access.
a) Création de la source de données pour la base de

données construite sur Access
Pour créer la source de donnes ODBC pour Access, il vous

suffit de :
 Aller dans panneau de configuration ;

 Cliquer sur Outils d’administration ;
 Cliquer sur source de données ODBC, la fenêtre suivante
apparait :
93
 Cliquez sur ajouter ;
 Puis sélectionner le pilote pour lequel vous souhaitez
définir votre source de données. Pour notre exemple
Microsoft Access driver (*mdb,*accdb) puis cliquer sur
terminer, l’écran ci-après apparait :
 Nommez la source de données. Pour notre exemple JMK,

puis cliquez sur sélectionner ;
 Puis chercher la base de données à l’endroit auquel elle se
trouve, puis cliquez successivement sur ok.
Voilà la source de données ainsi créée :
94
II. USAGE DU DATASET
Avec un objet DataSet, on manipule les données de la

base à travers une requête SQL sur un objet command, pour
alimenter un DataSet, on a besoin d’un Data Adapter qui fera
l’intermédiaire entre la base de données et le DataSet.
Avec un objet Command, on interrogera la base de

données à travers de requêtes SQL (UPDATE, INSERT,
DELETE, CREATE, DROP,…), on utilise la propriété
ExecuteNonQuery pour cette fin.
La méthode Close () fermera la base.
Voici la procédure pour manipuler le DataSet :
 Cliquer sur l’onglet Sources de données, puis « Ajouter

une nouvelle source de données », la fenêtre ci-après
apparait :
95
 Cliquer sur suivant, la fenêtre ci-après apparaitra,

puis aller dans nouvelle connexion
 Après avoir cliqué sur « Nouvelle connexion », la

fenêtre ci-après apparait, puisqu’il sera question,
d’une chaine de connexion avec OLE, cliquez sur
Modifier pour choisir une source de données, du
reste un type de SGBD, dans l’onglet parcourir,
cherchez un emplacement auquel se trouve le nom
du fichier de votre base de données.
96
 Puis tester la connexion, enfin cliquer sur OK,

vous verrez une chaine de connexion comme suite :
 Après avoir sélectionné un objet de base de

données, cliquer successivement sur « suivant » puis
sur Terminer.
97
III. ETUDE DE CAS
C’est une partie qui sera entièrement consacrée à une

mise en pratique de la démarche de réalisation des applications
de la conception des formulaires jusqu’à la production des états
de sortie.
Première étude avec ADO.NET : Identification des

étudiants
Dans le souci de bien suivre les étudiants de l’Institut

Supérieur de Commerce de Bandundu, on demande de mettre
au point une application en Visual basic.Net dont l’objet est de
produire la liste des étudiants.
Après conception et implémentation de la base de données,

la structure de la base de données est la suivante :
Solution
Outils
 Créer un dossier « APPLIGEST_ETUD » dans

lequel, vous créerez deux sous dossiers
dont Application et BD
 SGBD utilisé Access 2013.
 Nom de la base de données : Gest_etude
 Nom de la source de données ODBC : « JMK»
 Contrôle de liaison utilisé pour la base : ADO
98
3.1. Conception du formulaire
Concevoir un formulaire, revient tout simplement à le

dessiner, nous présentons ci-dessous quelques formulaires en
mode création.
a. Windows forms
b. Création fenêtre de chargement
c. Création de la boite de connexion
Pour préserver de mécanisme de sécurité dans toute

application digne de son nom, il est utile et nécessaire de faire
99
recours à la boite de connexion ; donc notre application doit
disposer d’un mot de passe.
Pour créer une boite de connexion, on procède comme suit :
 Cliquer sur menu « Projet » puis « Ajouter un nouvel

élément » ;
 La boite de dialogue apparait dans laquelle vous
sélectionnez « formulaire de connexion », renommez le en
Login puis cliquer sur « Ajouter ».
 La boite de connexion est prête :

100
On peut également ajouter un formulaire dans lequel, on peut
dessiner simplement une interface comme au modèle ci-
dessous :
d. Création de menus
Pour créer le menu, la procédure est la suivante :
Dans le menu « Projet », cliquer sur « Ajouter

un nouvel élément »
Une boite de dialogue apparait dans laquelle
vous sélectionnez « Formulaire parent MDI », renommez
le en Menu puis cliquer sur « Ajouter »
101
Après personnalisation, on aura :
3.2. Création de module
Nous aimerons connecter notre application à la base de

données, tout en mettant les codes y afférent à partir d’un
module. Voici la procédure pour ajouter un module :
 Cliquer sur le menu projet ;
 Puis ajouter un module, la fenêtre ci-après apparait, puis

cliquer sur ajouter.
102
Placez les codes ci-après dans les modules et avec un

mécanisme de gestion des exceptions :
Module Module1
Public cn As New ADODB.Connection, rs As New

ADODB.Recordset, a As String
Sub Main()
Try
Application.EnableVisualStyles()
cn.Open("JOS")
Catch ex As Exception
MessageBox.Show("Aucune base de données n'est

associée à ce programme", "SOURCE DE DONNEES
INTROUVABLE", MessageBoxButtons.OK,
MessageBoxIcon.Error)
End Try
Form1.ShowDialog()
103
End Sub
End Module
MODULE POUR L’INITIALISATION DE L’ECRAN
Module initialisation
Textbox1.Text = ""
Textbox2.Text = ""
Textbox3.Text = ""
Combobox1.Text = ""
Combobox2.Text = ""
Textbox1. Focus()
End Module
A présent, il ne nous reste qu’à passer à l’écriture de

codes en rapport avec chaque bouton de notre application.
3.3. Ecriture de codes
3.3.1.Procedure pour annuler
Public Class Form1
Private Sub BtnAnnuler_Click(ByVal sender As

BtnAnnuler.Click
A = MessageBox.Show("Etes vous sur de vouloir annuler

ces informations?","ANNULATION DE DONNEES",
MessageBoxButtons.YesNo, MessageBoxIcon.Question)
If a = vbYes Then
Textbox1.Text = ""
104
Textbox2.Text = ""
Textbox3.Text = ""
Combobox1.Text = ""
Combobox2.Text = ""
Textbox1.Focus()
End If
End Sub
3.3.2. Insertion d’un nouvel enregistrement
Private Sub BtnEnregistrer_Click(ByVal sender As

BtnEnregistrer.Click
' saisie controlée
If Textbox1.Text = "" Or Textbox2.Text = "" Or

Textbox3.Text = "" Or Combobox1.Text = "" Or Combobox2.Text
= "" Then
MessageBox.Show("Veuilez remplir les zones vide avant

de continue SVP!!!", "Controle de zones",
MessageBoxButtons.OK, MessageBoxIcon.Exclamation)
Exit Sub
End If
rs = New ADODB.Recordset
rs.Open("select*from T_etudiant where Matricule='" &

Textbox1.Text & "'", cn,
ADODB.CursorTypeEnum.adOpenKeyset,ADODB.LockTypeEn
um.adLockOptimisti)
105
If rs.EOF = False Then
MessageBox.Show("ce matricule: " + Textbox1.Text

+ " éxiste déjà dans la base de données", "Risque de doublons",
MessageBoxButtons.OK, MessageBoxIcon.Error)
Textbox1.Text = ""
Textbox2.Focus()
Else
a = MessageBox.Show("Voulez-vous enregistrer ces

informations?", "Enregistrement de données",
If a = vbYes Then
rs.AddNew()
rs.Fields("Matricule").Value = Textbox1.Text
rs.Fields("Nom").Value = Textbox2.Text
rs.Fields("PNom").Value = Textbox3.Text
rs.Fields("Sexe").Value = Combobox1.Text
rs.Fields("Promo").Value = Combobox2.Text
rs.Update()
MessageBox.Show("Enregistrement réussi avec

succès", "Confirmation", MessageBoxButtons.OK,
MessageBoxIcon.Information)
Textbox1.Text = ""
Textbox2.Text = ""
Textbox3.Text = ""
106
Combobox1.Text = ""
Combobox2.Text = ""
Textbox1.Focus()
End If
Exit Sub
End If
rs.Close()
End Sub
Nota : Au cas où l’on ne veut pas placer les codes de connexion

à partir d’un module, on les placera directement dans le bouton
y afférent ; et cela de cette façon :
Insertion d’un enregistrement
Private Sub Button1_Click(ByVal sender As

Button1.Click
Dim Cn As New ADODB.Connection
Dim Rs As New ADODB.Recordset
Cn.Open("JMK")
If TextBox1.Text = "" Or TextBox2.Text = "" Or

TextBox3.Text = "" Then
MessageBox.Show(" Veuillez remplir les champs

vides", "Message", MessageBoxButtons.OK,
MessageBoxIcon.Error)
Exit Sub
End If
107
Rs.Open("Select * From T_etudiant where Matricule='" &
TextBox1.Text & "'",Cn,
um.adLockOptimistic)
If Rs.EOF = True Then
Rs.AddNew()
Rs.Fields("Matricule").Value = TextBox1.Text
Rs.Fields("Nom").Value = TextBox2.Text
Rs.Fields("Pnom").Value = TextBox3.Text
Rs.Fields("Sexe").Value = ComboBox1.Text
Rs.Fields("Promo").Value = ComboBox2.Text
Rs.Update()
MsgBox(" Enregistrement effectué")
TextBox1.Clear()
TextBox2.Clear()
TextBox3.Clear()
ComboBox1.Clear()
ComboBox2.Clear()
TextBox1.Focus()
Else
MsgBox(" Enregistrement impossible, il y a un doublon")
TextBox1.Clear()
TextBox2.Clear()
108
TextBox3.Clear()
ComboBox1.Clear()
ComboBox2.Clear()
TextBox1.Focus()
End If
End Sub
3.3.3.La recherche
Private Sub BtnRechercher_Click(ByVal sender As

BtnRechercher.Click
If Textbox1.Text = "" Then
MessageBox.Show("Veuillez saisir votre matricule

avant de rechercher SVP!!!", "Controle de zones",
Textbox1.Focus()
Exit Sub
End If

If rs.EOF = True Then

109
MessageBox.Show("ce matricule: " + Tmatri.Text +
" N'existe pas dans la base de données", "Erreur de recherche",
Textbox1.Text = ""
Textbox2.Focus()
Else
Textbox1.Text = rs.Fields("Matricule").Value
Textbox2.Text = rs.Fields("Nom").Value
Textbox3.Text = rs.Fields("PNom").Value
Combobox1.Text = rs.Fields("Sexe").Value
Combobox2.Text = rs.Fields("Promo").Value
End If
rs.Close()
End Sub
3.3.4. Modification d’un enregistrement en cours
Private Sub BtnModifier_Click(ByVal sender As

BtnModifier.Click
If Textbox1.Text = "" Then
MessageBox.Show("Veuillez saisir votre matricule

avant de modifier SVP!!!", "Controle de zones",
Tmatri.Focus()
Exit Sub
110
End If

MessageBox.Show("ce matricule: " + Textbox1.Text + "

n'existe pas dans la base de données", "Erreur de modification",
Textbox1.Text = ""
Textbox1.Focus()
Else
a = MessageBox.Show("Voulez-vous enregistrer ces

modifications?", "Enregistrement de données",
If a = vbYes Then
rs.Fields("Matricule").Value = Textbox1.Text
rs.Fields("Nom").Value = Textbox2.Text
rs.Fields("PNom").Value = Textbox3.Text
rs.Fields("Sexe").Value = Combobox1.Text
rs.Fields("Promo").Value = Combobox2.Text
rs.Update()
111
MessageBox.Show("Modification effectuée avec
succès", "Confirmation", MessageBoxButtons.OK,
Textbox1.Text = ""
Textbox2.Text = ""
Textbox3.Text = ""
Combobox1.Text = ""
Combobox2.Text = ""
Textbox1. Focus()
End If
Exit Sub
End If
rs.Close()
End Sub
3.3.5.Suppression d’un enregistrement
Private Sub BtnSupprimer_Click(ByVal sender As

BtnSupprimer.Click
If TextBox1.Text = "" Then
MessageBox.Show("Veuillez saisir votre matricule avant

de supprimer SVP!!!", "Contrôle de zones",
TextBox1.Focus()
Exit Sub
112
End If
rs.Open("select*from T_etudiant where Mat='" &

TextBox1.Text &
"'",cn,ADODB.CursorTypeEnum.adOpenKeyset,ADODB.LockT
ypeEnum.adLockOptimistic)
MessageBox.Show("ce matricule: " + Textbox1.Text

+ " n'existe pas dans la base de données", "Erreur de
suppression", MessageBoxButtons.OK, MessageBoxIcon.Error)
Textbox1.Focus()
Else
a = MessageBox.Show("Voulez-vous supprimer ces

informations?", "Suppression de données",
If a = vbYes Then
rs.Delete()
MessageBox.Show("Suppression effectuée
avec succès", "Confirmation", MessageBoxButtons.OK,
Textbox1.Text = ""
Textbox2.Text = ""
Textbox3.Text = ""
Combobox1.Text = ""
Combobox2.Text = ""
113
Textbox1.Focus()
End If
Exit Sub
End If
rs.Close()
End Sub
3.3.6. Procédure pour fermer une fenêtre
Private Sub BtnFermer_Click(ByVal sender As

BtnFermer.Click
Close()
End Sub
Nota : au cas où vous ne voulez pas faire la connexion

dans le module, il y a lieu de déclarer les variables de connexion
dans la procédure de chaque bouton et l’ouvrir par la méthode
Open.
Dim Cn As New ADODB.Connection
Dim Rs As New ADODB.Recordset
Cn.Open("JOS")
3.3.7.Codes liés à la fenêtre de chargement
Private Sub Timer1_Tick(sender As Object, e As

EventArgs) Handles Timer1.Tick
ProgressBar1.Increment(+1)
114
Label2.Text = ProgressBar1.Value & "%"
If ProgressBar1.Value = 100 Then
Form2.SHOW()
Me.Hide()
Timer1.Stop()
End If
3.3.8. Instructions liées à la boite de dialogue
Private Sub OK_Click(ByVal sender As System.Object,

ByVal e As System.EventArgs) Handles OK.Click
Dim a As String
a = TextBox2.Text
If a = "1234" Then
Form2.Show()
Me.Hide()
Else
Label3.Text = "Mot de passe incorrect"
TextBox2.Text = ""
TextBox1.Text = ""
End If
End Sub
Private Sub Cancel_Click(ByVal sender As

Cancel.Click
Application.Exit()
End Sub
115
Private Sub LoginForm1_Load(ByVal sender As
MyBase.Load
UsernameTextBox.Text = "Josué"
UsernameTextBox.ReadOnly = True
PasswordTextBox.Focus()
End Sub
End Class
Etude de cas avec utilisation du DataSet
Soit le formulaire ci-après :
Procédures liées aux boutons
1. Bouton enregistrer
Imports System.Data
Imports System.Data.OleDb
116
Public Class Form1
Dim cnn As New OleDb.OleDbConnection
Private Sub Button1_Click(sender As Object, e As
EventArgs) Handles Button1.Click
TextBox3.Text = "" Or TextBox4.Text = "" Or TextBox5.Text = ""
Or TextBox6.Text = "" Then
MsgBox("Vérifiez les cases vides !!!",
MsgBoxStyle.Information, "Information")
TextBox1.Focus()
Exit Sub
End If
Dim cnn As New

OleDbConnection("Provider=Microsoft.Jet.Oledb.4.0; Data
Source=" & Application.StartupPath & "\MALADE.mdb")
Dim cmd As New OleDbCommand("select * from TMAL where
CODE ='" & TextBox1.Text & "'", cnn)
cnn.Open()
Dim dr As OleDbDataReader = cmd.ExecuteReader
If dr.Read Then MsgBox("Ce numéro existe déjà",
MsgBoxStyle.Critical, "Erreur") : TextBox1.Focus() : Exit Sub
dr.Close()
Dim dac As New OleDbDataAdapter(cmd)

Dim ds As New DataSet
dac.Fill(ds, "TMAL")
ds.Tables("TMAL").Rows.Add(New Object()
{TextBox1.Text, TextBox2.Text, TextBox3.Text, TextBox4.Text,
TextBox5.Text, TextBox6.Text})
Dim cb As New OleDbCommandBuilder(dac)
dac.Update(ds, "TMAL")
MsgBox("Enregistrement effectué !!!",
MsgBoxStyle.Information, "Confirmation")
117
CHARGEMENT()
eff()
cnn.Close()
End Sub
2. Bouton Rechercher
Private Sub Button5_Click(sender As Object, e As EventArgs)

Handles Button5.Click
MsgBox("Tapez un code !!!",
MsgBoxStyle.Exclamation, "Erreur")
TextBox1.Focus()
Exit Sub
End If
Dim cmd As New OleDbCommand("select * from TMAL
where CODE='" & TextBox1.Text & "'", cnn)
cnn.Open()
dr.Read()
TextBox2.Text = dr(1).ToString
dr.Close()
cnn.Close()
End Sub
3. Bouton Modifier

118
TextBox3.Text = "" Or TextBox4.Text = "" Or TextBox5.Text = ""
Or
TextBox6.Text = "" Then
MsgBox("Remplissez les champs vide !!!",
TextBox1.Focus()
Exit Sub
End If
cnn.Open()
dr.Read()
dr.Close()
Dim da As New OleDbDataAdapter(cmd)
da.Fill(ds, "TMAL")
ds.Tables("TMAL").Rows(0)("MALADE") = TextBox2.Text
ds.Tables("TMAL").Rows(0)("SEXE") = TextBox3.Text
ds.Tables("TMAL").Rows(0)("AGE") = TextBox4.Text
ds.Tables("TMAL").Rows(0)("MALADIE") = TextBox5.Text
ds.Tables("TMAL").Rows(0)("SORTIE") = TextBox6.Text
Dim cb As New OleDbCommandBuilder(da)
da.Update(ds, "TMAL")
MsgBox("Modification effectuée !!!",
CHARGEMENT()
eff()
cnn.Close()
End Sub
119
4. Bouton Supprimer

MsgBox("Tapez un numéro !!!",
TextBox1.Focus()
Exit Sub
End If
cnn.Open()
dr.Read()
dr.Close()
Dim da As New OleDbDataAdapter(cmd)
da.Fill(ds, "TMAL")
ds.Tables("TMAL").Rows(0).Delete()
Dim cb As New OleDbCommandBuilder(da)
da.Update(ds, "TMAL")
MsgBox("Suppression effectuée !!!",
CHARGEMENT()
eff()
cnn.Close()
End Sub
120
Création d’un état de sortie
Nous faisons appel au Crystal Report pour créer nos états de

sortie, la démarche est la suivante :
Cliquez successivement sur projet, Ajouter un nouvel
élément, Crystal Report puis sur Ajouter, la fenêtre ci-après
apparait ;
Sélectionner « à partir d’un rapport vide », puis cliquez sur

OK,
Le Crystal Report apparait en mode création ;
121
Dans l’explorateur des champs, Cliquer-droit sur « champs

de base de données », puis sur « Expert de base de
données » ;
Dans la boite de dialogue ci-dessous, cliquer sur le « + » à

gauche de « créer une connexion, puis sur le signe « + »
122
placé à coté de ODBC(RDO) en vue de sélectionner votre
source de données soit « JOS » ;
Cliquez sur suivant, puis Terminer, la connexion est créée
et la fenêtre ci-après apparait :
Sélectionnez la table affichée, cliquer sur le signe et enfin

sur OK
A travers l’explorateur des champs, cliquez sur le signe +
à coté du « champ de base de données, ouvrez notre table
« T_Etudiant», enfin glisser les champs de la base de
données sur le Crystal Report.
Ajouter un formulaire, nommez le « Liste_etud » dans
lequel vous insérez le Crystal Report viewer.
Nota :
Son insertion est dépendante de la version du .NET

Framework que reprend la configuration de notre application.
123
Il sera ici question de pouvoir changer la configuration du
Framework comme suit :
 Cliquer sur Projet,
 Cliquer sur propriétés « APPLIGESTETUD »
 Cliquer sur « compiler »
 Cliquer sur « Options avancées de compilation »
 Dans la rubrique « Framework cible (toutes les
configurations) », sélectionner « .Net Framework4 »
 Enfin cliquer sur OK
Il sera également question de modifier la balise

<startup> en effectuant un double-clique sur le fichier
« app.config » que l’on retrouve dans l’explorateur de solutions.
Ladite modification demandera l’ajout de l’attribut :
« uselegacyv2RuntimeActivationPolicy="True" » et ça deviendra
<startup uselegacyv2RuntimeActivationPolicy="True">
Enfin, saisir les codes ci-après :
Public Class List_etud

124
Private Sub List_etud_Load(ByVal sender As

MyBase.Load
cn = New ADODB.Connection
cn.Open("JOS")
rs.Open("select * from T_ETUD", cn,
ADODB.CursorTypeEnum.adOpenKeyset,ADODB.LockTypeE
num.adLockOptimistic)
Dim rep As New CrystalReport1
rep.SetDataSource(rs)
CrystalReportViewer1.ReportSource = rep
End Sub
End Class
En voici le résultat après exécution:
125
BIBLIOGRAPHIE
a) Ouvrages
1. Alain Godon, Programmer avec Visual Basic, cours M2AI -
ISTIA, 2001/2002 ;
2. ARSAC, la construction des programmes structurés,
Ed.Dunod, Paris, 2002 ;
3. Brice-Arnaud GUERIN, ADO.NET 3.5 et LINQ, ENI
Editions ;
4. Faulx-Briole, A., Crystal Reports 2008, ISBN10 : 2-7460-

4227-4 ;
5. Frédéric, B., Visual basic.Net cours et exercices,

Ed.Ellipses, Paris, 2004 ;
6. Gerard, F., Développement avec Visual Basic.NET, Ed.
Eyrolles, Paris, 2002 ;
7. Groussard, T., Visual basic.NET Développez avec Visual
Studio 2008, Ed.ENI, Paris, 2008 ;
8. Halvorson, M., Microsoft Visual Basic .NET Étape par

Étape, Microsoft Press. ;
9. McConnel, S., Tout sur le code, 2ème Ed. Microsoft Press ;

10. Moursli O. et Souchon, N., VISUAL BASIC .NET :
TUTORIAL, UNIVERSITE CATHOLIQUE DE LOUVAIN,
Institut d’Administration et de Gestion ;
11. Tahé, S., apprentissage du langage vb.net, ISTIA,
Université d'Angers, Mars 2004 ;
b) Sites web
1. www.dotnet.com
2. www.developpez.com
3. www.commentçamarche.net
4. www.legacy.net

Programmation Graphique Et Ev Avec Vbnet - Missway2022

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programmation Graphique Et Ev Avec Vbnet - Missway2022

Uploaded by

Copyright:

Available Formats

i

Josué MISSWAY KINDIA

PROGRAMMATION GRAPHIQUE ET EVENEMENTIELLE

Préfacé par le Prof. Emmanuel Tshibaka Katumonangani

Pensée pieuse aux professeurs :

Emmanuel Kanga Matondo ;

Marcel Musangu Luka ;

Alphonse Christian Ivinza Lepapa.

A l’heure actuelle, la mondialisation impose à l’humanité

La mise sur pied d’un programme exige l’application

La résolution d’un problème en informatique exige

Ainsi, à travers cet ouvrage, les lecteurs tireront profit des

Ce manuel s’adresse aux étudiants débutants en

Au regard du contenu de cet ouvrage, le Chef de Travaux

Emmanuel TSHIBAKA KATUMONANGANI

Professeur des universités

La mise au point d’une application en informatique appelle

Cependant, un programme en informatique est un

Pour montrer le rôle éminemment important de

L’algorithme a un rôle fondamental en programmation. Il

Un même algorithme peut être traduit en plusieurs

Il va sans dire qu’écrire un programme correct suppose

Puisque le programme est la représentation d’un

Le présent manuel vise à faire acquérir à l’apprenant

Avec tous les avantages que présente l’environnement

Ceci dit, place à présent aux uns d’apprendre et aux

GENERALITES SUR LA PROGRAMMATION

Un programme n’est rien d’autre que la représentation

1.1. Le langage de programmation

L’intérêt du programme provient de l’utilisation d’un

En résumé, un langage de programmation se

 Son vocabulaire qui définit la liste des mots acceptables

De même un nombre entier, un nombre flottant ou un

 Sa sémantique, c'est-à-dire la signification des

1.2. Paradigme de programmation

Un paradigme est une façon d'approcher la

Un paradigme de programmation fournit (et détermine)

Dans ce type de programmation, les fonctions de plus bas

La méthodologie de la programmation descendante

La programmation linéaire correspond à l’écriture de

 L’initialisation où l’on peut préparer l’écran ; initialiser les

Imaginez que le déroulement du programme soit effectué

Cela justifie l’appellation linéaire donnée à ce type de

La structure générale d’une programmation traditionnelle

En programmation logique, un programme se compose

En programmation modulaire, un programme est

Les modules clarifient et régularisent les interfaces entre les

Un programme écrit en programmation structurée

1.2.7.Programmation orientée objet

En programmation orientée objet, un programme est

Si, par exemple, on crée une classe nommée « cartable »,

De nombreux programmes comprennent des macro-

1.2.9. Programmation événementielle

La programmation événementielle est un paradigme de

PRESENTATION DE VISUAL BASIC.NET

Le développement de ce chapitre donne au lecteur les astuces

1.1. Quid du Framework

Le Framework.Net est un Framework (un kit de

Il s’appuie sur la norme CLI (Common Language

Son implémentation se fait dans la norme CLR (Common

Présentation des normes qui régissent le Framework.Net

La programmation est faite avec du code dit « managé »

1.2. Structure d’une application .NET et exécution