Post on 19-Aug-2021
1
Fascicule de TP
Atelier Programmation Evénementielle
M. Boukhchim Mossaab
Boukchim_mossaab@yahoo.fr
Etudiant:…………………………………..
Classe:……………………………………...
AU 2013-2014
Ministère de l’enseignement supérieur, de la recherche scientifique et de la technologie
Institut Supérieur des Etudes Technologique du Kef
Département Informatique
2
A.U : 2013/2014
ISET kef , Département informatique
Nom du module : Atelier Programmation Evénementielle
Enseignant : Mr. Boukhchim Mossaab
TP N°0 Concept de base de Visual Basic
Le logiciel Visual Basic Studio est là pour nous faciliter l'écriture de programmes, en
particulier (mais pas seulement) en mettant à notre disposition, sous une forme facilement
accessible, les classes Windows les plus communes (boutons, listes, cases, et tout ce qui
s'essuie).
Lorsqu'on va la programmer via Visual Studio, une application va donc toujours pouvoir
être abordée sous deux angles complémentaires :
L’aspect graphique, visuel, bref, son interface. Dans la fenêtre principale
de VB, nous pourrons facilement aller piocher les différents objets que
nous voulons voir figurer dans notre application, les poser sur notre
formulaire, modifier leurs propriétés par défaut, etc :
3
le code proprement dit, où nous allons entrer les différentes procédures en
rapport avec le formulaire en question :
I. Processus de développement « Rappel »
4
1. Création de l’interface Windows « Utilisation des contrôles »
a. Présentation
Après avoir lancé Visual Basic, vous devez voir apparaître à l'écran une boîte de dialogue
vous demandant quel genre d'application voulez-vous créer?
Choisissez "Application Windows" si vous voulez créer un programme. Quant aux autres
types d'applications, laissez-les de côté pour le moment. Vous verrez alors apparaître en face
de vous une fenêtre fragmentée en plusieurs petites fenêtres. Au premier abord, cela doit
certainement vous effrayer de voir une multitude de mini fenêtres. Ne vous inquiétez pas,
votre comportement est tout à fait normal. N'importe quel NEWBIE aurait eu ce
comportement.
5
Moi-même, je l'ai été et j'ai pensé au début que Visual Basic était un logiciel trop compliqué
pour moi et j'ai voulu laisser tomber ce fabuleux logiciel. Mais ce qui m'a encouragé à
continuer à utiliser Visual Basic, c'est la possibilité de créer un programme même si ce n'est
qu'une simple petite application car je sais qu'après je pourrai concevoir des programmes plus
élaborés au fur à mesure que j'acquiers de nouvelles connaissances.
Ca y est? Vous êtes décidé à continuer à apprendre ce langage informatique et faire partie
de la communauté des programmeurs? Alors, allons-y! Commençons par décrire toutes ces
multitudes de fenêtres.
La partie supérieure de la fenêtre est formé du système de menus et d'une
barre d'outils tout comme d'autres logiciels (Office, Lotus,...).
La partie de gauche est constituée de la boîte à outils. (Attention, ne
confondez pas barre d'outils avec boîte à outils. La barre d'outils est une
version simplifiée du système de menus. Elle permet d'accéder plus
rapidement aux sous-commandes du système de menus.) Quant à la boîte à
outils, elle permet de sélectionner les contrôles (ou si voulez "objets"), puis
ensuite de les placer sur la partie centrale de la fenêtre.
Pour placer un contrôle, sélectionnez d'abord un contrôle dans la boîte à
outils, puis, tracez une zone rectangulaire sur la feuille qui se trouve au
milieu.
6
Cette feuille située au centre, n'est autre que la future interface graphique
de votre application (appelé aussi "interface utilisateur").
Enfin, la partie de droite est constituée généralement de 2 boîtes de
dialogue :
o La 1ère est la boîte de dialogue "Projet" qui donne la liste de toutes
les feuilles qui constituent votre future application.
o La 2ème est la boîte de dialogue "Propriétés". Elle donne accès aux
propriétés du contrôle sélectionné.
7
Autres fenêtres de programmation
a. L’interface Windows
Comment créer une fenêtre?
Menu Projet, Ajouter un formulaire Windows, cliquer sur WindowsForm, une fenêtre
‘Form1’ apparaît. On a bien crée une fenêtre avec la classe WindowsForms.Form (En fait on a
crée une Classe 'Form1')
Comment ajouter un bouton?
Cliquer sur ‘Boite à Outils’ à gauche, bouton WindowsForms, puis bouton ‘Button’, cliquer
dans Form1, déplacer le curseur sans lâcher le bouton, puis lâcher le bouton : un bouton
apparaît.
Comment ajouter un label?
Un label est un contrôle qui permet d’afficher un texte. Comme pour le bouton cliquer sur
‘Boite à Outils’ à gauche, bouton WindowsForms, bouton ‘Label’ et mettre un contrôle label
sur la fenêtre.
Comment ajouter un textbox?
Un textbox est un contrôle qui permet de saisir un texte. Comme pour le bouton cliquer sur
‘Boite à Outils’ à gauche, bouton WindowsForms, bouton ‘Textbox’ et mettre un contrôle
label sur la fenêtre.
8
Comment modifier les propriétés de l'objet ?
Il suffit ensuite de modifier les propriétés de l'objet pointé (celui qui est entouré de petits
carrés) pour lui donner l’aspect désiré. Les propriétés sont accessibles dans la fenêtre de
propriétés de droite.
Dans le code des procédures les propriétés des objets sont aussi accessibles.
Button1.Text="OK" permet par exemple de modifier la propriété Text d'un bouton.
Noter que pour modifier la taille des objets, on peut le faire très facilement à la souris en
cliquant sur les petits carrés entourant l'objet et en tirant les bords. (On peut interdire les
modifications de taille et de position des contrôles par le menu Format puis verrouiller les
contrôles une fois que leurs tailles et positions est bien définies.)
Tous les objets ont des propriétés communes.
Celles héritées de la Classe ‘Control' qu’il faut connaître:
Name : il s’agit du nom de l’objet tel qu’il est géré par l’application. Par défaut, VB baptise
tous les objets que vous créez de noms génériques, comme Form1, Form2, Form3 pour les
fenêtres, List1, List2 pour les listes...
Accessible en mode conception uniquement. Il est vivement conseillé, avant toute autre chose,
de rebaptiser les objets que vous venez de créer afin de donner des noms plus évocateurs. Le
bouton sur lequel est écrit « OK » sera nommé BoutonOK. La liste qui affiche les utilisateurs
sera nommée ListUtilisateurs. Il est conseillé de débuter le nom de l’objet par un mot
évoquant sa nature: BoutonOk ou BtOk ou ButtonOk, btnOk c’est comme vous voulez.
Microsoft conseille:
o btn pour les Boutons
o lst pour les ListBox
o chk pour les CheckBox
o cbo pour les combos
o dlg pour les DialogBox
o frm pour les Form
o lbl pour les labels
o txt pour les Textbox
o tb pour les Toolsbar
9
o rb pour les radiobutton
o mm pour les menus
o tmr pour les timers
Text : il s’agit du texte qui est associé à l’objet. Dans le cas d’une fenêtre c’est le texte qui
apparaît dans la barre de titre en haut. Pour un TextBox ou un Label c’est évidement le texte
qui est affiché.
On peut modifier cette propriété en mode conception ou dans le code :
Exemple : Avec du code comment faire pour que le bouton ButtonOk porte l’inscription ‘Ok’
ButtonOk.Text= "Ok"
Enabled : « accessible » Indique si un contrôle peut répondre à une interaction utilisateur.
La propriété Enabled permet l'activation ou la désactivation des contrôles au moment de
l'exécution. Vous pouvez désactiver les contrôles ne s'appliquant pas à l'état actuel de
l'application. Vous pouvez également désactiver un contrôle pour interdire son utilisation. Par
exemple, un bouton peut être désactivé pour empêcher l'utilisateur de cliquer dessus. Si un
contrôle est désactivé, il ne peut pas être sélectionné. Un contrôle désactivé est généralement
gris.
Exemple : désactiver le ButtonOk
ButtonOk.Enabled=False
Visible : Indique si un contrôle est visible ou non. ButtonOk.Visible=False fait disparaître le
bouton. Attention pour rendre visible une fenêtre on utilisa la méthode .Show.
Font : Permet le choix de la police de caractères affichée dans l’objet.
10
A.U : 2013/2014
ISET kef , Département informatique
Nom du module : Atelier Programmation Evénementielle
Enseignant : Mr. Boukhchim Mossaab
TP N°1 Manipulation des objets
Nous en savons à présent suffisamment pour commencer à mettre pour de bon les mains dans
le cambouis. Ouvrons donc la boîte à outils, et regardons ça de près. Que trouvons-nous ?
La classe Form
La classe Form (qu'on appelle également le formulaire), issue de la classe
Windows.Form, est l'élément de base, obligé et fondamental, de toute application VB pour
Windows. C'est sur une Form, et uniquement sur une Form, que nous pourrons
éventuellement poser d'autres contrôles. Corollaire de cette proposition, c'est également dans
la Form que seront rassemblées toutes les procédures événementielles liées aux contrôles que
nous aurons créés sur cette Form.
Nous pouvons d'entrée noter plusieurs propriétés de la classe Windows.Form (donc de
tous les objets Form créés à partir de cette classe), propriétés que nous retrouverons dans la
plupart, sinon dans la totalité des autres contrôles proposés par VB :
Name : il s'agit du nom de l'objet, exactement comme une variable porte un nom de
variable. La valeur de cette propriété n'est donc pas visible à l'écran : il s'agit d'un nom
qui sert uniquement dans le code, pour désigner l'objet en question.
Text : une autre propriété quasi-universelle des contrôles est le texte qui leur est
associé à l'écran. Pour une Form, il s'agira du texte qui figure en haut, dans la barre de
titre. À l'inverse de la propriété Name, Text ne joue aucun rôle du point de vue du
code, et un rôle essentiel du point de vue de l'interface.
Une erreur à ne pas faire : Il ne faut évidemment pas confondre les propriétés Name et Text,
dont le rôle n'a vraiment rien à voir.
11
Size : Il s'agit évidemment de la taille, autre propriété partagée par la presque totalité
des contrôles. Il faut remarquer que la propriété Size est d'un type particulier, le type
Size, qui est un type structuré composé de deux Integer. Pour modifier sa valeur par du
code, c'est donc un peu sportif : il faut utiliser une variable de type Size déjà existante,
ou, le plus souvent, la créer à la volée par le constructeur New. Pour fixer par exemple
la taille de la Form à 500 pixels sur 300, et sachant que la manière la plus simple de
désigner la Form dans une des procédures qui lui sont liées est d'employer le mot Me,
on pourra écrire :
Me.Size = New Size(500, 300)
Nous reviendrons dès les tps suivants sur cette écriture un peu étrange. En attendant,
sachons qu'il y a moyen de contourner l'obstacle, puisque plutôt que nous embêter avec ce
type Size structuré, nous pouvons, en fouinant un peu - découvrir que nous avons directement
accès à deux autres propriétés, Height et Width, beaucoup plus maniables car de type Integer.
Ainsi, la ligne ci-dessus pourra avantageusement être remplacée par :
Me.Width = 500
Me.Height = 300
Visible : cette petite propriété booléenne rend des services inestimables, puisqu'elle
permet de masquer (quand elle vaut False) n'importe quel contrôle
Startposition : qui détermine la position de la fenêtre sur l'écran lors du lancement de
l'application.
BackgroundImage : qui permet de désigner une image d'arrière-plan pour une Form.
FormBorderStyle : qui détermine le type de bordures utilisé.
Côté événements, les Form sont capables d'en recevoir - autrement dit, d'en gérer - un
certain nombre. Parmi ceux-ci, les plus importants, pour commencer, sont sans doute Load et
Activate. Je m'y arrête d'autant plus volontiers qu'on a souvent une fâcheuse tendance à les
confondre, alors qu'ils sont loin d'être identiques.
L'événement Activate correspond au fait que la Form spécifiée devient la fenêtre active.
L'événement Load correspond au chargement de la fenêtre en mémoire vive.
Dans le cas d'une application qui ne compte qu'une seule Form, les deux événements
se confondent. En effet, l'unique Form se charge au lancement de l'application, devenant par
la même occasion la Form active, et le restant sans discontinuer jusqu'à la fin de cette
application.
12
Mais dès qu'une application compte plusieurs Form, les choses se passent tout
autrement. Toutes les Form vont en effet être chargées au lancement de l'application
(déclenchant ainsi les événements Load). Mais une seule sera active. Par la suite, chaque fois
que l'utilisateur passera d'une Form à l'autre, il redéclenchera l'événement Activate pour la
Form sur laquelle il vient d'atterrir.
Les événements Activate et Load se prêtent particulièrement bien à des instructions
d'initialisation : c'est là, avant que l'utilisateur ait eu le temps de faire quoi que ce soit, qu'on
remet les compteurs à zéro, qu'on remet les cases et les zones de saisie à blanc (ou qu'on y
réécrit les valeurs par défaut), etc.
La classe Button
On retrouve pour les contrôles créés à partir de la classe Button les propriétés
générales déjà évoquées ci-dessus pour les Form : Name, bien sûr, mais aussi Text, Size,
Location, Visible et bien d'autres.
Si la classe Button nous intéresse, ce n'est pas tant pour ses propriétés que pour sa
capacité à gérer un certain nombre d'événements, à commencer par le plus fréquent d'entre
eux : Click. Nous allons donc pouvoir gérer des procédures déclenchées automatiquement par
le clic sur un bouton.
La classe Label
La classe label correspond donc à une simple étiquette posée sur une Form (généralement,
pour éclairer l'utilisateur sur tel ou tel point, commenter une image ou une zone, etc.)
L'élément sans doute le plus important à retenir pour les Label est qu'il ne s'agit pas de
zones de saisie pour l'utilisateur. Ce qui n'empêche pas le contenu d'un Label de pouvoir être
modifié par le code en cours d'exécution, ni le Label de pouvoir recevoir un certain nombre
d'événements, dont le Click.
Signalons toutefois trois propriétés que possède la classe Label :
Autosize : propriété booléenne qui active (ou désactive) le redimensionnement
automatique du Label en fonction de son contenu - ce qui peut permettre par exemple
qu'une partie du texte déborde du contrôle, et devienne invisible.
Borderstyle : propriété qui permet de régler le style - ou l'absence - de bordure atour
d'un Label.
Textalign : propriété qui règle l'alignement du texte au sein d'un Label (il y a 9
possibilités, en fonction de l'alignement horizontal et vertical)
13
La classe Textbox
La Textbox, c'est par définition la zone de prédilection pour que l'utilisateur puisse saisir
des informations. Il n'y a en fait pas grand chose à en dire, sinon que la Textbox partage avec
les autres classes la plupart des propriétés standards dont nous avons déjà parlé à plusieurs
reprises.
Un détail qui a toutefois son importance : la propriété Text d'une Textbox désigne ce qui
se trouve à l'intérieur de la Textbox. Autrement dit, ce qu'aura saisi l'utilisateur. Par
conséquent, nous pouvons en déduire que tout ce que saisit l'utilisateur via une Textbox,
même lorsqu'il s'agit de nombres, est traité par VB comme une chaîne de caractères.
Naturellement, dans certaines circonstances, des conversions vont s'imposer...
Je mentionne toutefois quelques propriétés typiques de la classe Textbox, qui valent le
coup d'être signalées :
Charactercasing : qui permet de convertir d'autorité le contenu en majuscules ou en
minuscules
Multiline : qui autorise ou non la saisie de plusieurs lignes dans le contrôle
Passwordchar : qui permet de convertir d'office, à l'affichage uniquement, le texte
tapé en un caractère (typiquement, l'astérique, pour des mots de passe)
Readonly : propriété booléenne qui interdira éventuellement à l'utilisateur de modifier
le contenu de la Textbox.
14
Exercices TP1 « Manipulation Des Objets »
Avec tout ce que vous avez lu jusque là, vous avez largement de quoi commencer à
vous dérouiller les pattes (et les neurones).
EXERCICE 1 :
Créer un projet permettant de développer l’application dont l’interface est comme suite :
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
Ecrire en suite le code d’événements qui
permettent les fonctionnalités suivantes :
1. Un clic sur le bouton effacer le
contenu du texte boxe s’efface.
2. Un clic sur le bouton Quitter arrête
l’application.
15
EXERCICE 2 :
Créer un projet permettant de développer l’application dont l’interface est comme suite :
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
EXERCICE 3 :
Créer un projet permettant de développer l’application dont l’interface est comme suite :
Ecrire en suite le code d’événements qui
permettent les fonctionnalités suivantes :
1. Un clic sur le bouton visualiser
affiche en clair le mot de passe tapé.
2. Un clic sur le bouton effacer le
contenu des deux textboxes s’efface.
3. Un clic sur le bouton Quitter arrête
l’application.
Ecrire en suite le code d’événements qui
permettent les fonctionnalités suivantes :
1. Un clic sur le bouton nouveau le
contenu des textboxes s’efface pour
saisir deux nouveaux nombres.
2. Le choix d’un type d’opération
permet d’afficher le résultat et le
type d’opération effectuée.
3. Un clic sur le bouton Quitter arrête
l’application.
16
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
EXERCICE 4 :
Écrire un programme en VB qui permet de simuler une calculatrice.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
17
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
…………………………………………………………………………………….
18
A.U : 2013/2014
ISET kef , Département informatique
Nom du module : Atelier Programmation Evénementielle
Enseignant : Mr. Boukhchim Mossaab
TP N°2 Manipulation des objets
Nous pouvons maintenant reprendre le cours de nos pensées et nous livrer à notre
activité favorite : farfouiller dans la boîte à outils pour en sortir tous les jolis jouets qu'elle
contient.
La classe Checkbox
La Checkbox, c'est cette charmante petite case carrée que vous connaissez bien :
Passons rapidement sur les propriétés que les Checkbox partagent avec la plupart des
autres classes, pour en venir à celle qui nous intéresse au premier chef : celle qui nous permet
de savoir si une Checkbox est cochée ou non (si nous l'utilisons en lecture), ou de faire en
sorte que Checkbox soit cochée ou non (si nous l'utilisons en écriture). Il s'agit de Checked :
propriété booléenne, qui vaut naturellement True lorsque la case est cochée et False
lorsqu'elle ne l'est pas.
Remarques anticipatrices :
Les Checkbox sont parfois rassemblées dans un conteneur, qui les présente comme
faisant partie d'un même groupe. Cette présentation est purement décorative : elle ne remet
jamais en cause le fonctionnement de la Checkbox, toujours individuel et indépendant de ses
congénères.
Il nous faut enfin mentionner le principal événement associé aux CheckBox : il s'agit
de CheckChanged, qui est déclenché chaque fois que la case est cochée ou décochée.
19
Les classes Radiobutton, GroupBox
Deux d'un coup, vous vous rendez compte ? Mais ce ne sont pas les plus pénibles.
Voilà tout de suite une illustration de notre propos :
Le RadioButton, dans sa forme classique, n'est donc autre que la célèbre petite case
ronde. Par définition, cette case ne fonctionne qu'en groupe, conjointement avec d'autres,
puisque par principe, une seule des cases d'un même groupe peut être cochée à la fois. Dit
autrement, cocher une case d'un groupe décoche automatiquement les autres cases du groupe.
Ce groupe est défini par ce qu'on appelle un conteneur, qui peut au choix être un objet
de la classe GroupBox.
Un RadioButton appartient donc au même groupe qu'un autre Radiobutton s'il est
placé dans le même conteneur (généralement, un GroupBox). Ce simple fait suffit à faire
marcher les Radiobutton les uns avec les autres. Il n'y a pas une seule ligne de code à écrire
pour cela.
La propriété la plus utilisée du Radiobutton est évidemment Checked, propriété
booléenne qui renvoie (ou définit) si un bouton radio est coché ou non.
20
La classe Listbox
La Listbox, par définition :
contient exclusivement des items de type String.
graphiquement, se présente toujours sous une forme "développée" (ce n'est pas
une liste déroulante).
impose un choix parmi les items proposés (ce n'est pas une liste modifiable, où
l'on peut entrer une valeur qui n'est pas proposée dans la liste)
possède ou non une barre de défilement verticale (voire horizontale), selon le
nombre d'éléments présents dans la liste et la place disponible pour les afficher
(l'apparition et la disparition des barres de défilement sont gérées de manière
automatique par VB, même si on peut toujours bidouiller cela via certaines
propriétés).
Pour les Listbox, on va trouver plusieurs propriétés concernant le mode d'affichage, dont entre
autres :
Multicolumn : propriété booléenne qui permet d'afficher les items sur
plusieurs colonnes.
Et une propriété fondamentale pour son comportement :
SelectionMode : qui indique si l'on autorise ou non la multisélection des items
de la liste.
On peut, comme dans n'importe quelle collection, ajouter un élément dans une liste via
la méthode Add :
Listbox1.Items.Add("Nouvel élément")
Pour supprimer un élément, on n'a que l'embarras du choix. La méthode Remove
demandera de fournir l'élément lui-même...
Listbox1.Items.Remove("Midnight Jokers")
...tandis que la méthode RemoveAt demandera un indice :
Listbox1.Items.RemoveAt(5)
21
Enfin, Clear procèdera au nettoyage complet de la liste, en supprimant tous les
éléments d'un seul coup d'un seul :
Listbox1.Clear
Le but d'une liste, c'est de permettre à l'utilisateur d'en sélectionner un ou plusieurs
items. Cette action de l'utilisateur affectera les propriétés :
SelectedItem : qui désigne sous forme de chaîne de caractères l'élément
actuellement sélectionné. Si aucun élément n'est sélectionné, cette propriété
vaut une chaîne vide.
SelectedIndex : qui désigne par son indice l'élément actuellement sélectionné.
Si aucun élément n'est sélectionné, cette propriété vaut -1.
Lorsqu'une sélection multiple est possible sur une Listbox, ces deux propriétés
renvoient alors des collections, dans lesquelles on peut partir à la pêche pour récupérer les
différents éléments.
En ce qui concerne les événements, on peut bien sûr gérer les Listbox par l'événement
Click. Mais un événement propre est disponible, qui ne se déclenche qu'en cas de changement
de l'item sélectionné : il s'agit de SelectedIndexChanged. Cet événement est à la fois plus
restrictif et plus large que le Click. Plus restrictif, car il ne se déclenche pas en cas de clic sur
un item déjà sélectionné. Plus large, car il détectera un changement de sélection survenant y
compris suite à une manoeuvre au clavier.
22
La classe Combobox
Il s'agit d'une classe-fille à la fois de la classe Listbox et de la classe Textbox. Elle en
hérite donc l'essentiel des propriétés. En gros, on peut considérer qu'une ComboBox, c'est une
liste modifiable et/ou déroulante :
Exercices TP2 « Manipulation Des Objets »
Pour réussir ces exercices, vous disposez de toutes les connaissances nécessaires.
EXERCICE 1 :
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
Cette application est une
généralisation du célèbre exercice
« compter les ‘a’ dans une phrase ».
Ici il y a 3 zones de recherche
possible, la recherche doit se faire
dans les zones correspondant aux
coches et seulement celles-ci. Les
résultats obtenus seront cumulés. Le
caractère recherché doit être tapé
dans la zone ‘Caractère recherché’.
Écrire le code correspondant à
cette interface.
23
EXERCICE 2 :
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
EXERCICE 3:
-Créer un projet
permettant de développer
l’application dont
l’interface est comme
suite :
-Ecrire en suite le code
d’événements qui
permettent de répondre au
fonctionnalité de chaque
élément de l’interface.
-Les éléments de chaque
liste doivent être affiché
en ordre.
- Créer un projet permettant de
développer l’application dont
l’interface est comme suite :
-Ecrire en suite le code
d’événements qui permettent les
fonctionnalités suivantes :
Le choix de la couleur du
fond n’est possible que si la case à
cocher « Modifier couleur est
cochée »
Le choix du style du texte n’est
possible que si la case à cocher
« Modifier le style est cochée »
24
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
EXERCICE 4:
Le gérant d’un restaurant veut automatiser son activité, voici l’interface qu’il souhaite avoir.
L’objectif est d’afficher le montant du déjeuner en cliquant sur Addition.
Sachant que :
Si on paye par Espèce ou carte de crédit aucune majoration n’est attribuée.
Si on paye par Bon il y a une majoration de 10% dans le prix et si on paye par chèque une
majoration de 20% aussi.
Écrire la procédure Init
permettant de réinitialiser la
feuille et appeler cette
procédure dans Reinitialiser.
Ecrire la fonction
Remise permettant de faire une
remise de 10% du montant
global si ce dernier dépasse 8
DT. Appeler cette fonction
dans l’emplacement approprié.
Écrire la fonction
CheckInputs permettant de
vérifier qu’il y au moins un
plat et un type de payement
sélectionné. Sachant que
CheckInputs retourne true si
les entrées sont correctes et
false dans le cas contraire,
appeler cette fonction dans son
emplacement.
25
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
26
A.U : 2013/2014
ISET kef , Département informatique
Nom du module : Atelier Programmation Evénementielle
Enseignant : Mr. Boukhchim Mossaab
TP N°3 Manipulation des chaines de caractère
Nous pouvons maintenant reprendre le cours de nos pensées et nous livrer à notre activité
favorite : farfouiller dans le langage basic pour en sortir tous les jolis jouets qu'elle contient.
Fonctions de chaîne de caractères
Trim, LTrim, RTrim :
Renvoie une valeur de type Varient (String) contenant une copie d’une chaîne de caractères
en supprimant les espaces de gauche (LTrim), les espaces de droite (RTrim) ou les deux
(Trim). Syntaxe
LTrim(string) RTrim(string) Trim(string)
Exemples
Ltrim (“ Test”): donne la chaine “Test”
Rtrim(“Test ”): donne la chaine “Test”
UCase, LCase
Renvoie une valeur de type Variant(String) contenant la chaîne indiquée, convertie en
majuscules, minuscules. Syntaxe
UCase (string) LCase (string)
InStr
Renvoie une valeur de type Variant (Long) indiquant la position de la première occurrence
d’une chaîne à l’intérieur d’une autre chaîne. Syntaxe
Instr ([PositionDébut ,] chaîne 1, chaîne 2)
27
Exemple
Instr (1, « Bonjour », « jour ») : retourne 4.
Mid
Renvoie une valeur de type Variant (String) contenant un nombre indiqué de caractères
extraits d’une chaîne de caractères. Syntaxe
Mid (string, start [,lengh])
Exemple
Mid(“bonjour”,4,4) : retourne “jour”
Len
Renvoie une valeur de type long contenant l nombre de caractères d’une chaîne de caractères
ou le nombre d’octets requis pour stocker une variable. Syntaxe
Len (string | VarName)
Exercices TP3 « Manipulation Chaine de caractère »
Pour réussir ces exercices, vous disposez de toutes les connaissances nécessaires.
Exercice 1
Concevoir et réaliser une application en VB qui lit une chaîne de caractères et affiche le
pourcentage des lettres voyelles.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
28
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
Exercice 2
Concevoir et réaliser une application en VB qui lit une chaîne de caractères contenant des
parenthèses ouvrantes et fermantes et doit affiché si le parenthèsage est cohérent ou non.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
29
Exercice 3
Concevoir et réaliser une application en VB qui lit deux chaînes de caractères et qui affiche
les caractères en commun.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
Exercice 4
Concevoir et réaliser une application en VB qui lit 20 valeurs réelles et qui détermine la
moyenne de valeurs strictement positives et la moyenne de valeurs strictement négatives. On
n'utilise qu’un seul ‘Textbox’.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
30
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
Exercice 5
Concevoir et réaliser une application en VB qui saisit un nombre et qui détermine combien de
fois il est divisible par 2.
Exemple
11 est divisible 0 fois par 2
4 est divisible 2 fois par 2
8 est divisible 3 fois par 2
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
31
A.U : 2013/2014
ISET kef , Département informatique
Nom du module : Atelier Programmation Evénementielle
Enseignant : Mr. Boukhchim Mossaab
TP N°4 Les événements Claviers
Il est temps à présent d'examiner plus en détail les différents événements que nous
permet de gérer VB. Car il faut bien l'avouer, jusqu'ici, à part des clics, des clics et encore des
clics, on n'a pas vu grand chose. Et ce serait bien dommage de s'en tenir là.
Les événements claviers
Dans un certain nombre d'applications, on peut souhaiter attribuer certaines conséquences
à la frappe de certaines touches du clavier. Par exemple, la touche F1 doit ouvrir le fichier
d'aide.
Tout cela suppose que la frappe de telle ou telle touche du clavier soit interprétée par le
logiciel comme un événement. Aucun problème, Bill Gates s'occupe de nous, et pour ce faire
nous offre trois événements, pas un de moins.
Keypress : cet événement détecte le fait qu'un caractère a été frappé au clavier.
Keydown et Keyup : ces deux événements, qui fonctionnent de pair, se déclenchent
lorsqu'une touche du clavier est enfoncée (Keydown) ou relâchée (Keyup). La
caractéristique de ces deux événements est qu'ils détectent l'état physique du clavier.
Remarque :
Cela signifie que les touches ne produisant pas de caractères, telles les touches de fonction, ou
les touches de direction, ne génèrent pas l'événement Keypress, mais génèrent les événements
KeyDown et KeyUp
Revenons-en à présent à un aspect sur lequel, jusqu'à maintenant, nous ne nous sommes
pas arrêtés autant qu'il le mérite : je veux parler des paramètres en entrée des procédures
événementielles.
32
Pour ce qui est des généralités sur les paramètres en entrée d'une procédure, je ne vous
ferai pas l'affront de vous réexpliquer ce dont il s'agit. Vous êtes blindés en algo, et je sais que
jamais vous ne vous seriez lancé dans ce cours sans être des cadors sur la question. Passons
donc rapidement, comme il sied de le faire en présence d'experts.
Dans une procédure événementielle, nous avons toujours pu constater, quel que soit
l'événement, que VB organisait le passage de deux paramètres : le fameux Sender, et le
mystérieux e.
Fameux, le Sender, puisqu'on a déjà vu qu'il s'agissait d'une variable faisant référence
à l'objet qui a déclenché la procédure. Ceci s'est avéré particulièrement utile lorsque
plusieurs objets étaient branchés (par exemple en cas de clic) sur la même procédure : le
paramètre Sender nous a alors permis, au sein de cette procédure, d'identifier lequel des
contrôles avait déclenché la procédure, et d'avoir accès à ses propriétés.
Le paramètre e est également une variable qui désigne un objet. Mais cet objet n'est pas
le contrôle qui a déclenché la procédure (évidemment, puisque c'est Sender, on ne va pas
mettre deux fois la même information sous deux noms différents, eh, patate). D'ailleurs, le
paramètre objet e n'est pas un contrôle du tout. Il représente, si l'on veut, les conditions, ou
les résultats, comme on préfère, de l'événement lui-même. La nature de ses propriétés
variera donc d'un événement à l'autre.
S'il s'agit d'un événement Click, disons-le tout net, il n'y a pour ainsi dire aucune
propriété dans e, car rien n'est plus tristement banal et sans caractéristiques particulières qu'un
clic. En revanche, s'il s'agit d'un événement clavier, c'est tout de suite beaucoup plus
intéressant.
Par exemple, lors d'un KeyDown ou d'un KeyUp, e possèdera tout un tas de propriétés
booléennes (Shift, Alt) ou numériques (Keycode) nous permettant de savoir dans les menus
détails quel était l'état du clavier lors du déclenchement de l'événement.
Lors d'un KeyPress, nous trouvons pour le paramètre en entrée e la propriété caractère
KeyChar, contenant le caractère généré par la touche pressée.
Ainsi, le code qui afficherait dans une MessageBox une à une les touches frappées au
clavier serait :
33
Private Sub Button1_KeyPress(ByVal sender As Object, ByVal e As
System.Windows.Forms.KeyPressEventArgs) Handles Button1.KeyPress
Dim tutu As Integer
tutu = MsgBox(e.KeyChar, vbOKOnly, "Touche frappée :")
End Sub
Et voilà le travail, enveloppez, c'est pesé.
Il nous reste toutefois un petit détail à régler avant d'en avoir définitivement terminé avec
les événements clavier. Imaginons que nous voulions réaliser un "appel à l'aide" avec la
touche F1. Pas le choix, nous devrons passer par un KeyDown (car la touche F1 n'engendrant
aucun caractère, elle ne produit donc pas d'événement Keypress). Mais là où ça coince, c'est
quand on réfléchit à quel contrôle nous devrons affecter l'événement. En effet, le focus étant
supposé pouvoir se trouver sur bien des endroits de la Form lorsqu'on appuiera sur la touche
F1, il faudrait en bonne logique créer une procédure Chmoll.KeyDown pour chacun des
contrôles Chmoll susceptibles de posséder le focus. On n'est pas rendu.
Heureusement, il y a une autre possibilité : faire en sorte que la Form court-circuite tous
les contrôles qui se trouvent sur elle en cas de frappe de touche au clavier. Il suffit pour cela
de régler sa propriété KeyPreview (qu'on pourrait traduire approximativement par
"interception du clavier") à True. On n'a plus alors qu'à écrire une seule procédure, celle qui
gère l'événement KeyDown sur la Form. Et dans cette procédure, à tester si la touche frappée
était bien F1, auquel cas on déclenche l'ouverture de l'aide. Et hop, comme qui rigole.
Exercices TP4 « Événements Clavier »
Pour réussir ces exercices, vous disposez de toutes les connaissances nécessaires.
Exercice 1
Concevoir et réaliser une interface en VB contenant un Textbox numérique
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
34
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
Exercice 2
Concevoir et réaliser une interface en VB contenant un Textbox qui n’accepte que les
alphabets.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
35
A.U : 2013/2014
ISET kef , Département informatique
Nom du module : Atelier Programmation Evénementielle
Enseignant : Mr. Boukhchim Mossaab
TP N°5 Les menus
Une application informatique sans menus, c'est un peu comme un restaurant sans
ordinateurs. Euh... Je m'égare. Bon, avec ce tout petit, petit chapitre, on va pouvoir reposer un
peu nos neurones surmenés.
Les menus
1. Le concepteur de menus
Si l'on veut un ensemble de menus dans sa Form, il faut créer un objet (un seul) de la
classe MainMenu, classe disponible sous forme de contrôle dans la boîte à outils. Bien sûr,
on peut aussi ajouter un menu par du code, mais étant donné le peu de cas où cette procédure
s'avère nécessaire, j'en passerai pudiquement les détails sous silence.
Une fois l'objet MainMenu posé sur la Form, le concepteur de menus permet, en
cliquant sur ce MainMenu, d'entrer à l'intérieur toute la série des commandes dont on
souhaitera disposer. C'est extrêmement facile et ergonomique, il suffit de cliquer à côté, ou
en-dessous, de l'élément adéquat, pour pouvoir entrer d'autres éléments. Ce faisant, on crée
des objets de la classe MenuItem. Ainsi, chaque objet MainMenu comprend un certain
nombre d'objets de la classe MenuItem, c'est-à-dire d'éléments de menu.
A signaler que les menus sont organisés les uns par rapport aux autres sous la forme d'un
emboîtement de collections : les menus principaux (typiquement : Fichier, Édition, Affichage,
etc.) sont les MenuItems membres de la collection de l'objet MainMenu. De même, les
menus "secondaires" comme Ouvrir, Enregistrer, Enregistrer sous, etc. seront membres de la
collection du menu Fichier. Et ainsi de suite.
Propriétés des menus
Pour introduire une barre de séparation entre deux menus placés verticalement l'un
sous l'autre, il suffit de créer un élément possédant comme propriété Text un simple tiret
(celui du signe de la soustraction).
36
Pour créer une touche de raccourci (celle qui permettra, conjointement à Alt, de
déclencher la commande en question), il suffira de placer le signe & avant la lettre concernée
dans le texte du menu.
la propriété Checked, si elle vaut True, permet de faire figurer devant le menu un
signe indiquant son activation. Si la propriété RadioChecked vaut également True, ce signe
est un cercle plein.
les propriétés ShortCut et ShowShortCut permettent respectivement d'attribuer une
combinaison de touches du clavier à un menu, et de les afficher à côté du menu en question.
Les événements liés aux menus
Il s'agit pour l'essentiel de l'événement Click, lorsqu'on parle d'une commande ordinaire.
Dans le cas d'un menu qui n'est rien censé déclencher, hormis l'apparition sur sa droite d'un
sous-menu, on pourra utiliser si besoin l'événement PopUp.
Enfin, le simple fait qu'un élément soit en surbrillance, suite au passage de la souris ou du
clavier, déclenche un événement Select.
2. Menus contextuels
Il s'agit du menu qui apparaît lors d'un clic droit de la souris, et dont le contenu varie
selon l'endroit où se trouve le curseur. Pour qu'un, ou plusieurs contrôles disposent d'un menu
contextuel, la procédure à suivre est très simple.
On commence par poser sur la Form autant de contrôles ContextMenu qu'on aura
besoin de menus contextuels différents.
On édite chacun de ces menus, en y créant les différents éléments voulus, via la même
interface que pour les MainMenu.
On affecte à chaque contrôle le ContextMenu qui lui revient par sa propriété...
ContextMenu.
Évidemment, tout cela peut également être réalisé par des liges de code, mais là encore,
nous passerons tout cela sous silence, l'intérêt en étant réservé aux spécialistes.
A noter qu'un ContextMenu génère un événement PopUp lorsqu'il apparaît, et que tout
comme pour un menu ordinaire, le clic sur l'un de ses éléments provoque un événement...
Click.
37
Exercices TP5 « Les menus »
Pour réussir ces exercices, vous disposez de toutes les connaissances nécessaires.
EXERCICE 1 :
Créer une application MDI composée de deux interfaces. La première contient un menu qui
assure la sortie de l’application et la modification dynamique de la surface d’un cercle. Et
dans la seconde on trouve le cercle à modifier.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
38
EXERCICE 2 :
Ecrire une application en VB qui permet de codifier l’interface suivante.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
39
A.U : 2013/2014
ISET kef , Département informatique
Nom du module : Atelier Programmation Evénementielle
Enseignant : Mr. Boukhchim Mossaab
TP N°6 Les fichiers
Nous pouvons maintenant reprendre le cours de nos pensées et nous livrer à notre activité
favorite : farfouiller dans le langage basic pour en sortir tous les jolis jouets qu'elle contient.
Les fichiers
I. Rappel algorithmique
1. Définition
Un fichier est une suite d’octets enregistrés sous un même nom sur un support de données
(Disque, Disquette, CD-ROM…).
2. Accès
Il existe traditionnellement deux modes d'accès aux fichiers :
L’accès séquentiel : traitement séquentiel des informations.
L’accès direct : se placer immédiatement sur l’information souhaitée.
II. Les fichiers en VB
Visual Basic fournit trois types d'accès au fichier :
L'accès séquentiel, pour lire et écrire des fichiers 'texte' de manière continue, chaque
donnée est enregistrée successivement du début à la fin; les enregistrements n'ont pas
la même longueur, ils sont séparés par un séparateur (des virgules ou des retours à la
ligne).
L'accès aléatoire (Random), (on le nomme parfois accès direct) pour lire et écrire des
fichiers texte ou binaire constitués d'enregistrements de longueur fixe; on peut avoir
directement accès à un enregistrement à partir de son numéro.
L'accès binaire, pour lire et écrire dans tous les fichiers, on lit ou écrit un nombre
d'octet désiré à une position désirée..C'est comme l'accès direct, on peut lire le 36ème
octet…
40
1. Les opérations
a. FileOpen
Pour ouvrir un fichier on utilise FileOpen.
FileOpen (FileNumber, FileName, Mode, Access, Share, RecordLength)
Paramètres de FileOpen
FileNumber
A tout fichier est affecté un numéro unique, c'est ce numéro que l'on utilisera pour indiquer
sur quel fichier pratiquer une opération.. Utilisez la fonction FreeFile pour obtenir le prochain
numéro de fichier disponible.
FileName
Obligatoire. Expression de type String spécifiant un nom de fichier. Peut comprendre un nom
de répertoire ou de dossier, et un nom de lecteur.
Mode
Obligatoire. Énumération OpenMode spécifiant le mode d'accès au fichier : Append, Binary,
Input (séquentiel en lecture), Output (séquentiel en écriture) ou Random (accès aléatoire).
Access
Facultatif. Mot clé spécifiant les opérations autorisées sur le fichier ouvert : Read, Write ou
ReadWrite. Par défaut, la valeur est OpenAccess.ReadWrite.
Share
Facultatif. Spécifiant si un autre programme peut avoir en même temps accès au même fichier
: Shared (permet l'accès aux autres programmes), Lock Read (interdit l'accès en lecture), Lock
Write (interdit l'accès en écriture) et Lock Read Write (interdit totalement l'accès). Le
processus OpenShare.Lock Read Write est paramétré par défaut.
RecordLength
Facultatif. Nombre inférieur ou égal à 32 767 (octets). Pour les fichiers ouverts en mode
Random, cette valeur représente la longueur de l'enregistrement. Pour les fichiers séquentiels,
elle représente le nombre de caractères contenus dans la mémoire tampon.
41
b. EOF
EOF (NuméroFichier) veut dire 'End Of File', (Fin de Fichier) il prend la valeur True si on
est à la fin du fichier et qu'il n'y a plus rien à lire.
c. LOF
LOF (NuméroFichier) veut dire 'Length Of File', il retourne la longueur du fichier.
d. FilePut
On ajoute 1 pour créer un nouvel enregistrement.
FilePut(FileNum, Unevariable,last+1 )
e. FileGet
Pour lire un enregistrement (le premier par exemple):
FileGet(FileNum, Unevariable, 1) ;
Exercices TP6 « Les fichiers »
Pour réussir ces exercices, vous disposez de toutes les connaissances nécessaires.
EXERCICE 1 :
Soit un fichier fétudiant contenant les informations suivantes :
NCE
Nom
Prénom
Ville
Code ville
Année de naissance
Année du bac
Nature du bac
Année 1er inscription
Classe
Département
Ecrire une application en VB permettant d’alimenter le fichier fétudiant.
42
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
EXERCICE 2 :
Créer à partir du fichier fétudiant un fichier F_DSI21 contenant les étudiants de la classe
« DSI21 »
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
43
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
EXERCICE 3 :
Ecrire un programme qui calcule le nombre d’étudiants du département informatique ayant
obtenu leur bac l’an 2000.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
44
A.U : 2013/2014
ISET kef , Département informatique
Nom du module : Atelier Programmation Evénementielle
Enseignant : Mr. Boukhchim Mossaab
TP N°7 Les bases de données
I. Introduction
VB s’interface avec pratiquement tous les types de bases de données (BD), notamment à
travers son support ODBC, tout en optimisant les accès à MS Access ou SQL Serveur. Afin
de faciliter l’accès aux données, VB fournit un ensemble d’objets permettant de gérer la
structure d’une BD ainsi que l’accès aux données qui y sont stockées. Ces objets sont appelés
DAO (Database Access Object) et s’appuient sur le moteur Jet BD de Microsoft.
II. La hiérarchie des objets du modèle ADO
Les objets ADO vous offrent un accès simple et rapide aux données de tous types. Le
modèle objet ADO comporte trois principaux composants : l’objet connection, l’objet
Command et l’objet Recordset.
1. Objet Connection :
Dans le modèle objet ADO, l’objet Connection est celui qui occupe le niveau le plus
élevé. Il est utilisé pour établir une connexion entre votreapplication et une source de données
externe, telle que Microsoft SQL Server.
2. Objet Command :
L’objet Command sert à créer des requêtes, y compris des paramètres spécifiques à
l’utilisateur, pour accéder aux enregistrements d’une source de données. En règle générale,
ces enregistrements sont renvoyés au sein d’un objet Recordset.
3. Objet Recordset :
L’objet RecordSet permet d’accéder aux enregistrements renvoyés par une requête SQL.
Avec cet objet, vous pouvez naviguer dans les enregistrements renvoyés, ajouter des
enregistrements ou en supprimer
4. Objet ADO :
ADO prend en charge trois collections, Errors, Parameters et Fiels. Si elles peuvent
apporter des fonctionnalités supplémentaires à une application, ces collections ne sont pas
45
indispensables à la création de solution ADO.
Collection Errors :
La collection Errors permet de renvoyer des informations détaillées sur des erreurs
survenues pendant l’exécution, ainsi que d’autres messages émis par une source de données.
Collections Parameters :
La collection Parameters permet de passer certaines données spécifiques à une requête
paramétrée ou à des procédures stockées d’une base de données SQL server.
Collection Fields :
La collection Fields permet d’accéder à certains champs d’un objet Recordset.
III. La connexion à une base de données
L’objet Connection établit une connexion avec une source de données. Il permet à votre
application de passer des informations provenant du client (nom d’utilisateur et mot de passe
par exemple) à la base de données pour validation.
Pour utiliser ADO pour l’établissement d’une connexion à la base donnée
1. Créez une référence à la bibliothèque d’objets ADO
Avant de pouvoir utiliser ADO dans votre application Visual Basic, vous devez créer une
référence à la bibliothèque Microsoft ActiveX Data Objets 2.0
Pour créer une référence à la bibliothèque d’objets ADO
Dans le menu Projet, cliquer sur Ajouter Références
Sélectionnez Microsoft ActiveX Data Objets 2.0 Library dans l’onglet COM, puis
sur OK.
2. Déclarez un objet connection
Une fois que vous avez créé une référence à la bibliothèque d’objets ADO, vous pouvez
déclarer un objet Connection dans votre application. En vous servant de l’objet Connection,
vous pouvez alors créer l’objet Command et on crée une instance :
Dim cn as New connection
3. Spécifiez un fournisseur de données OLE DB
Une fois que vous avez créé une instance d’un objet Connection, vous devez spécifier un
fournisseur de source de données OLE DB ; Pour ce faire, définissez la propriété Provider.
L’exemple de code suivant spécifie le fournisseur de données Microsoft Jet (Access)
Cn.Provider= « Microsoft.jet.OLEDB.4.0 »
46
Le tableau suivant présente quelques-uns des fournisseurs OLE DB actuellement
disponibles :
Fournisseur De données OLE DB Description
SQLOLEDB Pour Microsoft SQL Server
MSDASQL Fournisseur OLE DB pour ODBC
MSDAORA Fournisseur OLE DB pour Oracle
4. Passer les informations sur la connexion.
La dernière étape, avant l’établissement d’une connexion avec une source de données,
consiste à spécifier les informations de connexion. Pour se faire, définissez les propriétés de la
chaîne ConnectionString de l’objet Connection. Ces propriétés sont propres à un fournisseur,
auquel elles sont passées directement, et ne sont pas traités par ADO.
Une fois ces opérations accomplies, vous pouvez établir la connexion au moyen de la
méthode Open.
Exemple 1 Connexion à une base de données Microsoft SQL Server
Une connexion à une base de données Microsoft SQL Server appelée DSI sur le serveur
MSDB par le biais du fournisseur de données SQL Server OLE DB :
cn.provider = « SQLOLEDB »
cn.ConnectionString = « User ID = sa ; Password= ; » & _
Data Source = msdb ; »&_
Initial Catalog = DSI »
Cn.open
Exemple 2 Connexion à une base de données Microsoft Access
cn.provider = « = Microsoft.Jet.OLEDB.4.0 »
cn.ConnectionString = « c:\IG31.mdb »
cn.open
IV. Déconnexion d’une source de données
Quand vous n’avez plus besoin d’une connexion à une source de données, utilisez la
méthode Close pour supprimer cette connexion. L’exemple de code suivant ferme une
connexion active à une source de données.
Cn.close
47
V. La récupération de données
La récupération des données à partir d’une source de données se fait par le biais de l’objet
Recordset déjà définie. L’objet Recordset contient les colonnes et les lignes retournées à
l’issue d’une opération spécifique (requête SQL). En vous servant de l’objet Recordset, on
peut naviguer ou bien mettre à jour des enregistrements.
1. Propriétés de l’objet Recordset
Le tableau suivant décrit les propriétés de l’objet Recordset les plus utilisées pour créer un
jeu d’enregistrements.
Propriété Description
ActiveCommand Renvoie la commande active pour le jeu d’enregistrements. ActiveConnection Renvoie la connexion active pour le jeu d’enregistrement.
CursorLocation Renvoie ou définit l’emplacement ou est géré le curseur. La valeur par défaut est adUseServer
CursorType Renvoie ou définit le type du curseur. La valeur par défaut est adOpenStatic.
LockType Renvoie ou définit le type du verrouillaged’enregistrement. La valeur par défaut est adLockReadOnly
MaxRecords Renvoie ou définit le nombre maximal d’enregistrements à renvoyer.
RecordCount Renvoie le nombre d’enregistrements contenus dans le jeu d’enregistrements.
State Renvoie l’état en cours du jeu d’enregistrements. 2. Méthodes de l’objet Recordset
Le tableau suivant décrit les méthodes de l’objet Recordset les plus utilisées pour créer un
jeu d’enregistrement
Méthode Description Open Ecécute une commande Sql et ouvre un curseur. Close Ferme le jeu d’enregistrements.
3. Un scénario de récupération de données
Par le biais de la méthode Open de l’objet Recordset
Private Sub connect_click()
Dim cn as connection
Dim rs as Recordset
Set cn = New connection
Set rs = New Recordset
Cn.Provider = “SQLOLEDB”
Cn.ConnectionString = “User ID= sa;”&_ “Initial catalog = IG”
Cn.open
rs.open (“Select * from etudiant”,cn)
End sub
48
4. Utilisation des méthodes de l’objet recordset
Passons à présent, aux principales méthodes utilisées pour gérer la récupération et la mise
à jour des données via Recordset
AddNew Crée un nouvel enregistrement.
Delete Supprime un enregistrement donné. Movefirst, MoveLast, Elles servent respectivement à revenir au premier enregistrement, à
MovePrevious, MoveNext aller au dernier enregistrement, à revenir à l'enregistrement précédent et à aller à l'enregistrement suivant.
Refresh Rafraîchit la base de donnée.
Exercices
EXERCICE 1 :
Pour réussir ces exercices, vous disposez de toutes les connaissances nécessaires.
Soit le modèle relationnel suivant :
Salarie (Matricule, Nom, Poste, E-mail, DatEmb, Salaire, NumSer, prime)
Service (NumService, NomService, Lieu)
Projet (CodePrj, NomPrj, DateDebut, dateFin)
Participation (Matricule, CodeProjet, Fonction, NbrJours)
Travail à faire :
1. Créer la base de données sous Microsoft Access
2. Créer une interface d’ajout dans la table Salarié (le contrôle de saisie est obligatoire plus
confirmation d’ajout)
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
49
3. Créer une interface d’ajout dans les tables : Service et Projet
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
4. Faire quelques enregistrements pour le test
5. Créer une interface qui permet d’augmenter le salaire de 5% pour tous les employés
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
50
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
6. Créer une interface permettant d’attribuer une prime de 80% du salaire aux employés
travaillant dans un service donné.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
7. Créer une interface permettant de retourner le nombre de jours effectué par un employé pour
un projet donné.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
51
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
8. Créer une interface d’ajout dans la table Participation (le contrôle de saisie est obligatoire
plus confirmation d’ajout)
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
9. Créer une interface d’ajout dans les tables : Service et Projet
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
52
10. Créer une feuille de recherche :
a. Affichant la liste des participants à un projet
b. Les salariés embauchés entre deux dates
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
11. Créer une interface pour afficher la liste des employés qui travaillent dans un projet donné.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
12. Créer une interface permettant d’afficher le nombre de jours de travail total effectué pour un
projet donné.
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………..
53
EXERCICE 2 :
La société Télécommerce souhaite mettre en place un système de vente sur Internet, vous étés
maintenant chargé de développer cette application en respectant le modèle relationnel suivant:
CLIENTS (NumClient, Nom, Prenom, Ville, Tele).
COMMANDES (NumCommande, DateCommande, NumProduit,, Quantité).
ETAT _COMMANDE(NumCommand, NumClient , EtatCommande).
PRODUITS (N°Produit, Libellé, PrixUnitaire, TVA).
Une fois le client fait le règlement de la commande, les produits commandés seront livrés
dans un délai ne dépassant pas 48h.
EtatCommande : décrit l‘état de la commande (En cours, valider, annuler)
TVA : 20%
Travail à faire :
1. Créer une interface de mise à jour des Client
a. Ajout (le contrôle de saisie est obligatoire et confirmation d’ajout)
b. Modification
c. Suppression
d. Boutons de navigation
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
54
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
2. Créer une interface de mise à jour des Produit
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
3. Créer une interface de mise à jour des Commande et Etat_Commande
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
55
4. Créer une feuille de recherche :
a. Commandes passés par un client
b. Recherche les commandes validées entre deux dates
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
5. Sachant qu’une remise de 3% sur tous les produits est accordée aux clients ayant
passé plus de 5 commandes. Faire les modifications nécessaires sur l’interface
Commande
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
56
6. Créer une interface pour afficher les commandes passées entre deux dates et l’état de
chaque commande
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….
7. Créer une interface permettant de lister les commandes passées durant le mois en
cours et le montant total des commandes
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
……………………………………………………………………………………
…………………………………………………………………………………….