MS VB - Net 2003
MS VB - Net 2003
MS VB - Net 2003
Visual Basic
.Net
Olivier Zimmermann
Victor Formation
Août 2003
Fiche sur VBFrance : Olixelle http://www.vbfrance.com/auteurdetail.aspx?ID= 315759
Sommaire
1. PRESENTATION ................................................................................................................ 7
1.1 HISTORIQUE....................................................................................................................... 7
1.2 NOUVEAUTES .................................................................................................................... 7
1.3 INSTALLATION ................................................................................................................... 7
2. ENVIRONNEMENT VISUAL STUDIO ........................................................................... 8
2.1 L’INTERFACE ..................................................................................................................... 8
2.2 FENETRES D’EXPLORATION ............................................................................................... 9
2.2.1 Explorateur de serveur .............................................................................................. 9
2.2.2 Explorateur de Solutions ......................................................................................... 10
2.2.3 L’affichage de classes ............................................................................................. 10
2.2.4 Fenêtre de propriétés .............................................................................................. 11
2.2.5 L’aide dynamique .................................................................................................... 11
2.2.6 La liste des tâches ................................................................................................... 11
3. GESTION DE PROJETS .................................................................................................. 12
3.1 LES SOLUTIONS................................................................................................................ 12
3.2 CREATION D’UN PROJET................................................................................................... 12
3.3 CONFIGURATION D’UN PROJET ........................................................................................ 13
4. BASES DU LANGAGE ..................................................................................................... 14
4.1 STRUCTURE DU CODE ...................................................................................................... 14
4.1.1 Formulaire .............................................................................................................. 14
4.1.2 Module ..................................................................................................................... 14
4.1.3 Les commentaires .................................................................................................... 15
4.1.4 Les régions .............................................................................................................. 15
4.2 LES VARIABLES ............................................................................................................... 16
4.2.1 Types de variables ................................................................................................... 16
4.2.1.1 Types numériques ............................................................................................ 16
4.2.1.2 Types chaîne de caractère ................................................................................ 17
4.2.1.3 Autres types ...................................................................................................... 17
4.2.2 Déclaration de variables ......................................................................................... 17
4.2.3 Portée et visibilité des variables ............................................................................. 18
4.2.3.1 Portée des variables .......................................................................................... 18
4.2.3.1 Visibilité des variables ..................................................................................... 18
4.2.4 Les tableaux............................................................................................................. 18
4.2.5 Les constantes ......................................................................................................... 19
4.2.6 Les énumérations..................................................................................................... 19
4.3 LES OPERATEURS ............................................................................................................. 20
4.3.1 Opérateur d’affectation ........................................................................................... 20
4.3.2 Opérateurs Arithmétiques ....................................................................................... 20
4.3.3 Opérateurs de comparaison .................................................................................... 21
4.3.4 Opérateurs de concaténation .................................................................................. 21
4.3.5 Opérateurs logiques ................................................................................................ 22
4.4 LES STRUCTURES DE CONTROLE ...................................................................................... 22
1.1 Historique
Version Nouveautés
1.0 Sortie en 91, Visual Basic innove en particulier grâce à son environnement de
développement permettant de masquer les tâches fastidieuse
3.0 Evolution du langage, apparition de nouvelles fonction et de structures de contrôle
(select case)
4.0 Sorti en 96, la version 4.0 marque une étape importante dans l’évolution du
langage :
- Création d’application 32 bits
- Création et utilisation de DLL
- Apparition des fonctionnalités Objet (Classes)
5.0 Disparition des applications 16 bits et stabilité accrue du langage
6.0 Peu d’évolution sur le langage mais apparition de la technologie ADO
(remplaçante de DAO et RDO) et des outils de connexion aux sources de données
(DataEnvironment)
1.2 Nouveautés
La version .Net (ou version 7.0) de Visual Basic et plus généralement de l’IDE Visual
Studio marquent une étape importante dans l’évolution du langage. L’élément principal de
l’infrastructure .NET est le CLR (Common Language Runtime), langage offrant un ensemble
de classe permettant à l’utilisateur d’interagir avec le système. Ces classes peuvent être
utilisée avec n’importe quel langage .Net (Vb, C++, C#) car elle font partie d’une norme
commune : le CLS (Common Language Specification).
Une autre des révolutions du .Net réside dans le MSIL (Microsoft Intermediate
Language) : les applications réalisées avec Vb .Net sont d’abord compilés en pseudo code, le
MSIL, et c’est lors de l’exécution que le compilateur (JIT pour Just In Time) compile le code
MSIL afin de le rendre exécutable par le processeur utilisé. L’avantage de ce système est
double :
- Gain de ressource lors de l’exécution car seules celle devant être utilisées seront
chargées et de ce fait, leur installation préalable n’est pas obligatoire
- Portabilité des applications sur différentes plateformes à la manière de la machine
virtuelle Java.
1.3 Installation
A l’instar de la version 6.0, développer en VB .Net requiert une configuration machine
beaucoup plus importante.
Ces spécifications concernent l’utilisation du FrameWork .Net ainsi que de l’IDE, pas
l’exécution des programmes MSIL.
L’aide dynamique propose à tous les moments de la conception des rubriques d’aide
utiles en fonction de ce que vous faîtes. Par exemple, la rubrique « créer une collection de
contrôles » sera affichée lorsque vous ajouterez un bouton radio à votre application.
La fenêtre liste des tâche permet de recenser l’ensemble des tâche à réaliser sur votre projet.
Cette liste peut être remplie de plusieurs façons :
- Une tâche que vous aurez vous même définie (ex : appeler le client à 11h)
- Une tâche issue des commentaires de votre code : tous commentaires de votre code
commencant par « todo: » sera automatiquement ajouté
- Lorsqu’une erreur de syntaxe est détectée par Visual Studio, elle est automatiquement
ajoutée dans la liste
-
Propriétés communes
Propriété Description
Nom de l’assembly Nom du fichier généré après compilation (MSIL)
Type de sortie Type d’application a générer
Objet de démarrage Feuille ou procédure servant de point de départ au programme
Espace de nom racine Permet de définir un préfixe pour accéder à l’ensemble des
classes disponibles dans le projet
Icône de l’application Fichier .ico servant d’icône au fichier de sortie
Option explicit Interdit l’utilisation d’une variable non déclarée
Option Strict Oblige l’écriture de explicite de la conversion de données
Option compare Distinction de la casse en mode binaire (pas en mode texte)
Espaces de noms Permet de définir les espaces de noms qui devront être
automatiquement importés dans le projet (ex : permet d’écrire
« form » à la place de « system.windows.forms.form »
Chemin d’accès de référence Définit les dossiers dans lesquels se trouvent les références
utilisées dans le projet
Présentation page Mode de positionnement des contrôles : en mode Grid, le
placement est libre, en mode Flow, le placement se fait dans
l’ordre de création.
Schéma cible Navigateur pour lequel le code HTML doit être compatible
Langage de script Client Type de langage à utiliser
Propriétés de configuration
Propriété Description
Action de démarrage Action à réaliser par l’environnement lors de la demande
4. Bases du langage
4.1 Structure du code
Un exemple valant mieux qu’un long discours, nous allons commencer par décortiquer
un programme de base avant de parcourir le langage en lui même.
4.1.1 Formulaire
- Le code est en fait constitué de la définition d’une nouvelle classe portant le nom du
formulaire.
- L’instruction « inherits System.windows.forms.form » indique que la classe que nous
créons doit hériter (récupérer) de tous les éléments inscrits dans la classe « form »
- Enfin, la région « Code généré par le concepteur Windows Form » contient l’appel
aux méthodes de base de classe form ainsi que l’initialisation des contrôles.
Tout ajout d’éléments au formulaire (Variables, procédures, contrôles) seront ensuite perçus
(selon leur visibilité) comme membres de la classe « form1 ».
4.1.2 Module
Tout le code contenu dans le module sera inséré entre « module » et « end module »
Les commentaires permettent d’ajouter des annotations sur le code qui, une fois la
compilation lancée, ne seront pas traitées par le compilateur et ainsi exclue du programme
final.
Il n’est pas possible de créer des commentaires multilignes. Dans ce cas, vous êtes obligé de
répéter le caractère apostrophe au début de chaque ligne
A noter que lorsqu’un commentaire commence par le mot clé todo:, il sera automatiquement
ajouté dans la liste des tâches
Les régions sont une nouvelle fonctionnalité de Visual Basic permettant de masquer
une partie du code pour gagner en lisibilité.
La fonctionnalité appliquée aux région se retrouve sur chaque procédure Visual Basic : le
signe + situé à gauche du nom des procédures permet de ne garder que leur déclaration.
Depuis la version .Net, les chaînes de caractère sont enregistrées au format Unicode, c’est à
dire que chaque caractère utilise 2 octets.
Dim i as integer = 0
Dim moncar as char = ‘’i’’
Dim aujourdui as date = #12/07/02#
Dim nom as string
La portée d’une variable est équivalent à sa durée de vie, c’est à dire tant qu’elle est
accessible. La portée est définie en fonction de l’endroit où est placée sa déclaration. Quatre
niveaux de portée existent :
- Niveau Bloc : si la variable est déclarée dans un bloc (boucle while, condition …), la
variable ne sera valable que à l’intérieur du bloc
- Niveau projet : la variable est accessible à partir de tous les éléments du projet. Dans
ce cas, il faut utiliser le mot clé « friend » à la place du mot « dim ».
En dehors de l’emplacement où est définie la variable, plusieurs mot clés sont disponibles
pour agir sur la visibilité :
- Public : tous les blocs de code peuvent accéder à la variable
- Private : seul les éléments membres de la classe ou du module peuvent y accéder
Dim i as integer
Public y as string
Private z as integer
Pour accéder à un élément du tableau, il faut préciser le nom du tableau avec entre
parenthèses l’indice de l’élément désiré.
Montableau(2) = 123
Tableau2(5) = ‘’toto’’
En Vb, les tableaux sont dynamiques, c’est à dire qu’il est possible de modifier leur taille.
Pour cela, il faut utiliser l’instruction « Redim » suivi du nom du tableau et de sa nouvelle
taille.
Redim montableau(15)
Cependant, l’instruction « Redim » ne conserve pas les données déjà présentes dans le
tableau. Pour conserver son contenu, utiliser le mot clé « preserve »
Les constantes permettent de stocker une valeur en s’assurant qu’elle ne sera jamais
modifiée. Elles sont généralement utilisées pour améliorer la modularité du code en ne
définissant qu’une seule fois une valeur utilisée plusieurs fois.
Il n’est pas obligatoire de préciser le type de la constante sauf lorsque l’option
« Strict » du compilateur est activée.
Enum civilite
Monsieur
Madame
Mademoiselle
End enum
Enum jour
Jeudi = 4
Lundi = 1
Dimanche = 7
…
End enum
Une fois l’énumération déclarée, il est possible de déclarer une variable du type de
l’énumération.
De cette façon, la variable macivilite pourra uniquement prendre les valeurs définies
dans l’énumération :
Macivilite = monsieur
Macivilite = 1 ‘correspond à madame
Macivilite = 4 ‘invalide, l’indice max est 2
Un seul opérateur d’affectation existe et ce quelque soit le type de données concerné : le signe
égal « = ». Il permet d’affecter une valeur à une variable.
Mavar = 123
Il est également possible d’utiliser les opérateurs arithmétiques lors d’une affectation.
Dim i as integer = 5
I += 3 ‘équivalent à i = i + 3
les opérateurs arithmétique permettent d’effectuer des calculs sur des variables, constantes …
Il permettent de comparer deux membres et, en fonction du résultat, retournent True ou False
- Le plus « + » : dans ce cas, il faut que les deux membres de la concaténation soient de
type chaîne de caractères.
- L’éperluette « & » : dans ce cas, l’opérateur effectue une conversion implicite lorsque
les deux membres ne sont pas des chaînes de caractères.
Une condition est une comparaison entre deux membres dont le résultat retourne True
(Vrai) ou False (Faux). Une condition est composée d’au moins 2 membres (variables,
constantes, appel de fonction) et éventuellement d’opérateurs logiques permettant de lier les
sous conditions. Les conditions sont utilisées dans les structures de contrôle afin d’en définir
leur fonctionnement.
4.4.2.1 Structure If
• Forme simple
A utiliser dans le cas où vous ne souhaitez réaliser qu’une seule instruction lorsque la
condition est vérifiée. Dans ce cas, la condition et l’instruction à réaliser doivent se trouver
sur le même ligne.
• Forme normale
La forme normale permet d’exécuter plusieurs instructions lorsque la condition est vérifiée.
• Forme évoluée
La forme évoluée permet d’exécuter plusieurs instructions lorsque la condition est vérifiée
et d’exécuter d’autres instructions.
La structure de contrôle Select Case permet d’effectuer un ensemble de test sur une
seule valeur. Cette valeur peut-être le contenu d’une variable, le résultat d’un calcul ou d’une
fonction. Le principal intérêt de cette structure est de clarifier le code : en effet, toute
utilisation de cette structure peut être remplacée par un ensemble de structures If.
- Case min to max : pour les valeurs numériques, permet de définir un interval
- Case is > constante : pour les valeurs numériques, définition d’un interval non fermé
- Case Else : cette condition sera validée si tous les tests définis dans le select case sont
faux
• Iif
L’instruction IIF permet d’évaluer une condition et de retourner des valeurs différentes en
fonction du résultat de la condition.
• Switch
• Choose
L’instruction Choose permet de choisir une valeur dans une liste en fonction d’un Index.
Attention, les Index commencent à 1 !
La structure while répète les instructions contenues entre While et End while tant que
la condition est vérifiée.
While condition
…
end while
dim i as integer = 0
while i < 10
msgbox (i)
i++
end while
La structure do loop possède 4 variantes. Elle peut être paramétrée avec les mots clés while
(tant que la condition est vérifiée) et Until (Jusqu’à ce que la condition soit vérifiée).
Do while condition
…
loop
Do until condition
…
loop
Dans ces deux cas, la condition est évaluée une première fois avant l’entrée dans la
boucle, c’est à dire qu’il est tout à fait possible que les instructions de la boucle ne soient
exécutées aucune fois.
Une seconde variant de cette structure permet d’exécuter au moins une fois les
instructions de la boucle et d’évaluer la condition ensuite :
Do
…
loop while condition
Do
…
loop until condition
dim i as integer
for i = 1 to 10 step 2
msgbox (i)
next
Enfin, il existe plusieurs cas dans lequel l’utilisation de procédures est imposée par Vb.
4.5.1.1 Déclaration
- Toutes les instructions situées entre sub et end sub feront partie de la procédure
- Le nom d’une procédure suit les mêmes règles que pour les variables
- Il possible de préciser la visibilité de la procédure en remplaçant public par private ou
friend
4.5.1.2 Appel
Pour appeler une procédure, il suffit de placer son nom avec le mot clé call (facultatif)
Call nom_procedure(valeurs_parametres)
nom_procedure(valeurs_parametres)
4.5.2.1 Déclaration
Lors de la déclaration d’une fonction, il faut reprendre les mêmes éléments que pour
les procédures avec en plus le type de retour de la fonction (String, integer…).
La fonction doit également comporter l’instruction Return qui permet de définir la valeur
retournée par la fonction.
Nous l’avons dit plus haut, un fonction est une procédure retournant une valeur. Cette
valeur peut être issue d’un calcul ou être un code erreur. De ce fait, lors de l’appel d’un
fonction, il faut récupérer le résultat afin de le traiter. Le résultat peut donc être stocké
directement dans une variable ou encore être passé en paramètre à une autre procédure ou
fonction.
Variable = nom_fonction(valeurs_parametres)
Msgbox (nom_fonction(valeurs_parametres))
4.5.3.1 Déclaration
Dans certains cas, un paramètre peut être facultatif. Dans ce cas, il faut placer le mot
clé optionnal devant le paramètre et, éventuellement, spécifier la valeur par défaut avec
l’opérateur d’affectation :
4.5.3.2 Appel
Lors de l’appel d’une procédure ou d’une fonction, il faut donner les valeurs des différents
paramètres utilisés par la fonction.
Feliciter(‘’Dupont’’)
Feliciter(‘’Dupont’’, ‘’gerard’’)
Lors du passage de paramètres à une procédure ou à une fonction, deux méthodes sont
disponibles :
C’est le mode de passage de paramètre par défaut : lors du passage par référence, seule la
valeur du paramètre est passé à la procédure. Cette dernière travaille donc sur une variable
locale.
Pour définir un passage de paramètre par valeur, il suffit d’ajouter le mot clé « byval »
devant le nom du paramètre dans la déclaration de la procédure.
Dans l’exemple suivant, les 2 variables nom et enom font référence à des emplacements
mémoires distincts.
Sub main()
Dim nom as string = ‘’toto’’
Afficher(nom)
End sub
Dans le cas d’un passage par référence, ce n’est pas la valeur du paramètre qui est passé
mais l’adresse de la variable contenant la valeur : dans ce cas, la procédure appelée et la
procédure appelante travaille sur la même variable, même si le nom utilisé pour le paramètre
est différent du nom de la variable initiale. De ce fait, il est possible de modifier le contenu de
la variable passée en paramètre à partir de la procédure appelée.
Pour définir un passage de paramètre par valeur, il suffit d’ajouter le mot clé « byref »
devant le nom du paramètre dans la déclaration de la procédure.
Sub main()
Dim nom as string = ‘’toto’’
Modifier(nom)
Msgbox(nom) ‘affiche titi
End sub
Visual basic .Net permet le passage d’un nombre quelconque de paramètre grâce au mot clé
« ParamArray ». Il suffit de définir un paramètre de type tableau correspondant au type des
paramètres qui devront être passé. Chaque élément du tableau correspond ensuite à un
paramètre.
Pour la procédure somme, il sera donc possible d’effectuer les appels suivants :
Somme (12,2)
Somme(15,7,6,9,2,4)
De manière générale, il est préférable d’utiliser les méthodes liées aux types de variables dans
le sens où elles sont accessibles par simple ajout du point après le nom de la variable (Liaison
précoce).
Attention, l’appel des méthodes ne change pas la valeur de la variable mais retourne la
valeur modifiée.
L’ensemble des fonctions disponibles pour la gestion des nombres est disponible dans la
classe Math.
Pour les exemples ci dessous, nous utiliserons la variable suivante comme base :
Il existe une autre fonction de formatage dont le fonctionnement est un peu différent : la
fonction « ctype » permet de convertir une variable de type « Object » vers un type d’objet
précis. Le principal intérêt de cette méthode est de profiter de la liaison précoce lors de
l’écriture de programmes.
Ctype(objet, classe)
Dim f as object
Dim g as Personne
F = new personne(‘’toto’’)
G = Ctype(f, personne)
L’expression à formater peut être une valeur numérique ou de type date / heure.
• Formats prédéfinis
Caractère Description
0 Affiche le chiffre ou 0
# Affiche le chiffre ou rien
. Décimal
, Séparateur de milliers
\ Caractère d’échappement
• Formats prédéfinis
Caractère Description
: Séparateur d’heures
/ Séparateur de date
Les boîte de dialogue intégrées sont des feuilles modales (c’est à dire qu’elle suspendent
l’exécution du programme jusqu’à leur fermeture) destinées à afficher une information ou
demander une saisie.
Prompt
Icône
Type boutons
• Types de bouton
• Constantes de Retour
• Type d’icône
Exclamation
Information
Question
L’option bouton par défaut permet de définir le bouton qui sera sélectionné par défaut.
Titre
Message
InputBox est une fonction, elle retourne la valeur saisie par l’utilisateur où chaîne vide
si le bouton Annuler est utilisé. La valeur retournée est toujours de type String. Les éventuels
contrôle de saisie devront être fait par le programme une fois la valeur retournée.
La classe CollectionBase permet de créer une classe collection contenant tous les
éléments de base nécessaires à la création. Il ne reste qu’à définir quelques méthodes
supplémentaires pour avoir une collection opérationnelle.
Dans les exemples suivants, nous nous inspirons de la classe « Personne » décrite dans
le chapitre consacrée à la POO.
La création d’une collection se fait à partir d’une classe dans laquelle il faut hériter de
« system.collections.collectionbase ».
Ceci n’est pas suffisant : en effet, nous n’avons pas accès au contenu de notre collection. Pour
cela, nous devons implémenter la propriété « item » et la méthode « add » :
End Class
4.7.1.2 Utilisation
macol.add(New personne("toto"))
macol.add(New personne("titi"))
macol.RemoveAt(0)
MsgBox(macol.Item(0).nom)
La classe Stack est une collection particulière de type LIFO (Dernier rentré premier
sorti) permettant de gérer une pile. Cette dernière se présente comme un tableau mais contient
des fonctionnalités différentes. Pour imager, vous empiler des éléments les uns sur les autres
et vous ne pouvez retirer que l’élément du haut. Ce genre de liste est utilisé pour gérer les files
d’appels.
Pour déclarer une pile, on utilise la classe Stack en précisant le nombre maximum
d’éléments :
Pour déclarer une telle files d’attente, utiliser la classe Queue en précisant deux
paramètres : la taille initiale de la liste (par défaut 32) et le facteur d’extension (par défaut 2).
Erreur Description
De syntaxe De type d’erreur correspond aux fautes d’orthographe. Elles sont
directement captées par l’environnement de développement qui les
signale en les soulignant. Noter qu’une erreur de syntaxe empêche la
compilation du programme et de fait ne peut survenir lors de
l’exécution.
D’exécution Une erreur d’exécution survient lorsque l’environnement
La gestion en ligne existait déjà sur la version 6. Elle permet de définir les traitements
à effectuer dans une procédure lorsqu’une erreur survient.
L’instruction « On error » est la base de la gestion d’erreur : c’est elle qui va spécifier
les opérations à réaliser lorsqu’une erreur survient.
Cette instruction ignore la ligne ayant provoqué l’erreur et continue l’exécution. Cette
méthode est peu fiable dans le sens où vous n’êtes pas prévenu d’une erreur et le reste du
programme peut en être affecté.
Cette instruction dirige l’exécution du code vers une étiquette en fin de procédure. C’est
dans cette étiquette que vous pourrez ensuite définir les traitements correspondants.
Il est important de placer l’instructions « Exit sub » ou « Exit function » juste avant la
déclaration de l’étiquette car dans le cas où l’exécution se déroule correctement, il ne faut pas
que la gestion d’erreur soit activée.
• On error goto 0
Une fois que vous avez redirigé le code lors d’une erreur, vous devez définir les
actions à entreprendre : Il existe pour cela 2 mots clés permettant de continuer l’exécution du
programme :
Instruction Description
Resume Cette instruction reprend le programme où il s’était interrompu et essaye
de réexécuter l’instruction à l’origine du plantage.
Resume Next Reprend l’exécution du programme à partir de l’instruction suivant
l’instruction à l’origine du plantage.
Méthode Description
Clear Efface les paramètres de l’objet
Raise Déclenche une erreur
La gestion des exceptions est une méthode plus récente pour la gestion des erreurs.
Cette méthode est standardisée pour tous les langages du FrameWork .Net . De plus, elle
permet de définir une gestion d’erreur pour un bloc particulier et non pas pour une procédure
ou une fonction.
La gestion des exceptions pour un bloc de code est structuré de la manière suivante : le
code dangeureux doit être compris dans le bloc « try ». Ensuite pour chaque exception
suceptible d’être déclenchées, le mot clé « catch » (analogue au select case) permet de définir
les traitements à exécuter. Enfin, le bloc « finally » contient du code qui sera exécuté dans
tous les cas.
Try
{ Instructions dangeureuses}
Try
Microsoft.visualbasic.fileopen(1, ‘’A:\fichier.txt’’, openmode.input)
Catch exception1 as system.io.ioexception
Msgbox(‘’Erreur lors de l’ouverture du fichier : ’’ & exception1.source)
Finally
Msgbox(‘’Fin de la procédure’’)
End try
A chaque exception est associé un objet contenant les informations sur l’exception levée :
Propriété Description
Message Description textuelle de l’exception
Source Nom de l’application ayant générée l’erreur
StackTrace Liste de toutes les méthodes par lesquelles l’application est passée avant le
déclenchement de l’erreur
TargetSite Méthode ayant déclenchée l’exception
5 Programmation Objet
Contrairement aux versions précédentes, Visual Basic .net impose un minimum de
notions Objets afin de l’utiliser de façon optimale. De plus, de nombreux concepts objets sont
venus renforcer la POO sous Visual Basic comme les notions d’héritage, d’interface et de
polymorphisme.
Le principe des classes, objets, méthodes et l’encapsulation sont les principes de base de
la programmation orientée objet. Plusieurs aux concepts viennent enrichir la POO comme
l’héritage qui permet de récupérer le comportement d’une classe déjà existante pour en créer
une nouvelle, la surcharge qui permet de définir plusieurs fois le comportement d’une même
procédure en fonction des paramètres passés et la visibilité (partie de l’encapsulation)
permettant de cacher un certain nombre de paramètres inutiles pour l’utilisateur final.
La définition d’une classe permet de définir un modèle pour les objets qui seront créés.
Pour créer une nouvelle classe, il est conseillé de créer un nouveau fichier (.vb) dans le projet.
La déclaration d’une classe se fait avec les mots clés « class » et « end class ».
En visual Basic .Net, il est possible de définir une classe à l’intérieur d’une autre classe :
La visibilité d’une classe permet de définir la portée de celle ci, c’est à dire les blocs
de code qui auront accès à la classe. Cinq niveaux de visibilité existent :
Visibilité Description
Public Classe utilisable dans tout les projet
Friend Classe utilisable uniquement dans le projet
Private Classe utilisable uniquement dans le module / classe où elle est définie
Protected Classe utilisable dans les sous classes de celle où elle est définie
Protected friend Union des portées de Protected et Friend
Option Description
MustInherit Indique que la classe sert de base dans une relation d’héritage (Super
classe).
NotInheritable Indique que la classe ne peut être héritée. Elle devra être au dernier
niveau de la hiérarchie d’héritage.
Le mot clé « Inherits » permet d’hériter des membres d’une super classe(Cf section sur
l’héritage).
• D’abord, il faut créer une variable capable de référencer l’objet créé en mémoire :
c’est à dire que cette variable ne contiendra que l’adresse de l’objet. Le type de cette
variable est le nom de la classe qui instanciera l’objet.
• Ensuite, créer l’objet avec l’opérateur new et stocker l’adresse retournée dans la
variable
A partir de ce moment, l’objet est utilisable, c’est à dire qu’il possible de modifier ses
propriétés et d’appeler ses méthodes. L’environnement .net effectue ce qu’on appel une
liaison précoce, c’est à dire qu’à partir de la définition de la classe, il est capable d’afficher
l’ensemble des membres disponibles :
Lorsqu’un objet n’est plus utilisé, il est important de le supprimer afin de libérer de la
mémoire et, éventuellement, effectuer des opérations d’enregistrement dans une base de
données par exemple via le destructeur.
Pour supprimer un objet, il suffit de placer le mot clé « nothing » à l’intérieur de la variable
référençant l’objet.
MonObjet = Nothing
Moi = nothing
Toi = nothing
5.3.1 Variables
End Class
dim p as personne
p = new personne()
p.nom = ‘’toto’’
p.prenom = ‘’titi’’
Pour palier à ces problèmes, il existe les procédures de propriétés. L’idée est de lier
chaque propriété à deux procédures : GET et SET. La procédure « get » sera appelée lorsque
la propriété set utilisée en lecture et « set » lorsque la propriété est utilisée en écriture.
Dans tous les cas, les procédures de propriété agiront sur une variable de stockage qui
contiendra la valeur de la propriété.
La section Get est en fait une fonction devant contenir le mot clé « return » pour définir la
valeur de retour de la propriété.
La section Set est une procédure prenant en paramètre « value », la valeur à assigner à la
propriété.
L’exemple suivant implémente la propriété « nom ». Elle vérifie que le nom ne soit pas
vide et retourne le nom en majuscule. Dans cet exemple, c’est la variable « v_nom » qui
contient la valeur de la propriété.
5.4.1 Généralités
Les méthodes sont des procédures ou des fonctions déclarées à l’intérieur d’une classe et
appelable uniquement à partir d’un objet.
dim p as personne
p = new personne()
p.afficher()
Les constructeur et destructeur sont 2 méthodes spécifiques dont l’appel est effectué
automatiquement respectivement lors de la création et lors de la destruction d’un objet.
Le constructeur est généralement utilisé pour initialiser les propriétés d’une classe tandis que
le destructeur permet généralement la sauvegarde des données dans une base par exemple.
5.4.2.1 Constructeur
Le constructeur se doit d’être « Public » afin qu’il puisse être appelé lors de
l’instanciation des objets.
End Sub
Dim p As personne
p = New personne("toto")
Le mot clé « Overrides » définit une réécriture de fonction. Nous détaillerons ce point
plus tard.
5.4.3 La surcharge
La surcharge de méthode permet de définir plusieurs fois la même méthode mais avec des
paramètres différents. Seuls les paramètres peuvent être modifiés dans une surcharge, pas le
type de retour. Pour surcharger une méthode, il faut utiliser le mot clé « OverLoads ».
End sub
Overloads function convertir (byval valeur as integer, byval taux as double) as double
Return valeur / 100 * taux
End function
Msgbox convertir(100)
Msgbox convertir(100, 5.5)
Public Sub New(ByVal lenom As String, ByVal leprenom As String, ByVal ladaten As Date)
v_nom = lenom
v_prenom = leprenom
v_daten = ladaten
End Sub
Ainsi, il est possible d’appeler tel ou tel constructeur lors de la création de l’objet :
Dim p, q, r As personne
p = New personne("toto")
q = New personne("titi", "momo")
r = New personne("tutu", "mimi", #12/7/2002#)
5.4.4 L’objet Me
Comme dans la version précédente de Visual Basic, l’objet « Me » est l’objet courant.
Lorsque vous écrivez une méthode, vous pouvez faire référence directement aux propriétés de
l’objet :
Return nom
Le compilateur sait alors que vous faîtes référence à la propriété de l’objet courant.
Pour clarifier le code, lever des ambiguités entre plusieurs variables portant le même nom ou
profiter du menu de saisie automatique, vous pouvez faire référence à l’objet « Me » qui lors
de l’exécution fera référence à l’objet ayant appelé la méthode.
5.5 L’Héritage
Reprenons par exemple notre classe personne. Elle contient des propriétés et des méthodes
génériques quelque soit la personne. Cependant, les personnes sont subdivisées en 2
catégories : les employés qui ont un taux horaire et une durée de contrat, les cadres qui ont un
salaire fixe plus un montant de primes. Dans ce cas, les employés comme les cadres auront un
nom, prénom et date de naissance. Ainsi, les propriétés communes sont regroupées dans la
super classe (Personne) tandis que les propriétés spécifiques comme le taux horaire ou le
montant des primes seront eux stockés dans la sous classe.
EMPLOYE
Tx_horaire
PERSONNE Duree
Nom
Prénom
Date naissance
CADRE
Calc_salaire() Salaire
Prime
EMPLOYE CADRE
Nom Nom
Prénom Prénom
Date naissance Date naissance
Tx_horaire Salaire
Duree Prime
Calc_salaire() Calc_salaire()
Microsoft Visual Basic . Net - Août 2003 56/139
L’intérêt de l’héritage est donc de définir les éléments communs une seule fois et de
pouvoir les réutiliser dans plusieurs autres classes.
Pour définir qu’une classe hérite d’une autre classe, vous devez utiliser le mot clé
« Inherits » dans la définition de la sous classe. Attention, la classe que vous utilisez en tant
que super classe ne doit pas posséder l’option « NotInheritable », auquel cas vous ne pourrez
hériter de ses membres.
Dans l’exemple suivant, la classe cadre hérite des membres de la classe personne.
End Class
Ainsi, lors de l’instanciation de la classe cadre, nous retrouvons l’ensemble des propriétés :
L’objet MyBase est utilisable uniquement dans les sous classes. Il fait référence aux super
classes.
Si nous reprenons notre exemple précédent, le constructeur de la sous classe « cadre » fait
directement référence aux propriétés de la super classe « personne ». Dans le cas ou rien n’est
précisé, le compilateur appellera le constructeur de la super classe par défaut, c’est à dire celui
qui ne possède aucun paramètre.
Si vous souhaitez spécifié le constructeur, vous devez l’appeler de manière explicite dans
le corps du constructeur de la sous classe :
5.5.4 Le remplacement
Par exemple, nous allons modifier le code de telle façon à ce que, lorsque nous appelons
la méthode « afficher » à partir d’un objet de type cadre, celle ci affiche le nom, prénom et
salaire fixe. Cependant, le fonctionnement de la méthode ne sera pas modifié pour les objets
de type « Personne » ou « Employe ».
Pour remplacer la fonction « afficher », nous devons la réécrire dans la sous classe cadre
et utiliser le mot clé « overrides ». Attention, la signature des deux classes doit être identique
(paramètres et valeur de retour).
Pour déclarer une propriété ou une méthode partagée, il suffit de rajouter le mot clé
« shared » (partagé ☺) devant le nom du membre :
Ces variables et procédures seront ensuite accessibles soit via un objet, soit via le nom de
la classe.
L’exemple suivant crée une variable partagée contenant le nombre d’objet instanciés à partir
de la classe « personne ». Nous créons également la propriété « nb_personne » retournant la
valeur de v_nbpersonne.
Sub New()
v_nbpersonne++
End Sub
End class
Dim p as personne
P = new personne
Msgbox (p.nb_personne)
Msgbox (personne.nb_personne)
5.7.1 Création
La création d’une interface ressemble à celle d’une classe, elle est définie par les mots clé
« interface » et « end interface ».
Dans notre cas nous allons définir l’interface « comparer » implémentant la méthode
« plus_grand » prenant en paramètre un Objet.
5.7.2 Utilisation
Pour utiliser une interface, il suffit de l’implémenter dans une classe et de définir le
comportement des différentes méthodes. Plusieurs éléments doivent apparaître dans la classe
implémentant l’interface :
- Le mot clé « implements nom_interface » afin de préciser que la classe va
implémenter l’interface
- Le mot clé « implements nom_interface.nom_méthode » après les méthodes qui
définissent le comportement d’une méthode de l’interface.
Implements comparer
Public Function plus_grand(ByVal obj As Object) As Boolean Implements _
comparer.plus_grand
If Me.daten < obj.daten Then
Return True
Else
Return False
End If
End Function
…
Jusqu’ici, nous avons créé nos propres interfaces. Le framework .net met à disposition
plusieurs interfaces dont le développeur doit savoir tirer avantage pour simplifier la
programmation.
Nous baserons notre exemple sur l’interface Icomparable qui permet ensuite d’utiliser
la méthode « Sort » de la classe « Array ». Cette interface ne comporte qu’une seul méthode
« CompareTo » qui prend en paramètre un objet et retourne –1, 0 ou 1 selon que l’objet en
cours est inférieur, égal ou supérieur à l’objet passé en argument. A partir de cette méthode de
Tri, la méthode « Sort » sera capable de trier tous types d’objets, à condition qu’ils
implémente l’interface.
L’intérêt des Interfaces est de pouvoir utiliser des méthodes déjà définies et de
modifier leur comportement afin qu’elles puissent être utilisées avec des classes utilisateurs.
Implements comparer
Implements IComparable
End Function
Une fois l’interface implémentée, nous pouvons utiliser la méthode « Sort » avec un
tableau d’objets de type « personne » :
Sub main()
Array.Sort(t_personne)
End Sub
Cet exemple affiche la liste des personne triées grâce à l’appel de la méthode « Sort ».
5.8 La délégation
La délégation est un mécanisme qui permet de définir une variable pointant sur une
fonction. En réalité, cette variable contiendra l’adresse de la fonction ou de la procédure.
Dans les exemples suivants, nous utiliserons les deux fonctions suivantes :
Nous allons créer le type calcul qui sera un pointeur vers fonction :
Une fois le type défini, il faut lui assigner une valeur à l’aide de l’opérateur « Address Of »
Nom_type.invoke(paramètres)
Les évènements sont des méthodes qui seront automatiquement appelées par les objets
afin de prévenir d’un état donné. Il est également possible de définir des paramètres à
l’événement : ces derniers permettront de préciser les conditions dans lesquelles il se
déclenche.
5.9.1 Création
La création d’un événement permet d’en définir ses paramètres ainsi que les
conditions dans lesquelles il sera déclenché. C’est l’utilisateur de la classe qui définira ensuite
les actions à réaliser lorsque l’événement survient.
Dans l’exemple suivant, nous créons un événement lorsque le montant des primes d’un cadre
dépasse 10 000.
Une fois l’événement défini, il faut placer à l’intérieur de la classe les instructions qui
permettront de le déclencher. Pour cela, on utilise le mot clé « RaiseEvent » en précisant les
valeurs des différents paramètres attendus par l’événement.
Dans notre cas, nous devons placer le code nécessaire lors de la modification de la
propriété « montant_salaire ». Pour cela nous allons placer le code dans la procédure de
propriété « Set » de « montant_prime ».
5.9.2 Utilisation
Il existe deux méthodes pour traiter les évènements : soit en utilisant le mot clé
« withEvents », soit en utilisant un gestionnaire d’évènements.
Une fois la variable créée, vous devez définir le bloc de code à exécuter lors du
déclenchement de l’événement : pour cela, placer le code dans la procédure d’événement
correspondant. Pour qu’une procédure soit déclenchée lorsqu’un événement survient, vous
devez ajouter à la fin le mot clé « handles » suivi du nom de la classe et de l’événement
Par convention, le nom de la procédure est le nom de l’objet suivi de l’événement mais il n’y
à aucune obligation : l’exemple suivant fonctionne très bien.
Dans l’exemple suivant, nous avons 2 procédures qui affichent le montant des primes
en mode texte et en mode graphique.
Nous créons ensuite deux objets de type cadre (c1 et c2) et nous lions à chaque objet une
procédure différente pour la gestion de l’évènement depassement_plafond_prime.
C1 = new Cadre()
C2 = new Cadre()
A l’inverse, pour supprimer un gestionnaire d’événement mis en place, il faut utiliser le mot
clé « RemoveHandler »
Si aucune procédure n’est liée à l’événement, ce dernier sera tout simplement ignoré.
Implements comparer
Implements IComparable
End Function
Public Sub New(ByVal lenom As String, ByVal leprenom As String, ByVal ladaten As
Date)
v_nom = lenom
v_prenom = leprenom
v_daten = ladaten
v_nbpersonne = v_nbpersonne + 1
End Sub
End Class
End Property
6 Applications Windows
Ce sont les formulaires dont disposait Visual basic 6. Les applications basées sur ces
formulaires sont utilisés pour le développement d’applications pour lesquelles la plupart des
traitements se font sur la machine cliente et qui ont besoin d’accéder aux ressources de la
machine (fichiers, lecteurs, imprimantes …).
Les applications à base de Web Forms sont destinés à être utilisées sur le Web par le
biais d’un navigateur. Ce genre d’application présente plusieurs avantages comme un
déploiement facile dans le sens où seul les composants du navigateur doivent être installés,
une maintenance simplifiée car le programme est stocké sur le serveur et, enfin, les
applications développées sont indépendantes de toutes plateformes dans le sens où elles
n’utilisent que les ressources du navigateur.
Inherits System.Windows.Forms.Form
• Définition des Objets placé sur le formulaire. (remarquez le mot clé withevents
permettant la gestion des événements). Dans cet exemple, l’élément ajouté est un
champs texte.
End Sub
• AcceptButton
Lorsque l’utilisateur appuie sur la touche entrée, la méthode liée à l’événement « click »
du bouton d’acceptation sera automatiquement déclenchée. Généralement, c’est le bouton
« ok » ou « sauvegardé » qui est paramétré comme AcceptButton.
• AllowDrop
• AutoScale
Si cette option est activée, la taille des contrôles et du formulaire sont automatiquement
redimensionnés lors d’un changement dynamique de la police d’écran.
• AutoScroll
L’option AutoScroll est une nouveauté de la version .Net : elle permet de placer
automatiquement des barres de défilement lorsque la taille du formulaire ne permet pas
l’affichage de tous les contrôles qu’il contient.
• BackColor
• BackgroundImage
Il est possible de définir une image comme fond pour le formulaire. L’image sera
automatiquement répétée en mosaique.
• CancelButton
• ControlBox
Le menu système peut également être modifié avec les propriétés « MinimizeBox »,
« MaximizeBox » et « HelpButton ».
• Cursor
Définit l’apparence par défaut du curseur sur le formulaire. Cette option peut également
être paramétrée au niveau des contrôles.
• Enabled
Définit si le formulaire est disponible (True) ou non (False). Dans ce dernier cas, aucun
des contrôles et menus du formulaires ne seront accessibles (grisés).
• Font
Cette propriété définit les paramètres de formatage du texte. Cette propriété sera
automatiquement appliquée par défaut au texte des différents contrôles. Cette propriété est
elle même décomposée en plusieurs autres propriétés :
• ForeColor
• FormBorderStyle
FixedSingle Non
Fixed3d Non
FixedDialog Non
FixeToolWindow Non
SizableToolWindow Oui
• HelpButton
Affiche le bouton d’aide à gauche de la barre de titre. Attention, le bouton ne sera pas
affiché si les boutons min et max sont activés.
Pour déclencher un bloc d’instruction lorsque l’utilisateur demande l’aide (Soit à partir de
la touche F1, soit à partir du bouton d’aide, vous devez créer une méthode implémentant
l’événement :
Le code suivant permet d’afficher une boite de dialogue lorsque l’utilisateur demande
l’aide sur le champs texte « text1 » qui doit être déclaré avec le mot clé « WithEvents ». La
procédure suivante implémente l’événement :
• Icon
Définit l’icône liée au formulaire : cette dernière apparaît dans la barre de titre.
• IsMDIContainer
Détermine si le formulaire est un conteneur MDI, c’est à dire s’il est capable de contenir
d’autre fenêtres.
Dans le cas d’un formulaire MDI, vous devez spécifier le code afin d’afficher d’autres
formulaires à l’intérieur. Le code suivant permet l’affichage d’un formulaire fils : dans cet
exemple, Form2 est le formulaire MDI, Form1 et Form3 sont les formulaires enfant. Il faut
également paramétré l’option « IsMdiContainer » du Form2 à True.
f2.MdiParent = Me
f2.Show()
• Location
Cette objet défini la position du formulaire par rapport à son conteneur (c’est à dire l’écran
ou le formulaire parent dans le cas d’application MDI). Deux propriétés permettent de définir
la position :
• Locked
• MinimizeBox, MaximizeBox
Détermine si les boutons « Agrandir » et « Réduire » sont visibles. Leur affichage
empêchera l’affichage du bouton d’aide.
• MinimumSize, MaximumSize
Cet objet définit la taille minimale et maximale que peut avoir le formulaire. Cet objet est
généralement utilisé pour éviter que l’utilisateur réduise la fenêtre au point de ne plus avoir
accès aux contrôles. Pour chaque objet, deux propriété sont disponibles : width (largeur) et
height (hauteur).
Définit un pourcentage d’opacité pour la fenêtre. Une valeur de 100% rend la fenêtre opaque.
• ShowInTaskBar
Détermine si un nouveau bouton est ajouté dans la barre des tâches lorsque la fenêtre est
ouverte :
• Size
Cet objet définit la taille du formulaire à l’aide de deux propriétés : width (largeur) et
height (hauteur).
• Startposition
Valeur Description
Manual Position définie par la propriété location
CenterScreen Centré par rapport à l’écran
WindowsDefaultlocation Situé à l’emplacement par défaut de Windows et possède la taille
définie dans size
WindowsDefaultBounds Situé à l’emplacement par défaut de Windows et possède la taille
par défaut de Windows
Centerparent Centré par rapport à la fenêtre ayant déclenché l’ouverture.
• Text
• TopMost
Si cette option est activée (true) le formulaire sera toujours au dessus de tous les autres
formulaires, même s’il n’est pas activé. Cette option se prête particulièrement bien pour les
boîtes à outils qui doivent toujours rester accessibles.
• TransparencyKey
• WindowState
Valeur Description
Normal Le formulaire apparaît avec sa taille standard
Minimize Le formulaire est réduit lors de l’ouverture
Maximize Le formulaire est en plein écran lors de l’ouverture
6.1.2.2 Méthodes
• Activate
La méthode activate permet de mettre le formulaire au premier plan et de lui donner le focus.
• Close
Ferme le formulaire
Affiche le formulaire en tant que feuille modale, c’est à dire qu’au niveau de l’application,
la fenêtre restera au premier plan tant qu’elle n’est pas fermée.
6.1.2.2 Evénements
Les événements correspondent au cycle de vie de l’objet formulaire. Ils sont listés dans
l’ordre chronologique.
• New
• Load
Le formulaire ainsi que ses composants sont chargés mais il n’est pas visible.
• Paint
Se produit lorsque le formulaire est redessiné. Cet événement peut apparaître plusieurs
fois : par exemple au démarrage et lorsque le formulaire réapparait devant un autre.
• Activated
• Deactivate
• Closing
Le formulaire est en cours de fermeture, les différents éléments le composant sont détruits.
Le formulaire est cependant encore visible.
• Closed
• Dispose
• Resize
• Click
• DoubleClick
Si vous observez les différentes applications tournant sous windows, vous vous
apercevrez qu’elles utilisent toutes les même boîtes de dialogue standard (Enregistrer, Ouvrir
Imprimer …). Visual Basic permet l’utilisation de ces boîte de dialogue standard.
6.1.3.1 Ouverture
'paramétrage de la boîte
dlg.Title = "Veuillez sélectionner l'image"
dlg.DefaultExt = "gif"
dlg.Filter = "Image gif|*.gif|Image Jpeg|*.jpg"
dlg.Multiselect = True
dlg.CheckFileExists = True
'affichage de la boite
dlg.ShowDialog()
6.1.3.2 Enregistrement
'affichage de la boite
dlg.ShowDialog()
Cette boîte de dialogue permet à l’utilisateur de choisir une couleur dans un panel. Deux
versions de cette boîte de dialogue existent :
• Version « simple »
• Version « complète »
Propriété Description
Propriété Description
ShowEffects Booléen spécifiant si l’utilisateur peut définir les effets (gras
…)
ShowColor Booléen spécifiant si l’utilisateur peut définir la couleur
MinSize Taille minimale des caractères
MaxSize Taille maximale des caractères
Font Police par défaut et police retournée
Color Couleur par défaut et couleur retournée
De manière générale, les contrôles sont des objets graphiques, c’est à dire qu’il seront
placés et visibles sur le formulaire. Cependant, certains contrôles offrant des fonctionnalités
de programmation n’apparaîtront pas sur le formulaire mais dans une zone située en bas et
uniquement en mode « Design ».
Contrôle graphique
Contrôle masqué
Les contrôles Visual Basic .Net sont des classes issues de la classe de base « control ».
Cette dernière assure les fonctions élémentaires comme le placement sur une feuille, leur
position … A cette classe est ajoutée une classe dérivée permettant la personnalisation des
différents contrôles.
6.2.1.1 propriétés
• Name
• Anchor
Lors du paramétrage, vous devez définir sur quels bords du conteneur est ancré le
contrôle. Dans l’exemple suivant, nous créons un contrôle ancré à gauche et à droite :
• CanSelect
• Dock
Dans le même esprit, la propriété « Dock » permet d’ancrer un contrôle aux à un bord du
conteneur. Dans l’exemple suivant, le bouton est ancré en bas :
• Enabled
Cette propriété est une valeur booléenne spécifiant si le contrôle est accessible ou non.
Dans le second cas, le contrôle apparaîtra grisé.
• Location
• Locked
• Modifiers
Cette propriété paramètre la visibilité au niveau programmation de l’objet. Elle peut prendre
les valeurs suivantes :
Valeur Description
Public Accessible à partir de tous les éléments de la solution
Protected Accessible à partir des membres de la classe et des sous classes
Protected Friend Correspond à l’union des visibilités Friend et Protected
Friend Accessible à partir du programme et des assemblages liés
Private Accessible à partir des membres de la classe
• Size
Cet objet permet de définir la taille du contrôle. Il est composé de deux propriétés, width
(largeur) et height (hauteur).
• TabIndex
• Text
Cet propriété référence le texte contenu ou affiché dans un contrôle (Par exemple, le texte
affiché sur un bouton).
• Visible
Cet propriété détermine si le contrôle est visible lors de l’exécution. Attention, aucun
changement n’est visible lors de la conception.
6.2.1.2 Méthodes
Méthode Description
Focus Donne le focus au contrôle
Evénements Description
Click Activé lors du clic sur le contrôle
DoubleClick Activé lors du double clic sur le contrôle
Enter Activé lorsque l’utilisateur entre sur le contrôle
GotFocus Activé lorsque le contrôle reçoit le focus
KeyDown Touche enfoncée
KeyPress Touche enfoncée et relachée
KeyUp Touche relachée
LostFocus Activé lorsque le contrôle perd le focus
MouseDown Bouton souris enfoncé
MouseUp Bouton souris relaché
MouseMove Souris déplacée sur le contrôle
MouseWheel Déplacement de la roulette
Resize Déclenché lorsque le contrôle est redimensionné
6.2.2.1 TextBox
Le contrôle TextBox est certainement le contrôle le plus utilisé : il permet de saisir des
chaînes de caractère de 2000 à 32 000 caractères en fonction de la configuration.
Propriété Description
CanFocus Détermine si le contrôle peut recevoir le focus
CharacterCasing Détermine la casse du texte : majuscules (upper) ou minuscules
(lower)
Focused Indique si le contrôle détient le focus
ForeColor Couleur du texte
HideSelection Définit si le contrôle masque la sélection lorsqu’il perd le focus
Lines Tableau correspondant aux lignes du contrôle
MaxLength Nombre de caractères maximum du contrôle
Modified Spécifie si le contenu du champs a été modifié depuis sa création
MultiLine Définit si le contrôle est multi lignes
PasswordChar Définit le caractère servant à masquer un mot de passe
Readonly Contenu du champs en lecture seule
Méthode Description
Clear Efface le contenu du champs texte
Copy / Cut Copie / coupe la sélection dans le presse papier
Focus Donne le focus au contrôle
ResetText Rétabli la valeur initiale du champs
Evénement Description
TextChanged Déclenché lorsque le texte change
L’exemple suivant permet de copier dans le presse papier tout le texte contenu dans le
champs « textbox1 » et de vider ce dernier lorsqu’il reçoit le focus.
6.2.2.2 Label
Le contrôle label est utilisé pour afficher du texte qui ne sera pas éditable par
l’utilisateur. Il est généralement utilisé pour afficher le rôle des différents contrôles.
Propriété Description
BorderStyle Style de bordure
AutoSize Le contrôle s’adapte à la taille du texte
Text Contenu du label
6.2.2.3 CheckBox
Le contrôle Checkbox (Case à cocher) est utilisé pour proposer plusieurs options à
l’utilisateur parmi lesquelles il pourra effectuer plusieurs choix.
Propriété Description
Checked Valeur booléenne indiquant si la case est cochée ou non
CheckState Retourne ou modifie la valeur de la case à cocher en gérant le 3ème
mode (grisé).
ThreeState En standard, une case à cochée peut être cochée ou non. Il existe
cependant un 3ème état « Indéterminé » permettant de grisé la case.
Cette propriété permet d’activer ce 3ème état.
CheckAlign Alignement de la case à cocher par rapport au contrôle
Text Texte associé au contrôle
Evénement Description
CheckedChanged Se produit lorsque la propriété « Checked » change
CheckStateChanged Se produit lorsque la propriété « CheckState » change
L’exemple suivant comporte 3 cases à cocher (pour une sélection d’options voiture) :
- ch1 libellée « Décapotable »
- ch2 libellée « Toit ouvrant »
- ch3 libellée « Ailerons »
Pour des raisons logiques, il n’est pas possible de choisir ch2 et ch3 si ch1 est sélectionné.
Le code suivant permet de décocher et griser les cases.
6.2.2.4 RadioButton
Les boutons radios possèdent les même propriétés et événements que les cases à cocher.
L’exemple suivant travaille avec 3 boutons radio (rad_blue, rad_red, rad_black) qui
modifie la couleur de fond du formulaire en fonction de celui sélectionné. Notez qu’une seule
Au même titre qu’un formulaire, les contrôles GroupBox et Panel sont des conteneurs,
c’est à dire qu’il contiennent eux même d’autres contrôles. Ces contrôles présentent deux
intérêts majeurs :
• Regrouper de manière logique des contrôles afin de les isoler (pour les boutons radio
par exemple)
• Faciliter le placement de plusieurs contrôles car en modifiant la position du conteneur,
vous modifiez la position de tous les contrôles contenus
• Le GroupBox
Ce contrôle possède une seule propriété particulière« text » qui correspond au texte affiché.
• Le Panel
6.2.2.6 Button
Le contrôle « button » est principalement utilisé pour déclencher une action lors du clic.
6.2.2.7 ListBox
Le contrôle ListBox permet l’affichage d’une liste de choix, généralement des chaînes
de caractères, dans laquelle l’utilisateur pour effectuer un ou plusieurs choix.
Propriété Description
MultiColumn Permet un défilement horizontal de la liste
Integralheight Evite l’affichage d’une partie d’un élément de la liste
Items Collection représentant les éléments contenus dans la liste
Sorted Eléments classés par dans l’ordre
Itemheight Hauteur d’un élément de la liste
SelectedIndex Indice de l’élément sélectionné
SelectedIndices Indices des éléments sélectionnés
SelectionMode Mode de sélection des éléments (« MultiExtended » permet une
sélection multiple, « One » permet une seule sélection et « None »
aucune.
Méthode Description
FindString Retourne l’indice de l’élément commençant par le texte recherché
SetSelected Définit un élément en tant que sélectionné ou non
GetSelected Retourne un booléen permettant de savoir si un élément est sélectionné
ou non
Evénement Description
SelectedIndexChange Déclenché lorsque la propriété « SelectedIndex » change
Dim i As Int16
Me.ListBox1.Items.Clear()
Celui ci affiche l’élément sélectionné lors d’un double clic sur le ListBox.
6.2.2.8 ComboBox
6.2.2.9 Splitter
Le contrôle « Splitter » est une nouveauté de la version .Net. Il permet de créer des
barres de séparation redimensionnables pour distribuer l’espace du formulaire entre les
différents contrôles. Splitter est particulièrement utilisé dans les interfaces de type
« explorateur ».
Plutôt qu’un long discours, ci-dessous figure le mode opératoire afin de réaliser
l’interface montrée en exemple.
Propriété Description
MinSize
MinExtra
6.2.2.10 ImageList
Propriété Description
ColorDepth Nombre de couleurs à utiliser pour les images
ImageSize Taille en pixels des images
Transparent Définit la couleur de transparence
Images Collection contenant les images
Chacune des images possède un Index qui sera ensuite utilisé pour les lier aux autres
contrôles. La gestion des images se fait à l’aide d’un assistant :
Le code suivant permet d’ajouter une image dans un Imagelist à partir d’un fichier physique et
la supprimer du contrôle :
6.2.2.11 Treeview
Pour remplir le Treeview, vous pouvez utiliser les méthodes liées au contrôle ou
utiliser l’assistant fourni par le framework. Pour l’ouvrir, utiliser le bouton situé à droite de la
propriété « Nodes » :
Méthode Description
Nodes.add Ajoute un élément
Me.ImageList1.Images.Add(Image.FromFile("C:\peugeot.jpg"))
Me.ImageList1.Images.Add(Image.FromFile("C:\renaud.bmp"))
Me.TreeView1.ImageList = Me.ImageList1
Me.TreeView1.ImageIndex = 0
With noeud1
.Text = "Peugeot"
.ImageIndex = 0
.Nodes.Add("307")
.Nodes.Add("806")
.Nodes.Add("309")
End With
With noeud2
.Text = "Renault"
.ImageIndex = 1
.Nodes.Add("Mégane")
.Nodes.Add("4L")
.Nodes.Add("Laguna")
End With
With Me.TreeView1
.Nodes.Add(noeud1)
.Nodes.Add(noeud2)
6.2.2.12 ListView
Le contrôle listview permet l’affichage d’une liste plate selon les 4 modes de
présentation de l’explorateur Windows :
Au même titre que le TreeView, le ListView posséde des assistants afin de définir leur
contenu. Pour ouvrir l’assistant permettant de gérer la liste, cliquer sur le bouton à droite de la
propriété Items :
Il existe également un assistant pour les colonnes : pour l’ouvrir, utiliser le bouton à droite
de la propriété « Columns ». Celles ci n’apparaîtront que lors d’un affichage au détail.
Propriété Description
AllowColumnReorder Autorise ou non la modification de l’ordre des colonnes
AutoArrange Organise automatiquement la présentation des éléments
Columns Collection de colonnes
FullrowSelect La surbrillance s’étend sur toute la largeur du contrôle
HeaderStyle Style des entête de colonne
Items Collection d’éléments
LabelEdit Permet à l’utilisateur de modifier l’étiquette des éléments
LargeImageList ImageList utilisé pour la présentation « LargeIcon »
MultiSelect Permet la sélection multiple
SmallImageList ImageList utilisé pour toutes les présentation (sauf LargeIcon)
Sorting Mode de tri
View Mode de représentation de la liste
Le code suivant affiche pour chaque caractère son code ascii, le caractère en
minuscule et le caractère en majuscule. Il crée également les colonnes :
With Me.ListView1
.View = View.Details
.Columns.Add("Ascii", 50, HorizontalAlignment.Center)
End With
6.2.2.13 TabControl
Pour chaque « page », il est possible de configurer les options d’apparence qui sont
analogues à celles d’un formulaire.
6.2.2.14 Menus
Pour créer un ou plusieurs menus, vous devez ajouter à votre formulaire le contrôle
« MainMenu ». A ce moment, le contrôle apparaît en dessous du formulaire et un menu est
ajouté. Il n’y a pas d’assistants particulier : pour ajouter un élément, cliquer sur les zones
« Tapez ici » :
Pour définir une barre de séparation, créer un élément avec « - » (tiret) en libellé.
Propriété Description
Checked Indique si l’élément est coché
DefaultItem Définit l’élément en tant qu’élément par défaut
MdiList Affiche la liste des fenêtres enfants dans le cas d’une fenêtre MDI
RadioCheck Indique si l’élément est activé
ShortCut Permet de définir un raccourci pour le menu
ShowShorcut Affiche le raccourci
Text Libellé du menu
Propriété Description
Checked Si activé, spécifie lorsque l’utilisateur a sélectionné une date
CustomFormat Chaine de format pour l’affichage de la date sélectionnée
Format Mode d’affichage de la date
MaxDate Date maximale sélectionnable
MinDate Date minimale sélectionnable
Evénement Description
ValueChanged Déclenché lorsque la valeur change
6.2.2.16 Timer
Propriété Description
Interval Définit l’interval en milliseconde. La valeur doit être comprise entre 1
et 65536
Enabled Active ou désactive le timer
Evénement Description
Tick Déclenché à chaque interval.
Le drag and Drop (ou Glisser Déposer) est une des fonctionnalités en terme
d’ergonomie qui fit le succès de Windows. Il permet de déplacer des informations (Fichiers,
Images, Texte, Objet) au sein d’une même application ou entre plusieurs en accrochant un
élément au curseur pour ensuite le déposer sur l’objet de destination (Liste, champs texte…).
Pour démarrer le drag and drop, vous devez détecter lorsque l’utilisateur quitte un
contrôle avec un bouton enfoncé. Pour cela, on utilise l’événement « MouseMove » :
Ensuite, vous activer le drag and drop en spécifiant l’élément à déplacer ainsi que les
effets. L’élément à déposer est de type Object (donc ce peut être n’importe quel élément).
Pour cela, on utilise la méthode « DoDragDrop » prenant deux arguments : l’objet à déplacer
et les effets voulus. Les effets sont membres de la classe « DragDropEffects ».
Effet Description
All Les données sont copiées, supprimées et parcourues dans la zone cible
Copy Les données sont copiées dans la zone de déplacement
Link Les données sont liées à la cible de déplacement
Move Les données sont déplacées vers la cible de déplacement
En premier lieu, vous devez spécifier que le contrôle cible peut recevoir des éléments :
pour cela, paramétrez la propriété « AllowDrop » à « True ».
Propriété Description
Pour récupérer l’élément ou l’objet déplacé, vous devez utiliser la méthode suivante :
e.Data.GetData(DataFormats.type_données)
Cette méthode est utilisée pour vérifier le type d’objet déplacé (dans la méthode DragEnter).
End If
End Sub
Au final, l’ADO est un ensemble de classe mettant à disposition les objets, méthodes et
évènements nécessaire à l’interfaçage avec une base de données. Ces classes sont disponibles
dans plusieurs espaces de nom :
Le mode déconnecté est une nouveauté de l’ADO .Net. Ce mode permet de travailler
sur des données sans avoir un accès direct et permanent à la base. Il est principalement utilisé
pour les applications « nomades » qui ne disposent pas toujours d’un accès à la source de
données comme par exemple, les portables des commerciaux dans une société.
Fournisseur Classe
ODBC Odbc.OdbcConnection
OLEDB OLEDB.oledbConnection
SQL Server Sqlclient.SQLconnection
7.3.1 Propriétés
Propriété Description
ConnectionString Chaîne utilisée pour la connexion
ConnectionTimeOut Délai en seconde maximum pour l’établissement de la connexion
State Etat de la connexion (Closed, connecting, Open, Executing, Fetching,
Broken)
Provider Fournisseur utilisé
DataSource Emplacement de la base de données
L’exemple suivant ouvre une connexion avec une base Microsoft Access :
L’exemple ci-dessous ouvre une connexion avec un serveur SQL Server, spécifie un
compte SQL pour l’authentification et paramètre le « timeout » :
7.3.2 Méthodes
Méthode Description
Open Ouvre la connexion
Close Ferme la connexion et libère les ressources
BeginTransaction Débute une transaction avec un niveau d’isolation
CreateCommand Crée un objet Command
7.3.3 Evénements
Evénement Description
Lors de la création d’un objet commande, vous devez définir le type d’opération qu’il
devra réaliser ainsi que la connexion à laquelle il est rattaché.
Propriété Description
Commandtext Texte SQL de la requête ou nom de la procédure stockée
CommandType Type de la commande (requête, table, procédure)
Connection Connexion liée à la commande
Transaction Objet transaction lié (voir plus bas)
CommandTimeOut Nombre de seconde pour l’exécution de la commande
Parameters Collection de paramètres à envoyer avec la commande
Méthode Description
Cancel Annule l’exécution de la commande
ExecuteNonQuery Exécute la requête d’action et retourne le nombre de ligne affectées
ExecuteReader Exécute la requête de sélection et retourne un objet de type DataReader
ExecuteScalar Exécute la requête et retourne la valeur scalaire (1ère ligne, 1ère colonne)
CreateParameter Crèe un objet paramètre
ExecuteXMLReader Exécute la requête de sélection et retourne un objet de type XmlReader
dr_sql = com_sql.ExecuteReader
com_sql.Connection = cn_sql
com_sql.CommandType = CommandType.Text
com_sql.CommandText = "update STAGIAIRE set sta_nom = 'toto' where sta_num = -
55"
MsgBox(com_sql.ExecuteNonQuery)
com_sql.Connection = cn_sql
com_sql.CommandType = CommandType.Text
com_sql.CommandText = "select count(*) from STAGIAIRE"
MsgBox(com_sql.ExecuteScalar)
com_sql.Connection = cn_sql
com_sql.CommandType = CommandType.StoredProcedure
com_sql.CommandText = "sp_who"
dr_sql = com_sql.ExecuteReader
Propriété Description
FieldCount Nombre de champs (colonne)
HasRows Détermine si le DataReader comporte 1 ou plusieurs lignes
Méthode Description
Close Ferme le DataReader et remplit les paramètres de retour
Read Avance au prochain enregistrement
GetValue(i) Retourne la valeur du champs à l’indice « i »
GetName(i) Retourne le nom du champs à l’indice « i »
GetType(i) Retourne le type du champs à l’indice « i »
com_sql.Connection = cn_sql
com_sql.CommandType = CommandType.Text
com_sql.CommandText = "select * from FORMATEUR"
dr_sql = com_sql.ExecuteReader
La création d’un DataSet se fait par simple déclaration en spécifiant son nom.
Attention, deux DataSet ne peuvent avoir le même nom.
Méthode Description
AcceptChanges Valide toutes les modifications effectuées dans le DataSet
RefuseChanges Refuse toutes les modifications effectuées dans le DataSet
Propriétés Description
HasChanges Retourne vrai si le DataSet contient des tables dont les
enregistrements ont été modifiés, supprimés, ajoutés
Propriété Description
Columns Collection des colonnes de la table
Constraints Collection des contraintes de la table
Rows Collection des lignes de la table
MinimumCapacity Taille initiale pour les enregistrements
CaseSensitive Mode de comparaison (Respect de la casse ou non)
PrimaryKey Tableau de colonnes faisant parti de la clé primaire
Les objets DataColumn correspondent aux différentes colonnes d’une table. En créant
une colonne, vous devez spécifier plusieurs informations :
• Le nom de la colonne
• Le type de la colonne (ci dessous figure la liste des types utilisables
Type Description
Boolean Valeur booléene
Byte Octets (Entier de 0 à 254)
Char Représente 1 caractère
DateTime Heure & Date
Decimal Décimal
Double Nombre à virgule flottante à double précision
Int16 Entier signé de XX Bits
Propriété Description
AllowDBNull Autorise la valeur Null
AutoIncrement Définit si la colonne est un compteur dont la valeur
s’incrémente automatiquement (Attention, le champs doit
être de type Integer )
AutoIncrementSeed Valeur de départ pour l’autoIncrement
AutoIncrementStep Pas de l’incrément
Defaultvalue Valeur par défaut de la colonne
MaxLength Longueur maximale pour le champs texte
Unique Définit si les valeurs de la colonne doivent être uniques
L’exemple suivant ajoute des champs à la table « personne » en utilisant les différentes
propriétés et spécifie la clé primaire :
'creation de la relation
Dim rel As New DataRelation("personne_categorie",
donnees.Tables("categorie").Columns("cat_num"),
donnees.Tables("personne").Columns("pers_cat_num"))
donnees.Relations.Add(rel)
Une fois que la structure du DataSet est en place, vous devez être en mesure d’ajouter
des données aux DataTable. Chaque DataTable contient une collection de DataRow qui
correspond aux différents enregistrements de la table.
Le parcourt des données permet de lire les enregistrements stockés dans le DataTable.
Il existe deux modes de parcourt :
• Le parcourt linéaire qui consiste à accéder aux enregistrements d’une seule table à
partir de leurs indices (éléments inexistants dans les bases de données relationnelles)
• Le parcourt hiérarchique permettant d’utiliser les relations mises en place entre les
tables d’un DataSet
Dim i As Int16
Dim contenu As String
With donnees.Tables("personne")
For i = 0 To .Rows.Count - 1
contenu &= .Rows(i).Item("pers_num") & " - " & .Rows(i).Item("pers_nom") &
vbCr
Next
End With
MsgBox(contenu)
Le résultat obtenu :
Dim contenu2 As String = "--- Liste des personnes par catégorie---" & vbCr
Dim elt As DataRow
With donnees.Tables("categorie")
For i = 0 To .Rows.Count - 1
contenu2 &= .Rows(i).Item("cat_lib") & vbCr
For Each elt In .Rows(i).GetChildRows("personne_categorie")
contenu2 &= "--> " & elt.Item("pers_nom") & vbCr
Next
Next
End With
MsgBox(contenu2)
Le résultat obtenu :
Dim contenu3 As String = "--- Liste des personnes avec le libellé catégorie---" & vbCr
With donnees.Tables("personne")
For i = 0 To .Rows.Count - 1
Le résultat obtenu :
Pour insérer un nouvel enregistrement, vous devez créer un objet DataRow à partir du
Datatable, configurer les valeurs des différentes colonnes et enfin ajouter le DataRow au
DataTable.
A ce moment, une exception est levée car les enregistrements ne respectent pas la
relation « personne_categorie » :
With donnees.Tables("personne").Rows(0)
.BeginEdit()
.Item("pers_nom") = "saturnin"
.EndEdit()
End With
donnees.Tables("personne").Rows(0).Delete()
L’objet DataView permet d’extraire, filtrer et trier des données issues d’un DataTable.
De plus, il est possible de modifier, ajouter, supprimer des données directement à partir du
DataView et les modifications seront automatiquement retranscrites dans le DataTable lié. Un
DataView peut être vu comme une vue au niveau base de données.
Propriété Description
AllowDelete Autorise la suppression d’enregistrements
AllowEdit Autorise la modification d’enregistrements
Méthode Description
Addnew Ajoute un enregistrement
Delete Supprime un enregistrement
Find Retourne l’indice de l’enregistrement correspondant aux
paramètres de recherche par rapport au champs spécifié dans
l’attribut « sort »
FindRows Retourne un ensemble de DataRow correspondant à la recherche.
Evénement Description
ColumnChanged Valeur de colonne changée
ColumnChanging Valeur de colonne en cours de modification
RowChanged Ligne de la table modifiée
RowChanging Ligne de la table en cours de modification
RowDeleted Ligne de la table supprimée
RowDeleting Ligne de la table en suppression
7.7.1 Création
• OleDbDataAdapter
• SqlDataAdapter
L’importation des données consiste à remplir les DataTable d’une DataSet à partir
d’un DataAdapter défini.
Le remplissage des éléments d’un DataSet se fait à l’aide de la méthode Fill de l’objet
DataAdapter. Plusieurs configurations sont possibles pour la récupération des données en
raison de la surcharge de la méthode Fill :
La première possibilité consiste à remplir une DataTable déjà existant : dans ce cas, la
structure du DataTable doit correspondre au jeu de résultat retourné. Nous verrons plus tard
qu’il est possible de passer outre cette possibilité en utilisant un Mappage des données. La
méthode Fill prend en paramètres un DataSet ainsi que le nom de la table à remplir.
Attention, lors de la création des DataTable, la méthode Fill les nomme « Table1 »,
Table2 … Il est donc vivement conseillé de renommer les tables après exécution.
Jusqu’à présent, pour remplir un DataTable déjà existant, nous devions une structure
identique à celle définit dans la source de données, en particulier au niveau des noms et des
types de champs. Le mappage des données permet de définir pour chaque table et colonne de
la source leur correspondance au niveau du DataTable.
no num
name nom
surname prenom
birth daten
'connexion
Dim cn As New OleDb.OleDbConnection
cn.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=E:\Support\vbnet\bd2.mdb;"
'definition du DataAdapter
Dim da As New OleDb.OleDbDataAdapter("select num, nom, prenom, daten from
Client", cn)
'remplissage
da.MissingMappingAction = MissingMappingAction.Ignore
da.Fill(ds.Tables("customer"))
Dans certains cas, il peut être interressant de ne récupérer que la structure d’une source
de données sans pour autant récupérer les enregistrements qui la composent. Par exemple, un
programme ne faisant que de l’insertion aura besoin de la structure mais pas des données.
Il faut dans ce cas, utiliser la méthode FillSchema et passer les arguments suivants :
Paramètre Description
DataSet Le dataSet vers lequel exporter les données
SchemaType Spécifie si les mappings définit doivent être utilisés :
SchemaType.Mapped oui
SchemaType.Source non
SrcTable Nom du DataTable vers lequel envoyer la structure
'connexion
Dim cn As New OleDb.OleDbConnection
cn.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=E:\bd2.mdb;"
Résultat obtenu :
Cette mise à jour peut cependant lever des conflits au niveau des enregistrements :
imaginez un enregistrement que vous modifiez et qui est supprimé par un utilisateur juste
avant la demande de mise à jour ! Pour réglez ces conflits, le DataAdapter possède un
ensemble d’objets et d’évènements permettant de cibler et résoudre les problèmes.
• Propriétés utilisées
Afin de mener à bien les opérations de mise à jour vers la source de données, l’objet
DataAdapter doit être en mesure de connaître l’état des enregistrement (DataRow) des
différents DataTable.
Pour cela, chacune des lignes possède la propriété « RowState » pouvant prendre les
valeurs suivantes :
Valeur Description
1 Detached : la ligne n’est encore intégrée à aucun DataTable
2 Unchanged : Aucun changement depuis le dernier appel de AcceptChanges
4 Added : la ligne a été ajoutée
8 Deleted : La ligne a été supprimée
16 Modified : La ligne a été modifiée
En fonction de l’état des lignes, l’objet DataAdapter exécutera des requêtes différentes
afin de mettre à jour la source de données. Le comportement du DataAdapter est définit par
trois objets command :
- InsertCommand
- UpdateCommand
- DeleteCommand
Pour créer ses commandes, vous pouvez soit utiliser la classe CommandBuilder
correspondant à votre fournisseur de données qui générera automatiquement les commandes
ou alors les paramétrer vous même :
• Classe CommandBuilder
'connexion
Dim cn As New OleDb.OleDbConnection
cn.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=E:\Support\vbnet\bd2.mdb;"
'dataset, dataadapter
Dim ds As New DataSet
Dim da As New OleDb.OleDbDataAdapter("select * from Client", cn)
da.Fill(ds, "Client")
Les commandes créées sont des requêtes SQL contenant plusieurs paramètres
(représentés par des ?).
Dans le cas d’une commande Delete ou Update, les commandes générés prennent en
compte le fait que l’enregistrement cible à mettre à jour doit avoir les même valeurs que lors
de la lecture initiale. Si une des valeurs de l’enregistrement à été modifiée sur la source de
données, la mise à jour ne sera pas validée et une erreur sera retournée.
o Commande Insert
Notez que dans le cas d’une clé primaire avec numéroauto ou AutoIncrement, le
champs n’est pas spécifiée car il est généré par la base de données.
o Commande Delete
DELETE FROM Client WHERE ( (num = ?) AND ((? = 1 AND nom IS NULL) OR (nom =
?)) AND ((? = 1 AND prenom IS NULL) OR (prenom = ?)) AND ((? = 1 AND daten IS
NULL) OR (daten = ?)) )
o Commande Update
UPDATE Client SET nom = ? , prenom = ? , daten = ? WHERE ( (num = ?) AND ((? = 1
AND nom IS NULL) OR (nom = ?)) AND ((? = 1 AND prenom IS NULL) OR (prenom = ?))
AND ((? = 1 AND daten IS NULL) OR (daten = ?)) )
Dans l’exemple suivant, la commande de suppression ne filtre les enregistrements que par
rapport à leur clé primaire : ainsi, si un autre utilisateur a modifié les enregistrements entre
temps, la suppression se fera quand même.
Pour déclencher la mise a jour des données, il suffit d’appeler la méthode Update de
l’objet DataAdapter en passant en paramètre le DataSet ainsi que le nom de la table du
DataSet à valider.
da.Update(ds, "Client")
If ds.HasChanges Then
da.Update(ds, "Client")
Else
MsgBox("aucun changement")
End If
Il est également possible de récupérer à partir d’un DataTable uniquement les lignes
ayant subies des modifications (ajout ou suppression ou modification). De cette façon, vous
êtes en mesure d’actualiser qu’une partie des lignes modifiées.
Une fois la mise à jour effectuée, la propriété « RowState » des différents DataRow
concernés est passée à « UnChanged » spécifiant que la ligne est validé.
Lors de la mise à jour de la base de données avec la méthode Update, plusieurs conflits
peuvent apparaître. Un conflit est une exception de mise à jour de la source.
Try
Da.update(ds, ‘’Clients’’)
Catch ex as Exceptio
Msgbox(‘’Erreur de mise à jour ‘’)
End Try
Dans le cas d’une erreur de mise à jour, la mise à jour des lignes suivantes est ommise.
Afin de forcer la mise à jour de toutes les lignes (même celles suivants un conflit), vous devez
paramétrer le comportement du DataAdapter :
Da.ContinueUpdateOnErrors = true
Après une mise à jour, toutes les lignes voit leur propriété « RowState » à « Unchanged »
sauf les lignes conflictuelles : la méthode consiste donc à parcourir les RowState et récupérer
seulement les lignes dont « RowState » est différent de « UnChanged ».
da.ContinueUpdateOnError = True
da.Update(ds, "Client")
La seconde méthode consiste à récupérer les enregistrements non validés par la méthode
Update par l’intermédiaire de la méthode « GetChanges » : vous créez à partir de cette
méthode un nouvel objet « DataTable » et vous pouvez ensuite parcourir les enregistrements
de cette table afin d’identifier les conflits.
Pour la gestion des conflits, il est également possible d’utiliser les évènements
« RowUpdating » et «RowUpdated » respectivement déclenchés avant et après la mise à jour
d’un enregistrement (c’est à dire l’envoi de la commande correspondante).
L’événement RowUpdating est utilisé pour prévenir les sources de conflits : par exemple,
dans une application ou deux utilisateurs peuvent simultanément modifier différents champs
d’un même enregistrement, un conflit sera automatiquement déclenché pour le dernier faisant
la mise à jour. L’événement RowUpdating peut vous permettre de modifier
l’UpdateCommande et n’y inclure que les champs modifiés (ceux dont l’ancienne valeur est
différente de la nouvelle).
L’événement RowUpdated quand à lui permet de résoudre les conflits une fois que ceux ci
sont déclenchés afin de ne pas avoir d’autres répercutions sur les enregistrements suivants.
Propriété Description
StatementType Type de la commande
Command Objet commande
Row Objet DataRow à actualiser
Status Règle de gestion des lignes suivantes
Errors Erreurs générées (seulement dans RowUpdated)
Case DataRowState.Modified
If Not TypeOf e.Errors Is DBConcurrencyException Then
'erreur d'integrite referentielle
MsgBox("Erreur de mise à jour" & vbCr & "type
erreur = " & e.Errors.Message)
Else
'conflit d'actualisation, l'enregistrement n'existe
plus
MsgBox("L'enregistrement à mettre à jour n'existe
plus dans la source de données")
End If
End Select
End If
End Sub
Dans le cas d’un problème d’actualisation bloquant, il peut être interressant d’annuler
toutes les actualisations déjà réalisées afin de laisser la base de données dans un état cohérent.
Pour annuler toutes les actualisations déjà faîtes, il suffit de lier les commandes à une
transaction (regroupement de commande) car l’objet transaction possède les méthodes
« commit » et « rollback » qui permettent respectivement de valider et d’annuler toutes les
commandes d’une transaction.
L’exemple suivant effectue les mises à jour et annule l’ensemble des commandes si une
erreur survient.
'connexion
cn.ConnectionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=E:\Support\vbnet\bd2.mdb;"
'dataset, dataadapter
Dim ds As New DataSet
da = New OleDb.OleDbDataAdapter("select * from Client", cn)
da.Fill(ds, "Client")
da.InsertCommand.Transaction = transac
da.DeleteCommand.Transaction = transac
da.UpdateCommand.Transaction = transac
'fermeture de la connexion
cn.Close()
- Liaison de données simple : une seule propriété du contrôle est liée à une colonne de
la source de données (exemple : champs texte)
Lors de la mise en place de contrôles liés, les objets suivants sont mis à contribution :
7.8.1.1 DataBinding
Cet objet permet de lier une propriété d’un contrôle à un champs de la source de données.
7.8.1.2 ControlBindingCollection
Cet objet contient l’ensemble des objets Binding pour un contrôle (par exemple dans le
cas d’un TextBox dont le contenu serait définit par le champs « nom » et la couleur de fond
par le champs « color »).
7.8.1.3 BindingManagerBase
Cet objet contient l’ensemble des objets Binding liés à la même source de données. C’est
grâce à lui que vous pourrez par exemple parcourir les données (suivant, précédent), ajouter
ou supprimer des enregistrements etc…
Propriété Description
Count Nombre de ligne gérées par le BMB
Position Indice de la ligne en cours
Méthode Description
AddNew Ajoute un nouvel enregistrement
CancelCurrentEdit Annule l’édition ou l’ajout en cours
RemoveAt(indice) Supprime l’enregistrement à la position Indice
7.8.1.4 BindingContext
Contient l’ensemble des objets BindingManagerBase pour les contrôles d’un formulaire
par exemple.
Pour définir la connexion, ouvrir l’explorateur de serveur, clic droit sur « Connexions de
données », Ajouter une connexion :
Une fois la connexion définie, vous devez générer les objets Connexion et
DataAdapter qui seront utilisés pour lier vos contrôles a la source de données : pour cela,
faîtes glisser la table voulue sur le formulaire : les objets connexion et DataAdapter sont alors
créés.
Afin de pouvoir faire références aux données de la table sélectionnée dans les
différents contrôles, vous devez générer le groupe de données. Cette opération permet de
générer un DataSet contenant les informations des différentes tables.
Pour générer le groupe de données, clic droit sur l’objet DataAdapter précédemment
créé, « Générer le groupe de données » :
Une fois toutes ces opération réalisées, vous êtes en mesure de lier les différents
contrôle aux données du DataSet. Cette opération est différente suivant les contrôles utilisés :
• Pour un TextBox
• Pour un ListBox
End Sub
Pour cela, il suffit de créer dans le même DataSet deux tables liées par une relation et
de modifier la propriété « DataMember » en lui passant en paramètre le nom de la table maître
et le nom de la relation.
'liaison du DataGrid
Me.DataGrid1.CaptionText = "Liste des commandes"
Me.DataGrid1.DataSource = Me.ds
Me.DataGrid1.DataMember = "Client.client_commande"
'recupere le context
bmb = Me.BindingContext(Me.ds, "Client")