Support de Formation VB2008 Module1 - v1.0-1

L’ENVIRONNEMENT
DE DEVELOPPEMENT
INTEGRE VISUAL
BASIC 2008
SUPPORT DE FORMATION
De la base du langage basic à la gestion des

applications Windows orientée base de données.
Par SEKE MAVINGA Jonathan

Janvier 2010
MODULE I
TABLE DES MATIERES
I. GENERALITES .................................................................................................................. 3
SECTION I : INTRODUCTION .............................................................................................. 3
I.1. Historique de Visual Basic .Net .................................................................................... 3
I.2. La programmation Orienté Objet.................................................................................. 3
I.3. Le langage UML (Unifield Modeling Language) ........................................................... 4
SECTION II : LES OUTILS D’ANALYSE ET CONCEPTION ................................................ 4
SECTION III : L’ENVIRONNEMENT DE TRAVAIL DE VISUAL STUDIO ............................. 5
I.4. Présentation de l’environnement de travail .................................................................. 5
I.5. Création d’un projet en VB ........................................................................................... 7
II. LE LANGAGE VISUAL BASIC.Net .................................................................................11
SECTION I : LES BASES DU LANGAGE ...........................................................................11
II.1. Les types de données et déclaration de variable .......................................................11
II.2. La conversion de type ................................................................................................13
II.3. Les structures ............................................................................................................13
II.4. Les operateurs et expressions ...................................................................................13
II.5. Les instructions de contrôle .......................................................................................14
II.6. Les structures de répétition........................................................................................16
II.7. Les tableaux de données ...........................................................................................17
II.8. Les collections d’objets ..............................................................................................18
II.9. La gestion des exceptions (Try, Catch et Finally) .......................................................20
II.10. Passage de paramètres à une fonction....................................................................21
SECTION II : L’ASPECT ORIENTE OBJET DANS VISUAL BASIC ...................................23
II.11. Les classes, le constructeur, le destructeur et les propriétés ...................................23
II.12. Les méthodes et attributs de classe (Shared) ..........................................................25
II.13. Les objets et les références d’objets ........................................................................25
II.14. Passage d’un objet à une fonction ...........................................................................25
II.15. Les espaces de nom et les Assembly ......................................................................26
II.16. Les interfaces et les références ...............................................................................29
II.17. Les Surcharges de méthodes ..................................................................................30
II.18. L’héritage et le Polymorphisme ................................................................................30
II.19. La portée des déclarations.......................................................................................32
II.20. Introduction aux génériques.....................................................................................32
II.21. Quelques classes couramment utilisées ..................................................................33
III. LA GESTION DES FICHIERS .........................................................................................34
III.1. La classe File............................................................................................................34
III.2. Exemples ..................................................................................................................34
IV. INTRODUCTION AU LANGAGE LINQ (Language Integrated Query) .........................36
IV.1. Définition ..................................................................................................................36
IV.2. L’interface IEnumerable et IEnumerable<(Of T)> .....................................................36
IV.3. Structure d’une requête LINQ ...................................................................................36
IV.4. Les opérateurs de requête de LINQ .........................................................................37
SEKE MAVINGA Jonathan / Formateur

1
V. GESTION DES APPLICATIONS WINDOWS ..................................................................44
V.1. Création d’une application Windows ..........................................................................44
V.2. Les propriétés les plus courantes de contrôle............................................................45
V.3. Définition du formulaire de démarrage.......................................................................46
V.4. Gestion des événements ...........................................................................................46
V.5. La fenêtre Multiple Document Interface (MDI) ...........................................................47
V.6. La barre de Menu, la barre d’outils, le Menu contextuel et les boites de dialogues ....48
VI. MANIPULATION DE BASE DE DONNÉES ET GÉNÉRATION DE RAPPORTS ...........49
SECTION I : LA MANIPULATION DES BASES DE DONNEES ..........................................49
VI.1. Généralités ...............................................................................................................49
VI.2. Les modes d'exploitation d'une source de données..................................................50
VI.3. Structuration du logiciel en couche ...........................................................................50
VI.4. Notion de base de données (SGBD PostgreSql) ......................................................51
VI.5. Connexion à une base de données ..........................................................................52
VI.6. Extraction des données dans la base de données....................................................53
VI.6. Mise à jour de la base de données ...........................................................................53
VI.7. Notions de transaction ..............................................................................................54
VI.8. Utilisation d’un fichier de configuration .....................................................................55
SECTION II : LA GENERATION DES RAPPORTS (REPORTING) .....................................56
VI.9. Création des rapports avec Crystal Report ...............................................................56
VI.10. Chargement de données dans un rapport ; ............................................................59
VI.11. Afficher, Imprimer et Exporter un rapport. ...............................................................59
VII. EMPAQUETAGE ET DEPLOIEMENT DE L’APPLICATION .........................................62
VII.1. Ajout d’un projet Configuration et déploiement dans la solution ...............................62
VII.2. Préparation des fichiers du setup ............................................................................63
VII.3. Embarquer les composants requis dans le projet setup...........................................64
VII.4. Génération du fichier Setup .....................................................................................65

2
I. GENERALITES
SECTION I : INTRODUCTION
I.1. Historique de Visual Basic .Net
Visual basic est un langage assez facile à utiliser.
VB.NET est un langage récent qui a été disponible en versions beta depuis l’année 2000
avant d’être officiellement disponible en février 2002 en même temps que la plate-forme
.NET de Microsoft à laquelle il est lié. VB.NET ne peut fonctionner qu’avec cet
environnement d’exécution, environnement disponible pour le moment que sur les machines
Windows.
Ensuite est apparue la version 2003 suivis de la version 2005.
La plate-forme .NET permet l'exécution de programmes écrits en différents langages. Il suffit
que le compilateur de ceux-ci sache produire du code IL (Intermediate Language), code
exécuté par la machine virtuelle .NET.
Toutes les classes de .NET sont disponibles aux langages compatibles .NET ce qui tend à
gommer les différences entre langages dans la mesure où les programmes utilisent
largement ces classes. Le choix d'un langage .NET devient affaire de goût plus que de
performances.
Une des évolutions notables de VB.Net est d'être totalement orientée objet, contrairement à
ses versions précédentes.
La version 2008 permet d’implémenter des applications fonctionnant sur le FrameWork 2.0,
3.0 ou 3.5. La nouveauté de Visual Basic 2008 par rapport à la version 2005 est l’ajout du
Langage LINQ (Language Integrated Query) qui permet d’interroger des collections d’objets.
I.2. La programmation Orienté Objet

La programmation est un paradigme de programmation (une manière de programmer) le
plus utilisé de nos jours.
Elle consiste à modéliser informatiquement un ensemble d'éléments d'une partie du monde
réel (que l'on appelle domaine) en un ensemble d'entités informatiques. Ces entités
informatiques sont appelées objet.
Il s'agit de données informatiques regroupant les principales caractéristiques des éléments
du monde réel (la taille, la couleur, ...).
Simula a été le premier langage de programmation à implémenter le concept de classes en
1967. En 1976, Smalltalk implémente les concepts d'encapsulation, d'agrégation, et
d'héritage (les principaux concepts de l'approche objet).
La notion des Objets
Un objet est caractérisé par :
Les attributs: Il s'agit des données caractérisant l'objet. Ce sont des variables
stockant des informations de l'état de l'objet.
Les méthodes (appelées parfois fonctions membres): Les méthodes d'un objet
caractérisent son comportement, c'est-à-dire l'ensemble des actions (appelées
opérations) que l'objet est à même de réaliser.
Ces opérations permettent de faire réagir l'objet aux sollicitations extérieures (ou d'agir sur
les autres objets).
De plus, les opérations sont étroitement liées aux attributs, car leurs actions peuvent
dépendre des valeurs des attributs, ou bien les modifier.

3
La notion de classe
On appelle classe la structure d'un objet, c'est-à-dire la déclaration de l'ensemble des entités
qui composeront un objet. Un objet est donc "issu" d'une classe, c'est le produit qui sort d'un
moule. En réalité on dit qu'un objet est une instanciation d'une classe, c'est la raison pour
laquelle on pourra parler indifféremment d'objet ou d'instance.
Une classe est composée de deux parties:
Les attributs (parfois appelés données membres): il s'agit des données représentant
l'état de l'objet.
Les méthodes (parfois appelées fonctions membres): il s'agit des opérations
applicables aux objets.
I.3. Le langage UML (Unifield Modeling Language)

UML (Unified Modeling Language, traduisez "langage de modélisation objet unifié") est né
de la fusion des trois méthodes qui ont le plus influencé la modélisation objet au milieu des
années 90 : OMT, Booch et OOSE.
UML est une notation graphique conçue pour représenter, spécifier, construire et
documenter les systèmes logiciels.
Ses principaux objectifs sont :
La modélisation de systèmes utilisant les techniques orientées objet, depuis la
conception jusqu’à la maintenance ;
La création d’un langage abstrait compréhensible par l’homme et interprétable par les
machines.
UML s’adresse à toutes les personnes chargées de la production, du déploiement et de suivi
de logiciels (analystes, programmeurs, chefs de projets, architectes,…), mais également
servir à la communication entre le client et les utilisateurs du logiciel.
SECTION II : LES OUTILS D’AN ALYSE ET CONCEPTION

Le processus de développement d’un logiciel commence par l’analyse et la conception.
UML propose une série de diagrammes parmi lesquels nous pouvons citer :
Le diagramme de cas d’utilisation (accompagné d’une description de cas
d’utilisation) : qui représente les différents cas d’utilisation du système ;
Le diagramme de séquence : qui représente l’interaction entre les acteurs et le
système suivant les cas d’utilisations.
Le diagramme de classes : représente les différentes classes du système ainsi que
leurs associations.
En pratique on distingue généralement le diagramme de classe conceptuel (abstraction
des attributs et méthodes) et le diagramme de classe détaillé.
Le diagramme de paquetage : représente le découpage du système en plusieurs
modules complémentaires.
En dehors de diagrammes UML un autre élément important est la représentation graphique
des différentes fenêtres de l’application.
Ces différents éléments peuvent être élaborés dans Visio Architect intégré dans la version
Team de Visual Studio ou dans Microsoft Office Visio.

4
SECTION III : L’ENVIRONNEMENT DE TRAVAIL DE VISUAL
STUDIO
I.4. Présentation de l’environnement de travail
L’environnement de travail de Visual Studio se présente comme suit (cas d’une
application Windows) :
3
1
1. L’explorateur des solutions : contient tous les éléments de la solution. Une

solution est l’ensemble des éléments constituant votre logiciel, elle peut avoir un
ou plusieurs projets.
2. La boite de propriétés : elle présente les propriétés de l’objet sélectionné.

5
3. La boite à outils : elle contient les différents contrôles utilisés pour construire
l’interface graphique entre l’utilisateur et le logiciel.
4. La zone de travail : c’est l’espace où s’affiche les différents éléments utilisés lors
du développement (Formulaire, classes,…).

6
I.5. Création d’un projet en VB
Visual studio en général gère son contenu dans un ensemble des fichiers appelé
« Solution » qui peut contenir un ou plusieurs « projets ».
I.5.1. Nouveau projet
Voici de quelle manière un nouveau projet est créé en Visual Basic :
Cliquer sur le menu Fichier – Nouveau projet ;
Dans la boite de dialogue, sélectionner Visual Basic – Application Windows et
saisissez le nom du projet « MonProjet»;
Note : Cette boite de dialogue peut s’afficher différemment selon la distribution de Visual
Studio.
Cliquer sur le bouton OK.
I.5.2. Compilation, débogage et Exécution d’un projet ;
a) Compilation d’un projet
La compilation d’un programme est une opération pendant laquelle l’exécution du
programme est créée. Cette opération est effective si et seulement si il n’y a aucune erreur
de syntaxe.
Elle se fait via le menu Générer – Générer nom_du_projet.
Une progression est affichée sur la barre d’état puis un message de succès ou d’échec de
l’opération.
b) Débogage d’un projet
Le débogage d’un projet revient à l’exécuter en mode debug, mode dans lequel le
programmeur peut suivre l’exécuter pas à pas en utilisant éventuellement des point d’arrêt.
Elle se fait via le menu Déboguer – Démarrer le débogage ou en appuyant sur la touche F5.

7
c) Exécution d’un projet.
Exécuter un projet revient à le démarrer sans le mode debug.
Elle se fait via le menu Déboguer – Exécuter sans débogage ou en appuyant sur les touches
Ctrl+F5.
I.5.3. Utilisation du système de gestion de versions de code source Visual
Source Safe.
Visual Source Safe (VSS) est une solution efficace de gestion de code source qui est
inévitable pendant le développement en équipe.
Le fonctionnement de VSS est tel qu’une copie de la solution (Projet) existe dans la machine
locale (version locale) et une autre copie est gérée dans le serveur VSS (Version du
serveur).
Dans le cadre de cette formation, nous supposons que :
- les machines sont connectées dans un réseau local ;
- VSS est installé et configuré ;
- chaque développeur dispose d’un compte d’accès au serveur VSS.
a) Ajout d’un projet dans Visual Source Safe
L’ajout d’un projet dans VSS se fait comme suit :
- Click droit sur le projet dans l’explorateur de solution ;
- Cliquer sur le Menu « Ajouter un projet au contrôle de code source safe » ce qui
affiche la fenêtre de connexion de VSS.
- Après connexion, la fenêtre d’ajout du projet s’affiche et cliquer sur le bouton OK.

8
- Une boite de dialogue demande la création de la racine du projet sous VSS. Cliquer
sur Yes.
L’icône d’un cadenas apparait sur chaque élément de l’explorateur de projet qui est
maintenant sous contrôle de VSS.
b) Extraction et Archivage des codes sources

Chaque élément sous contrôle de VSS doit être extrait avant toute modification. Cette action
d’extraire pour modification verrouille le fichier afin d’éviter des modifications simultanées.
L’extraction d’un fichier se fait comme suit :
- Click droit sur l’élément à extraire ;
- Cliquer sur le menu Extraire pour modification
Une fois extrait, l’icône s’affiche devant l’élément, il peut alors être modifié. Les autres

9
développeurs du projet verront plutôt l’icône signifiant que l’élément est extrait par un
autre développeur.
L’archivage est l’opération contraire qui consiste à répercuter les modifications apportées
dans la version locale vers le serveur VSS.
L’archivage se fait comme suit :
- Click droit sur l’élément extrait ou sur le projet (si plusieurs éléments ont été extraits);
- Cliquer sur le menu Archiver…
L’icône du cadenas apparait sur l’élément ou les éléments archivés.
Un nouvel élément ajouté au projet aura l’icône
c) Obtenir la dernière version du serveur
L’obtention de la dernière version du serveur consiste à écraser la version locale par celle du
serveur VSS. Ainsi toutes les modifications archivées par les membres de l’équipe de
développement sont dans la machine locale.
Procédure :
- Click droit sur le projet ;
- Cliquer sur le menu Obtenir la dernière version (Récursif)

10
II. LE LANGAGE VISUAL BASIC.NET
SECTION I : LES BASES DU LANGAGE
Cette section est consacrée à traiter d’abord VB.NET comme un langage de programmation
classique puis nous aborderons les classes et les objets.
II.1. Les types de données et déclaration de variable

II.1.1. Types de données
Dans un programme on trouve deux choses : les données et les instructions qui les
manipulent.
VB.NET utilise les types de données suivants:
les nombres entiers, réels et décimaux
les caractères et chaînes de caractères
les booléens
les dates
les objets
Voici une liste non exhaustive des types de données prédéfinis en VB.Net
Type VB Type .NET Taille Plage de valeurs

équivalent
Boolean System.Boolean 2 octets True ou False
Byte System.Byte 1 octet 0 à 255 (non signés).
Char System.Char 2 octets 0 à 65 535 (non signés).
Date System.DateTime 8 octets 0:00:00 le 1er janvier 0001 à 23:59:59 le 31
décembre 9999
Decimal System.Decimal 16 octets 0 à +/-79 228 162 514 264 337 593 543 950 335
sans décimale ; 0 à +/-
7,9228162514264337593543950335 avec 28
décimales ; le plus petit nombre différent de zéro
étant +/-0,0000000000000000000000000001 (+/-
1E-28).
Double System.Double 8 octets -1,79769313486231E+308 à
-4,94065645841247E-324 pour les valeurs
négatives ; 4,94065645841247E-324 à
1,79769313486231E+308 pour les valeurs
positives.
Integer System.Int32 4 octets -2 147 483 648 à 2 147 483 647.
Long System.Int64 8 octets -9 223 372 036 854 775 808 à 9 223 372 036 854
775 807
Object System.Object 4 octets N'importe quel type peut être stocké dans une
variable de type Object
Short System.Int16 2 octets -32 768 à 32 767
Single System.Single 4 octets -3,402823E+38 à -1,401298E-45 pour les valeurs
négatives ; 1,401298E-45 à
3,402823E+38 pour les valeurs positives.
String System.String 0 à environ 2 milliards de caractères Unicode
(classe)

11
Notation de données littérales
Le littérale est utilisé lorsqu’on initialise une valeur à une variable.
Exemple :
Integer : 145, -7, &FF (hexadécimal)
Long : 100000L
Double : 134.789, -45E-18 (-45 10-18)
Single : 134.789F, -45E-18F (-45 10-18)
Decimal : 100000D
Char : "A"c
String : "aujourd'hui"
Boolean : true, false
date : New Date(2003, 1, 1) pour le 01/01/2003
Notons les points suivants :
100000L, la lettre L pour signifier qu'on considère le nombre comme un entier long
134.789F, la lettree F pour signifier qu'on considère le nombre comme un réel simple
précision
100000D, la lettre D pour signifier qu'on considère le nombre comme un réel décimal
"A"c, pour transformer la chaîne de caractères "A" en caractère 'A'
la chaîne de caractères est entouré du caractère ". Si la chaîne doit contenir le
caractère ", on double celui-ci comme dans "abcd""e" pour représenter la chaîne
abcd"e.
II.1.2. Déclaration des variables
a) Rôle
Les données manipulées par un programme sont caractérisées par un nom et un type, et
celles-ci sont stockées en mémoire.
Au moment de la traduction du programme, le compilateur affecte à chaque donnée un
emplacement en mémoire caractérisé par une adresse et une taille. Il le fait en s'aidant
des déclarations faites par le programmeur.
Par ailleurs celles-ci permettent au compilateur de détecter des erreurs de
programmation. Ainsi l'opération x=x*2 sera déclarée erronée si x est une chaîne de
caractères par exemple.
b) Déclaration des constantes
La syntaxe de déclaration d'une constante est la suivante :
const identificateur as type=valeur
Par exemple Const PI As Double = 3.14159.
Utilité de déclarer des constantes
1. La lecture du programme sera plus aisée si l'on a donné à la constante un nom
significatif : const taux_tva as Single=0.186F
2. La modification du programme sera plus aisée si la "constante" vient à changer car il
suffira de le changer à un seul endroit sinon ce serait alors de nombreuses
instructions qu'il faudrait modifier.
c) Déclaration des variables
Une variable est identifiée par un nom et se rapporte à un type de données. VB.NET ne
fait pas la différence entre majuscules et minuscules, ainsi les variables NOM et nom
sont identiques.
Une variable peut être initialisée lors de sa déclaration.
La syntaxe de déclaration d'une ou plusieurs variables est :
dim variable1,variable2,...,variablen as identificateur_de_type
Où identificateur_de_type est un type prédéfini ou bien un type défini par le

12
programmeur.
Exemple :
Dim nom, postnom, prenom As String
Dim perimetre As Single
II.2. La conversion de type

Voici de quelle manière la conversion de type de variable se fait en VB.Net :
nombre -> chaîne : nombre.ToString() ou "" & nombre
objet -> chaîne : objet.ToString()
chaine -> Integer : Integer.Parse(chaine) ou Int32.Parse
chaîne -> Long : Long.Parse(chaine) ou Int64.Parse
chaîne -> Double : Double.Parse(chaîne)
chaîne -> Single : Single.Parse(chaîne)
NB : Les nombres réels sous forme de chaîne de caractères doivent utiliser la virgule et non
le point décimal. Ainsi on écrira Dim d As Double = -14.98 mais Dim d1 As Double =
Double.Parse("100,87")
II.3. Les structures

Une structure permet de regrouper dans une variable composée des données de type
différent. La structure VB.NET est directement issue de la structure du langage C et est très
proche de la classe.
Une structure est définie comme suit :
Structure personne
' attributs
...
' propriétés
...
' méthodes
...
End Structure
Exemple :
Structure personne
Public nom As String
Public age As Integer
End Structure
II.4. Les operateurs et expressions

II.4.1. Liste des opérateurs
Voici la liste des opérateurs utilisés en VB.Net
Arithmétique : ^, –, *, /, \, Mod, +, =
Assignation : =, ^=, *=, /=, \=, +=, -=, &=
Comparaison : =, <>, <, >, <=, >=, Like, Is
Concaténation : &, +
Opérations logiques : /de bits Not, And, Or, Xor, AndAlso, OrElse
II.4.2. Expression arithmétique

Les opérateurs des expressions arithmétiques sont les suivants :
+ : addition, - : soustraction, * : multiplication, / : division réelle, \ : quotient de division
entière, Mod : reste de la divion entière, ^: élévation à la puissance.

13
La priorité entre eux est la suivante :
Primaire : Toutes les expressions sans opérateur (fonctions, parenthèses)
Élévation à la puissance : ^
Négation unaire : +, -
Multiplication : *, /
Division entière : \
Modulo : Mod
Addition :+, -
II.4.3. Expressions relationnelles
= : égal à, <> : différent de, < : plus petit que (strictement), > : plus grand que
(strictement), <= : inférieur ou égal, >= : supérieur ou égal, Like : correspond à un
modèle, Is : identité d'objets.
Tous ces opérateurs ont la même priorité. Ils sont évalués de la gauche vers la droite. Le
résultat d'une expression relationnelle est un booléen.
II.4.4. Expressions booléennes
And : et logique, Or : ou logique, Not : négation, Xor : ou exclusif. op1 AndAlso op2 : si
op1 est faux, op2 n'est pas évalué et le résultat est faux.
op1 OrElse op2 : si op1 est vrai, op2 n'est pas évalué et le résultat est vrai.
La priorité de ces opérateurs entre-eux est la suivante :
NOT logique Not
AND logique And, AndAlso
OR logique Or, OrElse
XOR logique Xor
Le résultat d'une expression booléenne est un booléen.
II.4.5. Traitement de bits
On retrouve d'une part les mêmes opérateurs que les opérateurs booléens avec la même
priorité. On trouve également deux opérateurs de déplacement : << et >>. Soient i et j
deux entiers.
i<<n décale i de n bits sur la gauche. Les bits entrants sont des zéros.
i>>n décale i de n bits sur la droite. Si i est un entier signé (signed char, int, long) le bit de
signe est préservé.
i & j fait le ET logique de i et j bit à bit.
i | j fait le OU logique de i et j bit à bit.
~i complémente i à 1
i^j fait le OU EXCLUSIF de i et j
II.4.6. Opérateur associé à une affectation
Il est possible d'écrire a+=b qui signifie a=a+b. La liste des opérateurs pouvant se
combiner avec l'opération d'affectation est la suivante : combinaison d'opérateurs : ^=,
*=, /=, \=, +=, -=, &=
NB : Lorsqu'un opérande est placé entre deux opérateurs de même priorité,
l'associativité des opérateurs régit l'ordre dans lequel les opérations sont
effectuées. Tous les opérateurs sont associatifs à gauche, ce qui signifie que les
opérations sont exécutées de gauche à droite. La priorité et l'associativité peuvent
être contrôlées à l'aide d'expressions entre parenthèses.
II.5. Les instructions de contrôle

II.5.1. Arrêt
La méthode Exit définie dans la classe Environment permet d'arrêter l'exécution d'un
programme : Public Shared Sub Exit(ByVal exitCode As Integer)

14
Elle arrête le processus en cours et rend la valeur exitCode au processus père. La valeur
de exitCode peut être utilisée par celui-ci.
Environment.Exit(0) arrêtera l'exécution du programme avec une valeur d'état à 0.
II.5.2. Structure de choix simple
a) If … Then … Else … End if
Elle permet d’exécuter une action ou une suite d’action suivant une condition.
Syntaxe :
If condition then
actions_alors
Else
actions_sinon
End If
Chaque action est sur une ligne, la clause else peut être absente.
On peut imbriquer les structures de choix.
Exemple :
If a < 0 Then MessageBox.Show("a est negatif")
If res Mod 7 = 0 Then

MessageBox.Show("Res est multiple de 7")
Else
MessageBox.Show("Res n’est pas multiple de 7")
End If
b) Fonction IIf : retourne un ou deux objets selon l'évaluation d'une expression.

Syntaxe : Public Function IIf(Expression, partieVrai, partieFausse) As Object
Exemple :
Dim resultat As String
resultat = IIf(valeur Mod 7 = 0, "Res est multiple de 7", "Res
n'est pas multiple de 7")
IIf évalue les trois arguments
c) Opérateur If : Utilise l'évaluation de court-circuit pour retourner conditionnellement l'une

de deux valeurs
Syntaxe : If ([argument1,] argument2, argument3)
Exemple :
MessageBox.Show(If(diviseur <> 0, nombre \ diviseur, 0))
Cet opérateur est équivalent à la fonction IIf avec une légère différence sur l’évaluation
des arguments (IIf évalue toujours les trois arguments, alors qu'un opérateur If qui a trois
arguments n'en évalue que deux).
II.5.3. Structure de cas
La syntaxe est la suivante :
Select Case expression
Case liste_valeurs1
actions1()
Case liste_valeurs2
actions2()
...
Case Else
actions_sinon()
End Select
Le type de expression doit être l'un des types suivants : Boolean, Byte, Char, Date,

15
Decimal, Double, Integer, Long, Object, Short, Single et String
La clause case else peut être absente.
liste_valeursi sont des valeurs possibles de l'expression. listes_valeursi représente
une liste de conditions condition1, condition2, ..., conditionx.
Si expression vérifie l'une des conditions, les actions derrière la clause [liste_valeursi]
sont exécutées.
Les conditions peuvent prendre la forme suivante :
- val1 to val2 : vrai si expression appartient au domaine [val1,val2]
- val1 : vrai si expression est égal à val1
- is > val1 : vrai si expression > val1. Le mot clé is peut être absent
- idem avec les opérateurs =, <, <=, >, >=, <>
Seules les actions liées à la première condition vérifiée sont exécutées.
Exemple :
Select Case resultat
Case Is > 0
MessageBox.Show("Res n’est pas multiple de 7")
Case Is < 0
MessageBox.Show("Resultat est pas multiple de 7")
Case Is = 0
MessageBox.Show("Resultat est null")
End Select
II.6. Les structures de répétition

Les structures de répétition permettent d’effectuer une même action plusieurs fois. Elles sont
beaucoup utilisées sur les tableaux et les collections.
II.6.1. Nombre de répétitions connu
a) Boucle For
For compteur [ As datatype ] = start To end [ Step step ]
actions
Next [compteur]
Les actions sont effectuées pour chacune des valeurs prises par la variable compteur.
b) Boucle Foreach
Une autre structure d'itération à nombre d'itérations connu est la suivante :
For Each element [ As datatype ] In groupe
actions
Next [ element ]
groupe est une collection d'objets. La collection d'objets que nous connaissons déjà est
le tableau
datatype est le type des objets de la collection (Pour un tableau, ce serait le type des
éléments du tableau)
element est une variable locale à la boucle qui va prendre successivement pour valeur,
toutes les valeurs de la collection.
II.6.2. Nombre de répétitions inconnu
Il existe de nombreuses structures en VB.NET pour ce cas.
a) Boucle Do While|Until…Loop
Do { While | Until } condition
statements
Loop
On boucle tant que la condition est vérifiée (while) ou jusqu'à ce que la condition soit
vérifiée (until). La boucle peut ne jamais être exécutée.

16
b) Boucle Do…Loop While|Until
Do
[ statements ]
Loop { While | Until } condition
On boucle tant que la condition est vérifiée (while) ou jusqu'à ce que la condition soit
vérifiée (until). La boucle est toujours exécutée au moins une fois.
c) Boucle While
While condition
[ statements ]
End While
On boucle tant que la condition est vérifiée. La boucle peut ne jamais être exécutée.
II.6.3. Instructions de gestion de boucle
Elles permettent de sortir d’une boucle :
exit do fait sortir d'une boucle do ... loop
exit for fait sortir d'une boucle for
II.7. Les tableaux de données

Un tableau VB.NET est un objet permettant de rassembler sous un même identificateur des
données de même type.
II.7.1. Tableau à une dimension
Sa déclaration est la suivante :
Dim Tableau(n) as type ou Dim Tableau() as type=New type(n) {}
où n est la taille du tableau.
La syntaxe Tableau(i) désigne le ième élément du tableau où i appartient à l'intervalle [0,n].
Toute référence à la donnée Tableau(i) où i n'appartient pas à l'intervalle [0,n] provoquera
une exception.
Un tableau peut être initialisé en même temps que déclaré. Dans ce cas, on n'a pas besoin
d'indiquer la taille n.
Exemple : Dim entiers() As Integer = {0, 10, 20, 30} est un tableau de 4 éléments (Taille = 4).
La propriété Length d’un tableau permet d’obtenir le nombre d'éléments de celui-ci.
Exemple :
' Création et Initialisation d’un tableau à 0
Dim Vecteur(5) As Integer
For i As Integer = 0 To Vecteur.Length
Vecteur(i) = 0
Next
II.7.2. Tableau à 2 dimensions
Un tableau à deux dimensions pourra être déclaré comme suit :
Dim Tableau(n,m) as Type ou Dim Tableau(,) as Type=New Type(n,m) {}
où n est le nombre de lignes, m le nombre de colonnes. La syntaxe Tableau(i,j) désigne
l'élément j de la ligne i de Tableau.
Le tableau à deux dimensions peut lui aussi être initialisé en même temps qu'il est déclaré :
Dim réels(,) As Double = {{0.5, 1.7}, {8.4, -6}}
Le nombre d'éléments dans chacune des dimensions peut être obtenue par la méthode
GetLenth(i) où i=0 représente la dimension correspondant au 1er indice, i=1 la dimension
correspondant au 2ième indice, …
Exemple
' Création et initialisation d’un tableau
Dim Matrice(2, 1) As Integer
For i As Integer = 0 To Matrice.GetLength(0) - 1

17
For j As Integer = 0 To Matrice.GetLength(1) - 1
Matrice(i, j) = i * 10 + j
Next
Next
II.7.3. Tableau de tableaux
Un tableau de tableaux est déclaré comme suit :
Dim Tableau(n)() as Type ou Dim Tableau()() as Type=new Type(n)()
La déclaration ci-dessus crée un tableau de n lignes. Chaque élément Tableau(i) est une
référence de tableau à une dimension. Ces tableaux ne sont pas créés lors de la déclaration
ci-dessus.
Exemple :
Dim noms()() As String = New String(3)() {}
' initialisation
For i = 0 To noms.Length - 1
noms(i) = New String(i) {}
For j = 0 To noms(i).Length - 1
noms(i)(j) = "nom" & i & j
Next
Next
II.8. Les collections d’objets

II.8.1. Faiblesses des tableaux
• Redimensionnement : le redimensionnement d’un tableau amène à créer un nouveau
tableau et de copier les éléments en excluant quelques éléments si le nouveau
tableau est plus petit.
• Suppression d’un élément : la suppression d’un élément demande de remonter tous
les éléments d’un cran.
• Insertion d’un élément : L’insertion d’un élément demande de faire descendre tous
les éléments d’un cran pour créer de l’espace
Le .Net fournit plusieurs classes qui collectent également des éléments, mais d’une façon
spécialisée. Ce sont les classes de collection qui sont dans l’espace de noms
System.Collections.
II.8.2. Les classes de collection
Parmi les collections nous pouvons citer :
La classe ArrayList : elle permet de mélanger les éléments d’une collection de
manière dynamique. Elle possède les méthodes Remove (pour supprimer un élément
en réorganisant automatiquement le reste), Add (permet d’ajouter un élément à la fin)
et Insert (ajoute un élément au milieu de la collection).
Exemple :
'Déclaration de la liste
Dim nombres As New ArrayList()
'Initialisation de la liste
For i = 1 To 10
nombres.Add(i)
Next
'Insertion de la valeur 25 à la sixième position de la liste
nombres.Insert(5, 25)
'Supprime l'élément de la liste dont la valeur est 6
nombres.Remove(6)
La classe Queue : elle implémente le mécanisme FIFO (fist-in, fist-out c'est-à-dire
premier entré, premier sorti), un élément est inséré à la fin de la file (méthode

18
Enqueue) et il est supprimé au début de la file (méthode Dequeue).
Exemple :
'Déclaration de la file
Dim nombres As New Queue()
'Initialisation de la file
For i = 1 To 10
nombres.Enqueue(i)
Next
'Supprime le 1er élément de la file
nombres.Dequeue()
La classe Stack : elle implémente le mécanisme LIFO (last-in, fist-out c'est-à-dire
dernier entré, premier sorti), un élément est inséré en haut de la pile (méthode Push)
et quitte le haut de la pile (méthode Pop).
Exemple :
'Déclaration de la pile
Dim nombres As New Stack()
'Initialisation de la pile
For i = 1 To 10
nombres.Push(i)
Next
'Supprime le dernier élément ajouté dans la pile
nombres.Pop()
La classe Hashtable : elle fournit la fonctionnalité de mappage où le type à partir
duquel on mappe n’est pas un integer mais plutôt un autre type (string, double,…),
contrairement aux tableaux et ArrayList où le type de mappage (indice) est toujours
un integer. Cette fonctionnalité est fournie en conservant de façon interne deux
tableaux d’objets, un pour les clés à partir desquelles se fait le mappage et un pour
les valeurs vers lesquelles le mappage est effectué.
Il est à noter que :
- un Hashtable ne peut pas contenir des clés (indice de mappage) dupliquées,
- Lors d’une instruction For Each pour parcourir un Hashtable, c’est un objet de
la classe DictionnaryEntry (classe fournissant l’accès aux éléments clé et
valeur des deux tableaux grâce aux propriétés Key et Value) qui est récupéré.
Un Hashtable est aussi appelé tableau associatif.
Exemple :
'Déclaration du tableau associatif
Dim tailles As New Hashtable()
'Initialisation du tableau associatif
tailles("Jacques") = 1.8
tailles("Justin") = 1.62
tailles.Add("Françoise", 1.65)
'Affichage des éléments
For Each element As DictionaryEntry In tailles
Dim nom As String = element.Key
Dim taille As Double = element.Value
Console.WriteLine(nom + " mesure " + taille + "m")
Next
'Supprime l'élément ayant la clé spécifiée
tailles.Remove("Justin")
La classe SortedList : elle est similaire à la classe Hashtable dans le sens où elle
permet d’associer des clés à des valeurs. La différence est que les clés sont
automatiquement triées.

19
Exemple :
'Déclaration du tableau associatif trié
Dim tailles As New SortedList()
'Initialisation du tableau associatif trié
tailles("Jacques") = 1.8
tailles("Justin") = 1.62
tailles.Add("Aline", 1.5)
'Affichage des éléments
For Each element As DictionaryEntry In tailles
Dim nom As String = element.Key
Dim taille As Double = element.Value
Console.WriteLine(nom + " mesure " + taille + "m")
Next
'Supprime l'élément ayant la clé spécifiée
tailles.Remove("Justin")
II.9. La gestion des exceptions (Try, Catch et Finally)

De nombreuses fonctions VB.NET sont susceptibles de générer des exceptions, c'est
à dire des erreurs. Lorsqu'une fonction est susceptible de générer une exception, le
programmeur devrait la gérer dans le but d'obtenir des programmes plus résistants aux
erreurs : il faut toujours éviter le "plantage" sauvage d'une application.
II.9.1. Clause Try … Catch
La gestion d'une exception se fait selon le schéma suivant :
try
actions susceptibles de générer l'exception
catch e as Exception
traiter l'exception e
end try
instruction suivante
Si les actions ne génèrent pas d'exception, on passe alors à instruction suivante, sinon on
passe dans le corps de la clause catch puis à instruction suivante. Notons les points
suivants:
e est un objet dérivé du type Exception. On peut être plus précis en utilisant des types tels
que IOException, SystemException, etc… : il existe plusieurs types d'exceptions.
En écrivant catch e as Exception, on indique qu'on veut gérer toutes les types d'exceptions.
Si le code de la clause try est susceptible de générer plusieurs types d'exceptions, on peut
vouloir être plus précis en gérant l'exception avec plusieurs clauses catch :
try
Actions susceptibles de générer l'exception
catch e as IOException
catch e as SystemException
end try
II.9.2. Clause Finally
On peut ajouter aux clauses try/catch, une clause finally :
try
Actions susceptibles de générer l'exception

20
finally
code exécuté après try ou catch
end try
Qu'il y ait exception ou pas, le code de la clause finally sera toujours exécuté.
Dans la clause catch, on peut ne pas vouloir utiliser l'objet Exception disponible. Au lieu
d'écrire catch e as Exception, on écrit alors catch.
La classe Exception a une propriété Message qui est un message détaillant l'erreur qui s'est
produite. Ainsi si on veut afficher celui-ci, on écrira :
MessageBox.Show("L'erreur suivante s'est produite : "+e.Message)
end try
La classe Exception a une méthode ToString qui rend une chaîne de caractères indiquant le
type de l'exception ainsi que la valeur de la propriété Message. On pourra ainsi écrire :
catch ex as Exception
MessageBox.Show("L'erreur suivante s'est produite : "+ex.ToString)
end try
II.10. Passage de paramètres à une fonction

Nous nous intéressons ici au mode de passage des paramètres d'une fonction. Considérons
la fonction :
Sub changeInt(ByVal a As Integer)
a = 30
MessageBox.Show(("Paramètre formel a=" & a))
End Sub
Dans la définition de la fonction, a est appelé un paramètre formel. Il n'est là que pour les
besoins de la définition de la fonction changeInt. Il aurait tout aussi bien pu s'appeler b.
Considérons maintenant une utilisation de cette fonction :
Sub Main()
Dim age As Integer = 20
changeInt(age)
MessageBox.Show(("Paramètre effectif age=" & age))
End Sub
Ici dans l'instruction changeInt(age), age est le paramètre effectif qui va transmettre sa
valeur au paramètre formel a. Nous nous intéressons à la façon dont un paramètre formel
récupère la valeur du paramètre effectif qui lui correspond.
II.10.1. Passage par valeur
L'exemple ci-après nous montre que les paramètres d'une fonction/procédure sont par
défaut passés par valeur : c'est à dire que la valeur du paramètre effectif est recopiée dans
le paramètre formel correspondant.
On a deux entités distinctes. Si la fonction modifie le paramètre formel, le paramètre effectif
n'est lui en rien modifié.
' options
Option Explicit On
Option Strict On
' passage de paramètres par valeur à une fonction
Imports System
Module param1

21
Sub Main()
changeInt(age)
End Sub
Sub changeInt(ByVal a As Integer)

a = 30
End Sub
End Module
Les résultats obtenus sont les suivants :
Paramètre formel a=30
Paramètre effectif age=20
La valeur 20 du paramètre effectif a été recopiée dans le paramètre formel a. Celui-ci a été
ensuite modifié. Le paramètre effectif est lui resté inchangé.
Ce mode de passage convient aux paramètres d'entrée d'une fonction.
II.10.2. Passage par référence
Dans un passage par référence, le paramètre effectif et le paramètre formel sont une seule
et même entité. Si la fonction modifie le paramètre formel, le paramètre effectif est lui aussi
modifié.
En VB.NET, le paramètre formel doit être précédé du mot clé ByRef.
Voici un exemple :
' options
Option Explicit On
Option Strict On
' passage de paramètres par valeur à une fonction
Imports System
Module param2
Sub Main()
changeInt(age)
End Sub
Sub changeInt(ByRef a As Integer)
a = 30
End Sub
End Module
et les résultats d'exécution :
Paramètre formel a=30
Paramètre effectif age=30
Le paramètre effectif a suivi la modification du paramètre formel.
Ce mode de passage convient aux paramètres de sortie d'une fonction.
Note : Après ces différentes notions, nous allons maintenant abordés les notions liées
à la programmation orientée objet proprement dit.

22
SECTION II : L’ASPECT ORIENTE OBJET DANS VISUAL BASIC
II.11. Les classes, le constructeur, le destructeur et les propriétés
II.11.1. Les Classes
Un objet est une entité qui contient des données qui définissent son état (on les appelle des
propriétés) et des fonctions (on les appelle des méthodes).
Une classe est un modèle suivant lequel un objet est créé : l’objet est une instance d’une
classe.
Exemple :
Public Class Direction
' Attributs
Private code As String
Private nom As String
....
' Méthode
Public Sub Ajouter(....)
...
End Sub
Public Function Rechercher(...) As DataTable

....
End Function
End Class
A partir de la classe Direction précédente, on peut créer de nombreux objets O1, O2,… Tous
auront les propriétés code et nom et les méthodes Ajouter, Rechercher, … Mais ils auront
des valeurs différentes pour leurs attributs code et nom ayant ainsi chacun un état qui leur
est propre.
II.11.2. Le constructeurs, le destructeur et les objets temporaires
a) Le Constructeur
Un constructeur en VB.Net est une méthode qui porte le nom New et qui est appelée lors de
la création de l'objet. On s'en sert généralement pour l'initialiser. Si une classe a un
constructeur acceptant n arguments argi, la déclaration et l'initialisation d'un objet de cette
classe pourra se faire sous la forme :
dim objet as classe =new classe(arg1,arg2, ... argn)
ou
dim objet as classe
objet=new classe(arg1,arg2, ... argn)
Lorsqu'une classe a un ou plusieurs constructeurs, l'un de ces constructeurs doit être
obligatoirement utilisé pour créer un objet de cette classe.
Si une classe C n'a aucun constructeur, elle en a un par défaut qui est le constructeur sans
paramètres : public New(). Les attributs de l'objet sont alors initialisés avec des valeurs par
défaut.
Exemple :
dim p as Direction
p1 = new Direction()
L’écriture : dim p1 as Direction = nothing indique explicitement (avec le mot clé nothing) que
la variable p1 ne fait référence à aucun objet.

23
Pour que p1 référence un objet, il faut écrire :
dim p1 as Direction=new Direction()
Cela a pour effet de créer un objet de type Direction non encore initialisé : les attributs code
et nom qui sont des références d'objets de type String, auront la valeur nothing. Il y a donc
une initialisation par défaut.
* Le mot clé Me est utilisé pour faire référence à l’objet en cours
Lorsqu'une méthode d'un objet référence un attribut A de cet objet, l'écriture Me.A est
implicite. On doit l'utiliser explicitement lorsqu'il y a conflit d'identificateurs. C'est le cas de
l'instruction :
Public Sub Affecter (ByVal code as String)
Me.code = code
End Sub
où code désigne un attribut de l'objet courant ainsi que le paramètre code reçu par la
méthode. Il faut alors lever l'ambiguïté en désignant l'attribut code par Me.code.
b) Le destructeur
Le destructeur permet de libérer les ressources utilisées par l’objet d’une classe.
Il est implémenté à l’aide des fonctions Dispose et Finalize.
VB.Net gère implicitement la destruction des objets du programme par un programme appelé
"ramassemiettes" dont le rôle est de récupérer l'espace mémoire occupé par des objets qui
ne sont plus référencés par des données du programme.
Néanmoins le programmeur peut aussi utiliser explicitement ces fonctions Dispose et
Finalize.
c) Les objets temporaires
Dans une expression, on peut faire appel explicitement au constructeur d'un objet : celui-ci
est construit, mais nous n'y avons pas accès (pour le modifier par exemple). Cet objet
temporaire est construit pour les besoins d'évaluation de l'expression puis abandonné.
L'espace mémoire qu'il occupait sera automatiquement récupéré ultérieurement par le
"ramassemiettes".
II.11.3. Les Propriétés
Il existe une façon d'avoir accès aux attributs d'une classe c'est de créer des propriétés.
Celles-ci nous permettent de manipuler des attributs privés comme s'ils étaient publics.
Les propriétés sont des méthodes particulières servant à connaître ou fixer la valeur
d'attributs de l'objet.
Public Class Direction
'Attributs
Private _code As String
Private _nom As String
'Propriétés
Public Property Code() As String
Get
Return _code
End Get
Set(ByVal value as String)
_code = value
End Set
End Property
Public Property Nom() As String
Get
Return _nom
End Get
Set(ByVal value As String)

24
_nom = value
End Set
End Property
End Class
II.12. Les méthodes et attributs de classe (Shared)

On appelle attributs (respectivement méthodes) de la classe, tout attribut (respectivement
méthode) qui dépend directement de la classe, c'est-à-dire on n’a pas besoin d’instancier un
objet de la classe pour accéder à cet attribut (respectivement méthode).
Par exemple un compteur du nombre d'objets Direction créées dans une application, on
l’inclura dans la définition de la classe.
Comme c'est un attribut de la classe elle-même et non d'un objet particulier de cette classe,
on le déclare différemment avec le mot clé Shared :
Public Shared _nbDirection As Long = 0
On peut lui créer une propriété publique pour donner accès à l'attribut de classe NbDirection.
Aussi a-t-on besoin d'une propriété déclarée elle-aussi Shared :
Public Shared ReadOnly Property NbDirection() As Long
Get
Return _nbDirection
End Get
End Property
De l'extérieur de la classe, elle sera appelée avec la syntaxe Direction.NbDirection. La
propriété est déclarée en lecture seule (ReadOnly) car elle ne propose pas de méthode set.
II.13. Les objets et les références d’objets

Comme énoncé précédemment, un objet est une instance d’une classe et est créé en
utilisant le mot clé new, dès lors un espace mémoire est alloué à celui-ci.
La référence d’objet quant à lui, est une variable qui contient l’adresse de l’objet en mémoire
(le pointeur).
Objet
Référence
II.14. Passage d’un objet à une fonction

Dans le cas d'un objet, il ne faut pas se laisser tromper par l'abus de langage qui est fait
systématiquement en parlant d'objet au lieu de référence d'objet. Un objet n'est manipulé
que via une référence sur lui.
Ce qui est donc transmis à une fonction, n'est pas l'objet lui-même mais une référence sur
cet objet. C'est donc la valeur de la référence et non la valeur de l'objet lui-même qui est
dupliquée dans le paramètre formel : il n'y a pas construction d'un nouvel objet.
Si une référence d'objet R1 est transmise à une fonction, elle sera recopiée dans le
paramètre formel correspondant R2. Aussi les références R2 et R1 désignent-elles le même
objet. Si la fonction modifie l'objet pointé par R2, elle modifie évidemment celui référencé par
R1 puisque c'est le même.
R1 Objet
R2

25
II.15. Les espaces de nom et les Assembly
II.15.1. Les espaces de nom
Pour écrire une ligne à l'écran dans une application console, nous utilisons l'instruction :
Console.Out.WriteLine(...)
Si nous regardons la définition de la classe Console
Namespace: System
Assembly: Mscorlib (in Mscorlib.dll)
On découvre qu'elle fait partie de l'espace de noms System. Cela signifie que la classe
Console devrait être désignée par System.Console et on devrait en fait écrire :
System.Console.Out.WriteLine(...)
On évite cela en utilisant une clause imports :
imports System
...
Console.Out.WriteLine(...)
On dit que l'espace de noms System est importé à l’aide de la clause imports. Lorsque le
compilateur va rencontrer le nom d'une classe (ici Console) il va chercher à la trouver dans
les différents espaces de noms importés par les clauses imports. Dans notre cas il trouvera
la classe Console dans l'espace de noms System.
Lorsqu'on crée une classe, on peut la créer à l'intérieur d'un espace de noms.
Le but de ces espaces de noms est d'éviter les conflits de noms entre classes lorsque celles-
ci portent le même nom.
Pour créer une classe dans un espace de noms, on écrit :
Namespace nom_espace
Public Class personne
' définition de la classe
...
End class
End namespace
L’importation d’un espace de nom dans un projet se fait comme suit :
- Cliquer sur le menu Projet – Propriété de SGAE…
- Dans la partie inférieure Espaces de noms importés, cocher les espaces de nom

26
souhaités.
II.15.2. Les Assemblages (Assembly)
Notons maintenant la seconde information attachée à la classe Console :
Assembly: Mscorlib (in Mscorlib.dll)
Cette ligne indique dans quelle "assemblage" se trouve la définition de la classe Console.
On peut compiler une classe ou un ensemble de classe dans un fichier particulier appelé un
assemblage (assembly). Ce fichier a une extension .dll et est créé dans le but de réutiliser
une fonctionnalité dans plusieurs programmes.
Chaque classe de ce fichier doit appartenir à un espace de nom.
Visual Basic .Net permet de créer ce type de fichier à l’aide des applications Bibliothèque de
classes (Menu Fichier – Nouveau projet – Bibliothèque de classes).
L’utilisation de ces classes dans un programme se fait en ajoutant le fichier .dll comme
référence (voir II.16.2) et en utilisant son espace de nom.
Voyons à travers un exemple comment crée-t-on un Assemblage (Assembly) dans Visual

basic 2008.
- Menu fichier – Nouveau projet – Bibliothèque de classe ;
- Dans la boîte de dialogue, remplacer ClassLibrary1 par « Login » puis cliquer sur le
bouton OK.
Un projet de type bibliothèque de classe ne peut pas être exécuté, il ne peut être que
compilé afin de créer un fichier ayant l’extension .dll.
Le projet que nous allons implémenter consiste à afficher une fenêtre de connexion (Login)
et de passer à la fenêtre cible (fenêtre passé en argument)
Créons la fenêtre et la classe suivante dans notre projet :
Fenêtre frmLogin

27
Ajouter les codes suivants dans la fenêtre :
Public Class frmLogin
Public connecte As Boolean = False
Private Sub btnAnnuler_Click(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles btnAnnuler.Click
Close()'Fermeture de la fenêtre
End Sub
Private Sub btnValider_Click(ByVal sender As System.Object, ByVal e As

System.EventArgs) Handles btnValider.Click
'Test si le compte n’est pas vide et le mot de passe a au moins 5
caractères
If txbCompte.Text.Trim() <> "" And txbMotDePasse.Text.Trim().Length
>= 5 Then
connecte = True
Close()'Fermeture de la fenêtre
Else
MessageBox.Show("Veuillez saisir le compte et le mot de
passe.")
End If
End Sub
End Class
Ajoutons la classe Login décrit comme suit :

Public Class Login
Sub New(ByVal nomApplication As String, ByVal fenetreCible As
Windows.Forms.Form)
If nomApplication = "" Then nomApplication = "Connexion"
Dim conn As New frmLogin()
conn.lblNomApplication.Text = nomApplication
conn.ShowDialog()'Affichage de la fenêtre Login
If conn.connecte = True Then
fenetreCible.Show()'Affichage de la fenêtre cible
conn.Hide()'Caché la fenêtre Login
Else
Environment.Exit(0) 'Fermeture du programme
End If
End Sub
End Class
Compilons le projet puis parcourons le dossier Login\bin\Debug dans son emplacement,

nous remarquons la présence du fichier nommé Login.dll :
Nous utiliserons ce fichier par la suite.

28
II.16. Les interfaces et les références
II.16.1. Les interfaces
Une interface est un ensemble de prototypes de méthodes ou de propriétés qui forme un
contrat. Une classe qui décide d'implémenter une interface s'engage à fournir une
implémentation de toutes les méthodes définies dans l'interface. C'est le compilateur qui
vérifie cette implémentation.
Exemple (définition de l'interface IStats) :
Public Interface IStats
Function moyenne() As Double
Function ecartType() As Double
End Interface
Toute classe implémentant cette interface sera déclarée comme
Public Class Statistique
Implements Istats
...
Function moyenne() As Double Implements Istats.moyenne
...
End Function
Function ecartType() As Double Implements Istats.écartType
...
End Function
End Class
Les méthodes moyenne et ecartType devront être définies dans la classe Statistique.
II.16.2. Les références
On appelle référence tout fichier additionnel à la solution. La plupart des cas ce sont des
fichiers dll.
L’ajout d’une référence se fait de la manière suivante :
- Cliquer droit sur le projet ;
- Ajouter référence
- Dans la boite de dialogue vous avez la possibilité de sélectionner une référence .Net,
Com, Projets, Parcourir (en chercher le fichier dans un emplacement du disque) ou
parmi les fichiers Récemment utilisés.

29
- Cliquer sur le Bouton OK.
II.17. Les Surcharges de méthodes

Surcharger une méthode revient à définir une ou plusieurs autres méthodes dont
l’identificateur est le même mais ayant des signatures (type d’argument) différentes.
Exemple :
Public Function Rechercher() As DataTable
…
End Function
Public Function Rechercher(ByVal id As Integer) As DataTable
…
End Function
Public Function Rechercher(ByVal id As Integer, ByVal categorie As String) As DataTable
…
End Function
Lors d’un appel de la méthode, le compilateur saura laquelle des ces méthodes appelée en
fonction de la signature.
II.18. L’héritage et le Polymorphisme

II.18.1. L’héritage
Le but de l'héritage est de "personnaliser" une classe existante pour qu'elle satisfasse à nos
besoins. Supposons qu'on veuille créer une classe enseignant : un enseignant est une
personne particulière. Il a des attributs qu'une autre personne n'aura pas : la matière qu'il
enseigne par exemple. Mais il a aussi les attributs de toute personne : prénom, nom et âge.
Un enseignant fait donc pleinement partie de la classe personne mais a des attributs
supplémentaires. Plutôt que d'écrire une classe enseignant à partir de rien, on préfèrerait
reprendre l'acquis de la classe personne qu'on adapterait au caractère particulier des
enseignants. C'est le concept d'héritage qui nous permet cela.
Pour exprimer que la classe enseignant hérite des propriétés de la classe personne, on
écrira :

30
Public Class enseignant
Inherits personne
On notera la syntaxe particulière sur deux lignes. La classe personne est appelée la classe
parent (ou mère) et la classe enseignant la classe dérivée (ou fille). Un objet enseignant a
toutes les qualités d'un objet personne : il a les mêmes attributs et les mêmes méthodes.
Ces attributs et méthodes de la classe parent ne sont pas répétées dans la définition de la
classe fille : on se contente d'indiquer les attributs et méthodes rajoutés par la classe fille.
La classe enseignant rajoute aux méthodes et attributs de la classe personne :
un attribut section qui est le n° de section auquel appartient l'enseignant dans le
corps des enseignants (une section par discipline en gros)
un nouveau constructeur permettant d'initialiser tous les attributs d'un enseignant
La déclaration
Public Class enseignant
Inherits personne
indique que la classe enseignant dérive de la classe personne.
Classe abstraite : on appelle classe abstraite une classe dont on ne peut pas instancier des
objets, mais qui sert de classe de base dans le cas de l’héritage. Elle est déduite lors d’une
factorisation des attributs et méthodes communs à plusieurs classes sans qu’il soit question
de créer ses objets.
Public MustInherit Class Modele
End Class
II.18.2. Le polymorphisme
Considérons une lignée de classes : C0 -> C1 -> C2 -> … ->Cn où Ci -> Cj indique que la
classe Cj est dérivée de la classe Ci. Cela entraîne que la classe Cj a toutes les
caractéristiques de la classe Ci plus d'autres. Soient des objets Oi de type Ci. Il est légal
d'écrire :
Oi=Oj avec j>i
En effet, par héritage, la classe Cj a toutes les caractéristiques de la classe Ci plus d'autres.
Donc un objet Oj de type Cj contient en lui un objet de type Ci. L'opération Oi=Oj fait que Oi
est une référence à l'objet de type Ci contenu dans l'objet Oj.
Le fait qu'une variable Oi de classe Ci puisse en fait référencer non seulement un objet de la
classe Ci mais en fait tout objet dérivé de la classe Ci est appelé polymorphisme : la faculté
pour une variable de référencer différents types d'objets. Prenons un exemple et considérons
la fonction suivante indépendante de toute classe :
Sub affiche(ByVal p As personne)
...
End Sub
On pourra aussi bien écrire
Dim p As personne
...
affiche(p)
que
Dim e As enseignant
...
affiche(e)
Dans ce dernier cas, le paramètre formel de type personne de la fonction affiche va recevoir
une valeur de type enseignant. Comme le type enseignant dérive du type personne, c'est
légal.

31
II.19. La portée des déclarations
Les attributs, propriétés et méthodes peuvent être accompagnés de l'un des trois mots clés
suivants :
Privé : Un champ privé (private) n'est accessible que par les seules méthodes internes de la
classe
Public : Un champ public (public) est accessible par toute fonction définie ou non au sein de
la classe
Protégé : Un champ protégé (protected) n'est accessible que par les seules méthodes
internes de la classe ou d'un objet dérivé (voir le concept d'héritage).
En général, les données d'une classe sont déclarées privées alors que ses méthodes et
propriétés sont déclarées publiques.
Cela signifie que l'utilisateur d'un objet (le programmeur) :
n'aura pas accès directement aux données privées de l'objet ;
pourra faire appel aux méthodes publiques de l'objet et notamment à celles qui
donneront accès à ses données privées.
La syntaxe de déclaration d'une classe est la suivante :
Public class classe
private donnée ou méthode ou propriété privée
public donnée ou méthode ou propriété publique
protected donnée ou méthode ou propriété protégée
End class
L'ordre de déclaration des attributs private, protected et public importe peu.
II.20. Introduction aux génériques

Les classes génériques permettent de définir des collections d’objets fortement typée, elles
sont implémentées dans l’espace de nom System.Collections.Generic.
Les objets de ces classes sont instancié en spécifiant le type des objets de la collection dans
le constructeur.
Nous allons illustrer cela en utilisant la classe List(Of T) qui représente une liste accessibles
par index. Fournit des méthodes de recherche, de tri et de manipulation de listes où T
désigne le type des objets de la collection.
Exemple
Public Class Personne
'Attributs
Private _nom As String
Private _age As Integer
'Propriétés
Public ReadOnly Property Nom() As String
Get
Return _nom
End Get
End Property
Public ReadOnly Property Age() As Integer

Get
Return _age
End Get
End Property
'Constructeur
Sub New(ByVal _nom As String, ByVal _age As Integer)
Me._nom = _nom

32
Me._age = _age
End Sub
'Méthodes
Public Shared Function Rechercher() As List(Of Personne)
'Déclaration de la liste
Dim MaListe As New List(Of Personne)
'Déclaration et Initialisation des objets Personne
Dim personne1 As New Personne("Joel", 23)
Dim personne2 As New Personne("Adriana", 5)
Dim personne3 As New Personne("Elysée", 25)
'Ajout des objets Personne dans la liste
MaListe.Add(personne1)
'Retourne de la liste
Return MaListe
End Function
End Class
N.B : Quelques unes des classes de collection décrit au point II.8.2. Les classes de
collection ont des classes génériques correspondantes dans l’espace de nom
System.Collections.Generic. Il s’agit de : Queue(Of T), Stack(Of T) et SortedList(Of
TKey, TValue).
II.21. Quelques classes couramment utilisées

A titre d’information, nous présentons les classes les plus couramment utilisées dont les
détails sont présentés dans l’aide (MSDN) :
• La classe String : implémente les chaines de caractères
• La classe Math : implémente les fonctions mathématiques
• La classe Array : implémente un tableau.
• Les classes StreamReader et StreamWriter
La classe StreamReader permet de lire le contenu d'un fichier.
La classe StreamWriter permet d'écrire dans fichier.
• Les classes BinaryReader et BinaryWriter
Les classes BinaryReader et BinaryWriter servent à lire et écrire des fichiers
binaires.
• La classe Regex : permet l'utilisation d'expressions régulières. Celles-ci permettent
de tester le format d'une chaîne de caractères.
• Les classes
classes TcpListener et TcpClient
TcpClient : permet la communication d’un client vers un serveur à l’aide du protocole
Tcp
TcpListener : permet à un serveur d’écouter et traiter les requêtes d’un programme
client.

33
III. LA GESTION DES FICHIERS
III.1. La classe File
Le fichier est une structure de stockage de données sur support auxiliaire. Son utilisation est
multiple partant de la persistance des données, la journalisation des opérations dans des
logs. La classe File située dans l’espace de nom System.IO fournit des méthodes statiques
pour manipuler les fichiers et facilite la création d'objets FileStream.
Voici une liste non exhaustive des méthodes statiques de la classe File :
Create(chemin as String ) : Crée ou écrase un fichier dont le chemin d'accès est
spécifié en argument et retourne un FileStream.
CreateText(chemin as String) : Crée ou écrase un fichier texte dont le chemin d'accès
est spécifié en argument et retourne un StreamWriter.
Exists(chemin as String) : Détermine si le fichier dont le chemin est spécifié en
argument existe et retourne un Boolean.
AppendAllText(chemin as String, contenu as String ) : Ouvre un fichier, ajoute le
contenu spécifié en second argument, puis ferme le fichier. Si le fichier n'existe pas, il
est créé.
AppendText(chemin as String) : Crée un StreamWriter qui ajoute du texte codé UTF-
8 à un fichier existant.
Open(chemin as String, mode as FileMode) : Ouvre un FileStream sur le chemin
d'accès spécifié avec un mode d’accès.
OpenText(chemin as String) : Ouvre un fichier texte codé UTF-8 existant pour
l'accéder en lecture et retourne un StreamReader.
Copy(fichierSource as String, fichierDestination as String) : Copie un fichier existant
vers un nouveau fichier.
Delete(chemin as String) : Supprime le fichier spécifié en argument.
Certaines méthodes listées ci haut ont des surcharges qui permettent d’ajouter d’autres
fonctionnalités.
Note : La classe FileInfo possède d’autres attributs et méthodes pour manipuler les fichiers.
III.2. Exemples
III.2.1. Création et mise à jour d’un fichier
Public Sub Ecrire()
'Déclaration
Dim nomFichier As String = "C:/Formation VB2008/MonFichier.txt"
Dim ecriture As IO.StreamWriter
Try
If Not IO.File.Exists(nomFichier) Then
'Création d'un fichier texte
ecriture = IO.File.CreateText(nomFichier)
Else
'Ouverture du fichier pour ajout d'enregistrement
ecriture = IO.File.AppendText(nomFichier)
End If
'Ajout des enregistrements
ecriture.WriteLine("Ceci est le contenu du fichier créé :")
ecriture.WriteLine("- Création ;")
ecriture.WriteLine("- Ajout d'enregistrements ;")
ecriture.WriteLine("- Fermeture.")
Catch ex As Exception
Console.WriteLine(ex.Message)

34
Finally
'Fermeture du fichier
If Not Object.ReferenceEquals(ecriture, Nothing) Then
ecriture.Close()
End Try
End Sub
III.2.2. Lecture du fichier

Public Sub Lire()
'Déclaration
Dim lecteur As IO.StreamReader
Try
If IO.File.Exists(nomFichier) Then
'Ouverture du fichier pour lecture
lecteur = IO.File.OpenText(nomFichier)
'Lecture des enregistrements
Dim contenu As String = lecteur.ReadToEnd()
Console.WriteLine(contenu)
Else
'Fichier n'existe pas
Console.WriteLine("Le fichier spécifié n'existe pas.")
End If
Console.WriteLine(ex.Message)
Finally
'Fermeture du fichier
If Not Object.ReferenceEquals(lecteur, Nothing) Then _
lecteur.Close()
End Try
End Sub
III.2.3. Suppression d’un fichier

Public Sub Supprimer()
'Déclaration
If IO.File.Exists(nomFichier) Then
'Suppression du fichier
IO.File.Delete(nomFichier)
End If
End Sub
.

35
IV. INTRODUCTION AU LANGAGE LINQ (LANGUAGE
INTEGRATED QUERY)
Dans ce chapitre nous allons présenter les notions de base du langage LINQ
(notions tirées de MSDN 2008) qui est une innovation dans Visual Studio 2008 et la
version 3.5 du .NET Framework.
IV.1. Définition
LINQ est un langage intégré de requêtes qui permet de rapprocher le monde des
objets et le monde des données.
Dans Visual Studio, vous pouvez écrire des requêtes LINQ en Visual Basic avec :
• des bases de données SQL Server (LINQ to SQL) ;
• des documents XML (LINQ to XML) ;
• des groupes de données ADO.NET (LINQ to DataSet) ;
• et des collections d'objets (LINQ to Objects)
prenant en charge l’interface IEnumerable ou l'interface IEnumerable<(Of T)>
générique.
Vous pouvez utiliser des requêtes LINQ dans de nouveaux projets ou avec des requêtes
non-LINQ dans des projets existants. La seule spécification est que le projet cible la
version 3.5 du .NET Framework.
IV.2. L’interface IEnumerable et IEnumerable<(Of T)>

• IEnumerable est l'interface que doit hériter toute interface qui énumère des objets
d'une collection. IEnumerable expose une méthode, GetEnumerator qui retourne
l’ensemble des éléments de la collection.
• IEnumerable<(Of T)> est l’interface qui expose l'énumérateur et prend en charge
une itération simple sur une collection générique d'un type spécifié.
IV.3. Structure d’une requête LINQ

Une requête Linq est une expression qui récupère des données d'une source de données.
LINQ (Language-Integrated Query) simplifie les choses en proposant un modèle cohérent
qui permet d'utiliser des données de types de sources et de formats divers.
Dans une requête LINQ, vous travaillez toujours avec des objets. Vous utilisez les mêmes
modèles de codage de base pour interroger et transformer des données dans des
documents XML, des bases de données SQL, des groupes de données et des entités
ADO.NET, des collections .NET Framework et les autres sources ou formats pour lesquels
un fournisseur LINQ est disponible.
Les opérations de requête LINQ incluent trois opérations :
1. Obtenir la source ou les sources de données.
2. Créer la requête.
3. Exécuter la requête.
L'exemple suivant présente les trois parties d'une opération de requête. Un tableau d'entiers
est utilisé comme source de données, à des fins de démonstration. Toutefois, ces concepts
s'appliquent également à d'autres sources de données.
' Source de données
Dim numbers() As Integer = {0, 1, 2, 3, 4, 5, 6}
' Création de la requête
Dim evensQuery = From num In numbers Where num Mod 2 = 0 Select num
' Exécution de la requête

36
For Each number In evensQuery
Console.Write(number & " ")
Next
Résultat : 0 2 4 6
IV.4. Les opérateurs de requête de LINQ

IV.4.1. Tri des données : permet de classer les éléments d'une séquence en fonction d'un
ou de plusieurs attributs.
Syntaxe :
• Order By : Trie les valeurs dans l'ordre croissant
• Order By … Descending : Trie les valeurs dans l'ordre décroissant.
Exemple :
Dim words() As String = {"the", "quick", "brown", "fox", "jumps"}
Dim sortQuery = From word In words Order By word.Length Select word
Dim sb As New System.Text.StringBuilder()
For Each str As String In sortQuery
sb.Append(str & " ")
Next
' Affichage du résultat.
Console.Write(sb.ToString())
Résultat : the fox quick brown jumps

IV.4.2. Opération ensembliste : fait référence aux opérations de requête qui génèrent un
ensemble de résultats basé sur la présence ou l'absence d'éléments équivalents dans des
collections (ou ensembles) identiques ou distinctes.
Syntaxe :
• Distinct : Supprime des valeurs en double d'une collection.
Exemple :
Dim classGrades As New System.Collections.Generic.List(Of _
Integer)(New Integer() {63, 68, 71, 75, 68, 92, 75})
Dim distinctQuery = From grade In classGrades Select grade Distinct
Dim sb As New System.Text.StringBuilder("Le grade distinct sont:")
For Each number As Integer In distinctQuery
sb.Append(number & " ")
Next
' Affichage du résultat
Console.Write(sb.ToString())
Résultat : 63 68 71 75 92
IV.4.3. Filtrage des données : Le filtrage fait référence à l'opération de restriction du jeu
de résultats pour qu'il contienne uniquement les éléments qui satisfont une condition
spécifiée. Cette opération est également connue sous le nom de sélection.
Syntaxe :
• Where : Sélectionne des valeurs basées sur une fonction de prédicat.
Exemple (cfr exemple au point IV.3):
IV.4.4. Opérations de quantificateur : retournent une valeur Boolean qui indique si
certains ou tous les éléments d'une séquence remplissent une condition.
Syntaxe :
• Aggregate … In … Into All(…) : Détermine si tous les éléments d'une séquence remplissent
une condition.
• Aggregate … In … Into Any() : Détermine si certains éléments d'une séquence remplissent

37
une condition.
Exemple
Considérons les deux classes personne et AnimalDomestique suivantes qui hérite de la
classe EtreVivant :
Public Class EtreVivant Public Class Personne
Protected _nom As String Inherits EtreVivant
Protected _age As Integer Private _animal As
Public Property Nom() As String AnimalDomestique()
Get Public Property Animal() As
Return _nom AnimalDomestique()
End Get Get
Set(ByVal value As String) Return _animal
_nom = value End Get
End Set Set(ByVal value As
End Property AnimalDomestique())
Public Property Age() As Integer _animal = value
Get End Set
Return _age End Property
End Get End Class
Set(ByVal value As Integer)
_age = value
End Set Public Class AnimalDomestique
End Property Inherits EtreVivant
End Class End Class
a) Utilisation de All
L'exemple suivant utilise la clause Aggregate et la méthode d'extension All à retourner les personnes
d'une collection ayant tous les animaux domestiques dont l’âge depasse 2 ans.
Dim Chien As New AnimalDomestique With {.Nom = "Milou", .Age = 4}
Dim Chat As New AnimalDomestique With {.Nom = "Chichi", .Age = 1}
Dim Chienne As New AnimalDomestique With {.Nom = "Rali", .Age = 6}
Dim Charly As New Personne With {.Nom = "Charly", .Animal = New

AnimalDomestique() {Chien, Chienne}}
Dim Arlette As New Personne With {.Nom = "Arlette", .Animal = New
AnimalDomestique() {Chat}}
Dim Jules As New Personne With {.Nom = "Jules", .Animal = New
AnimalDomestique() {Chien, Chat}}
' Création d'une liste d'objets Personne qui sera interrogé

Dim gens As New System.Collections.Generic.List(Of Personne)(New
Personne() {Charly, Arlette, Jules})
Dim query = From pers In gens _
Where (Aggregate pt In pers.Animal Into All(pt.Age >
3)) _
Select pers.Nom
For Each name As String In query
sb.Append(name)
Next
Console.WriteLine(sb.ToString())
Résultat : Charly

38
b) Utilisation de Any
L'exemple suivant utilise la clause Aggregate et la méthode d'extension Any à retourner les personnes
d'une collection ayant au moins un animal domestique qui a dépassé l’âge de 3 ans. L'exemple
suivant utilise la clause Aggregate et la méthode d'extension Any à retourner les personnes d'une
collection ayant au moins un animal domestique qui a dépassé l’âge de 3 ans. L'exemple suivant
utilise la clause Aggregate et la méthode d'extension Any à retourner les personnes d'une collection
ayant au moins un animal domestique qui a dépassé l’âge de 3 ans.
Dim Charly As New Personne With {.Nom = "Charly", .Animal = New

AnimalDomestique() {Chien, Chienne}}
Dim Arlette As New Personne With {.Nom = "Arlette", .Animal = New
AnimalDomestique() {Chat}}
Dim Jules As New Personne With {.Nom = "Jules", .Animal = New
AnimalDomestique() {Chien, Chat}}
'Création de la liste d'objets Personne qui sera interrogée

Dim people As New System.Collections.Generic.List(Of Personne)(New
Personne() {Charly, Arlette, Jules})
Dim query = From pers In people _
Where (Aggregate pt In pers.Animal Into Any(pt.Age >
3)) _
Select pers.Nom

For Each name As String In query
sb.Append(name & " ")
Next
' Affichage des résultats.
Résultat : Charly Jules

IV.4.5. Opérations de projection : désigne l'opération de transformation d'un objet en une
nouvelle forme qui se compose souvent uniquement des propriétés qui seront utilisées ensuite.
Syntaxe :
• Select : Projettent des valeurs qui sont basées sur une fonction de transformation.
• Select Many : Projettent des séquences de valeurs qui sont basées sur une fonction de
transformation, puis les aplatit en une séquence unique. Elle s’implémente en utilisant
plusieurs clauses From.
Exemple
L'exemple suivant utilise plusieurs clauses From pour projeter chaque mot à partir de chaque chaîne
dans une liste de chaînes.
Dim phrases As New List(Of String)(New String() {"Un exemple", "La
programmation en VB"})
Dim query = From phrase In phrases _
From word In phrase.Split(" "c) _
Select word
For Each str As String In query
Next

39
' Display the output.
Résultat :
Un
Exemple
La
programmation
en
VB
IV.4.6. Partitionnement des données : fait référence à la division d'une séquence d'entrée
en deux sections, sans réorganiser les éléments, puis au retour de l'une des sections.
Syntaxe :
• Skip : Ignore les éléments jusqu'à une position spécifiée dans une séquence.
• Skip While : Ignore les éléments basés sur une fonction de prédicat jusqu'à ce qu'un élément
ne satisfasse pas la condition.
• Take : Prend les éléments jusqu'à une position spécifiée dans une séquence.
• Take While : Prend les éléments basés sur une fonction de prédicat jusqu'à ce qu'un élément
ne satisfasse pas la condition.
Exemple
REM Utilisation de SKIP
Dim words() As String = New String() {"La", "programmation", "en",
"VB", "2008"}
Dim query = From word In words Skip 3
For Each str As String In query
Next
' Display the results.
REM Utilisation de TAKE WHILE

Dim query2 = From word In words _
Take While word.Length < 6
Dim sb2 As New System.Text.StringBuilder()
For Each str As String In query2
sb2.Append(str & " ")
Next
' Display the results.
Console.WriteLine(sb2.ToString())
Résultat Skip : VB 2008
Résultat Take While : La
IV.4.7. Opérations de jointure : Une jointure de deux sources de données est l'association
d'objets dans une source de données avec des objets qui partagent un attribut commun dans une
autre source de données.
Syntaxe :
• Join : Joint deux séquences selon les fonctions de sélection de clé et extrait des paires de
valeurs
• Group Join : Joint deux séquences selon les fonctions de sélection de clé et regroupe les
résultats correspondants pour chaque élément.
Exemple
Considérant les classes Personne et AnimalDomestique définit comme suit :
Public Class EtreVivant Public Class Personne
Protected _nom As String Inherits EtreVivant

40
Protected _age As Integer Private _animal As
Public Property Nom() As String AnimalDomestique
Get Public Property Animal() As
Return _nom AnimalDomestique
End Get Get
Set(ByVal value As String) Return _animal
_nom = value End Get
End Set Set(ByVal value As
End Property AnimalDomestique)
Public Property Age() As Integer _animal = value
Get End Set
Return _age End Property
End Get End Class
Set(ByVal value As Integer)
_age = value Public Class AnimalDomestique
End Set Inherits EtreVivant
End Property End Class
End Class
a) JOIN :
'Déclaration
Dim Charly As New Personne With {.Nom = "Charly", .Animal = Chien}

Dim Arlette As New Personne With {.Nom = "Arlette", .Animal =
Chien}
Dim Jules As New Personne With {.Nom = "Jules", .Animal = Chat}
'Création de la liste d'objets Personne et AnimalDomestique
Dim listePersonne As New System.Collections.Generic.List(Of
Personne)(New Personne() {Charly, Arlette, Jules})
Dim listeAnimaux As New System.Collections.Generic.List(Of
AnimalDomestique)(New AnimalDomestique() {Chien, Chat, Chienne})
' Jointure
Dim prorpietaireAnimal = From pers In listePersonne _
Join animal In listeAnimaux _
On pers.Animal Equals animal _
Select pers.Nom, NomAnimal = animal.Nom
Dim output As New System.Text.StringBuilder
' Affichage de résultats.
output = New System.Text.StringBuilder()
For Each pers In prorpietaireAnimal
output.AppendLine(pers.Nom & ": " & pers.NomAnimal & vbCrLf)
Next
Console.WriteLine(output)
Résultat :
Charly : Milou
Arlette : Milou
Jules : Rali
b) GROUP JOIN :
'Déclaration

41
Dim Charly As New Personne With {.Nom = "Charly", .Animal = Chien}
Dim Arlette As New Personne With {.Nom = "Arlette", .Animal =
Chien}
Dim Jules As New Personne With {.Nom = "Jules", .Animal = Chat}
'Création de la liste d'objets Personne et AnimalDomestique
Dim listePersonne As New System.Collections.Generic.List(Of
Personne)(New Personne() {Charly, Arlette, Jules})
Dim listeAnimaux As New System.Collections.Generic.List(Of
AnimalDomestique)(New AnimalDomestique() {Chien, Chat, Chienne})
' Jointure groupée
Dim appartenanceAnimal = From animal In listeAnimaux _
Group Join pers In listePersonne _
On pers.Animal Equals animal _
Into listePers = Group _
Select animal.Nom, animal.Age, _
listePers
Dim output As New System.Text.StringBuilder
For Each anim In appartenanceAnimal
output.AppendFormat(anim.Nom & " :" & vbCrLf)
For Each pers In anim.listePers
output.AppendFormat(vbTab & pers.Nom & vbCrLf)
Next
Next
Console.WriteLine(output)
Résultat :
Milou :
Charly
Arlette
Chichi
Jules
IV.4.8. Regroupement de données : consiste à placer des données dans des groupes afin
que les éléments de chaque groupe partagent un attribut commun.
Syntaxe :
• Group … By … Into … : Regroupe les éléments qui partagent un attribut commun. Chaque
groupe est représenté par un objet IGrouping<(Of <(TKey, TElement>)>).
Exemple
Dim nombres As New System.Collections.Generic.List(Of Integer) _
(New Integer() {35, 44, 200, 84, 3987, 4, 199, 329, 446, 208})
Dim query = From nombre In nombres _
Group By reste = (nombre Mod 2) Into Group
For Each group In query
sb.AppendLine(If(group.reste = 0, vbCrLf & "Nombres pairs :",
vbCrLf & "Nombres impairs :"))
For Each num In group.Group
sb.Append(num & " ")
Next
Next
Résultat :
' Nombres impairs : 35 3987 199 329
Nombres pairs : 44 200 84 4 446 208

42
IV.4.12. Conversion de types de données : modifient le type d'objets en entrée.
Les opérations de conversion dans les requêtes LINQ sont utiles dans diverses applications.
Par exemple :
• La méthode Enumerable..:.AsEnumerable<(Of <(TSource>)>) peut être utilisée pour masquer
l'implémentation personnalisée d'un type d'un opérateur de requête standard.
• La méthode Enumerable..::.OfType<(Of <(TResult>)>) peut être utilisée pour activer des
collections non paramétrées pour l'interrogation LINQ.
• Les méthodes Enumerable..::.ToArray<(Of <(TSource>)>), Enumerable..::.ToDictionary,
Enumerable..::.ToList<(Of <(TSource>)>) et Enumerable..::.ToLookup peuvent être utilisées
pour forcer l'exécution immédiate de la requête au lieu de la différer jusqu'à ce que la requête
soit énumérée.
Syntaxe :
• From … As … : Effectue un transtypage (cast) des éléments d'une collection en un type
spécifié.
Exemple
En considérant les classes AnimalDomestique et EtreVivant vu au point V.4.4.
Public Shared Sub Cast()
Dim etreVivants() As EtreVivant = { _
New AnimalDomestique With {.Nom = "Milou", .Age = 4, .Type =
"Chien"}, _
New AnimalDomestique With {.Nom = "Chichi", .Type = "Chat"}, _
New AnimalDomestique With {.Nom = "Raly", .Type = "Chien"}}
Dim query = From etre As AnimalDomestique In etreVivants _
Where etre.Type = "Chien" _
Select etre
For Each etre In query
sb.AppendLine(etre.Nom & " ")
Next
End Sub
Résultat : Milou Raly
IV.4.13. Opérations d'agrégation : calcule une valeur unique à partir d'une collection de
valeurs. Le calcul de la température quotidienne moyenne à partir des valeurs de température
quotidiennes d'un mois est un exemple d'opération d'agrégation.
Syntaxe générale : Aggregate … In … Into fonction()
Où fonction peut être :
• Average : Calcule la valeur moyenne d'une collection de valeurs.
• Count : Compte les éléments d'une collection, éventuellement uniquement les éléments qui
satisfont une fonction de prédicat.
• LongCount : Compte les éléments d'une grande collection, éventuellement uniquement les
éléments qui satisfont une fonction de prédicat.
• Max : Détermine la valeur maximale dans une collection.
• Min : Détermine la valeur minimale dans une collection.
• Sum : Calcule la somme des valeurs dans une collection.
Exemple
' Calcul de la moyenne
Dim temperatures() As Double = {72.0, 81.5, 69.3, 88.6, 80.0, 68.5}
Dim avg = Aggregate temp In temperatures Into Average()
Console.WriteLine(avg)
Résultat : 76,65

43
V. GESTION DES APPLICATIONS WINDOWS
V.1. Création d’une application Windows
Visual studio en général gère son contenu dans un ensemble des fichiers appelé
« Solution » qui peut contenir un ou plusieurs « projets ».
V.1.1. Nouveau projet
Voici de quelle manière un nouveau projet est créé en Visual Basic :
Cliquer sur le menu Fichier – Nouveau projet ;
Dans la boite de dialogue, sélectionner Visual Basic – Application Windows et
saisissez le nom du projet « SGAE »;
Note : Cette boite de dialogue peut s’afficher différemment selon la distribution de Visual
Studio.
Cliquer sur le bouton OK.
V.1.2. Construction d’une fenêtre simple
Construisons la fenêtre présentée au point 6 de l’exemple ci-avant.
Les contrôles utilisés sont : le Form, le panel, 3 Label, 2 TextBox, 2 Button et un PictureBox.
Tableau des propriétés des contrôles de la fenêtre
Contrôle Propriété Valeur de la propriété
Form1 Name frmConnexion
Text Connexion
MaximizeBox False
MinimizeBox False
StartPosition CenterScreen
Panel1 Name pnlTitre
BackColor White

44
Dock Top
Label1 Name lblTitre
Text Système de gestion des affectations des
employés SGAE
Font, Bold True
Font, Size 12
TextAlign TopCenter
Label2 Name lblCompte
Text Compte :
Label3 Name lblMotDePasse
Text Mot de passe :
TextBox1 Name txbCompte
TextBox2 Name txbMotDePasse
PasswordChar *
Button1 Name btnValider
text Valider
Button2 Name btnAnnuler
Text Annuler
PictureBox1 Name pcbIcone
Image Users.ico (à rechercher sur l’emplacement du
disque)
SizeMode AutoSize
Définissons maintenant le bouton par défaut de la fenêtre (Formulaire) en modifiant la

propriété AcceptButton de la fenêtre frmConnexion avec la valeur G sélectionnée.
V.2. Les propriétés les plus courantes de contrôle

Name : c’est le nom du contrôle (objet), il est utilisé par le programmeur lors de
l’écriture des codes sources.
Text : c’est le texte qui s’affiche sur le contrôle.
Dock : définit les bordures du contrôle par rapport à son conteneur.
PasswordChar : spécifie le caractère utilisé pour masquer un mot de passe dans une
zone de saisie.
TextAlign : détermine la position du texte dans le contrôle.
Font : définit la police du texte.
BackColor : définit la couleur de fond du contrôle.
ForeColor : définit la couleur de texte.
Enable : indique si le contrôle est visible ou pas.
Visible : indique si la taille du contrôle s »ajuste à son contenu.
AutoSize : indique si la taille du contrôle s’ajuste à son contenu.
Location : indique les coordonnées d coin gauche du contrôle par rapport au
conteneur.
Size : indique la taille du contrôle (Largeur ; Hauteur)
WindowState : détermine l’état visuel initial d’une fenêtre.
ShowIcon : indique si une icône doit être affichée sur la barre de titre de la fenêtre.
ShowInTaskbar : indique si le formulaire doit s’afficher dans la barre de tâche
Windows.
StartPosition : détermine la position d’un formulaire lorsqu’il s’affiche la première fois.

45
AcceptButton : définit le bouton par défaut de la fenêtre (bouton enclenché lorsque
l’utilisateur tape la touche Enter).
V.3. Définition du formulaire de démarrage

Tout projet en Visual Basic doit avoir un formulaire de démarrage, c'est-à-dire le formulaire
qui s’affichera dès qu’on lance le projet.
Elle se fait de la manière suivante :
Menu Projet – Propriété de « nom_du_projet »
Dans la fenêtre qui s’affiche dans la zone travail, la liste déroulante « Formulaire de
démarrage : » contient tous les formulaires du projet, il suffit d’en choisir un.
V.4. Gestion des événements

Visual basic permet au programmeur de définir le comportement du logiciel (en cours de
développement) suite aux actions enclenchées par l’utilisateur, cela est possible grâce à la
gestion des événements.
Un événement est un signal que l’utilisateur envoie au système, par exemple un Click, un
double click,…
Le programmeur attache une suite de codes à un événement bien défini.

46
Exemple :
Private Sub btnAnnuler_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles btnAnnuler.Click
MessageBox.Show("Evénement en Visual Basic 2008", Application.ProductName)
End Sub
Ce code signifie affiche le message « Evénement en Visual Basic 2008 » s’affiche si
l’utilisateur clique sur le bouton Annuler.
Chaque objet à une liste des événements que le programmeur peut utiliser selon le besoin.
V.5. La fenêtre Multiple Document Interface (MDI)

Une fenêtre MDI est une fenêtre (fenêtre mère) pouvant contenir d’autres fenêtres (Fenêtre
filles). Plusieurs applications Windows (par exemple Excel) utilisent les fenêtres MDI.
V.5.1. Ajout d’une fenêtre MDI ;
L’ajout d’une fenêtre MDI se fait comme l’ajout d’une fenêtre ordinaire sauf que il faut
sélectionner Formulaire parent MDI dans la boite de dialogue « Ajouter un nouvel élément ».
Un formulaire parent est alors ajouté dans le projet, il comporte une barre de Menu, une
barre d’outils et une barre d’état. En plus, un ensemble de méthodes prédéfinies est intégré
dans le formulaire.
Le programmeur peut alors la personnaliser à sa guise.

Une fenêtre est rendue fille de la fenêtre MDI si sa propriété MdiParent égale au MDI.
V.5.2. Passage d’un formulaire à un autre
Le passage d’un formulaire à un autre dans un programme en VB.Net se fait en créant la
seconde fenêtre dans une procédure de la première fenêtre, puis appeler la méthode
Show().
Exemple : Passage de la fenêtre de connexion vers la fenêtre principale.
Private Sub btnValider_Click(ByVal sender As System.Object, ByVal e As System.EventArgs)
Handles btnValider.Click

47
Dim _principale As frmPrincipale
_principale = New frmPrincipale()
_principale.Show() 'Affiche la fenêtre principale
Me.Hide() 'Cache la fenêtre en cours
End Sub
V.6. La barre de Menu, la barre d’outils, le Menu contextuel et les boites

de dialogues
Une application windows peut avoir une seule fenêtre principale ou un
ensemble de fenêtre avec lequel la navigation est possible d’une fenêtre à
une autre. Dans ce dernier cas, l’une des fenêtres est dédiée au rôle de
fenêtre principale.
Cette fenêtre prncipale est généralement muni d’une barre de Menu et/ou une barre
d’outils comme la plupart des applications standard de Windows.
Barre de menus
Barre d’outils
Le menu contextuel peut aussi être utilisé sur des contrôles de données tels
que DataGridView ou ListView afin d’effectuer des opérations liées sur les
données de ce contrôle.
Les boîtes de dialogue quant à elles sont beaucoup plus utilsées dans
l’opération d’ouverture et de sauvegarde des fichiers.
Les boites de dialogues les plus utilisées sont : OpenFileDialog et SaveFileDialog
NOTE : Les différents aspect sur la gestion des applications windows seront vus par la
pratique à l’aide des exercices et particulièrement le projet SGAE qui sera utilisé
dans le chapitres suivants.

48
VI. MANIPULATION DE BASE DE DONNÉES ET GÉNÉRATION
DE RAPPORTS
SECTION I : LA MANIPULATION DES BASES DE DONNEES
VI.1. Généralités
Pour accéder à une base de données, les applications passent au travers de programmes
appelés pilotes (drivers).
Dans le schéma ci-dessus, le pilote présente deux interfaces :

l'interface I1 présentée à l'application ;
l'interface I2 vers la base de données.
Afin d'éviter qu'une application écrite pour une base de données B1 doive être ré-écrite si on
migre vers une base de données B2 différente, un effort de normalisation a été fait sur
l'interface I1. Si on utilise des bases de données utilisant des pilotes "normalisés", la base B1
sera fournie avec un pilote P1, la base B2 avec un pilote P2, et l'interface I1 de ces deux
pilotes sera identique. Aussi n'aura-t-on pas à ré-écrire l'application.
Il existe deux types de pilotes normalisés :
les pilotes ODBC (Open DataBase Connectivity);
Les pilotes OLE DB (Object Linking and Embedding DataBase).
Les pilotes ODBC permettent l'accès à des bases de données.
Les sources de données pour les pilotes OLE DB sont plus variées : bases de données,
messageries, annuaires, ... Il n'y a pas de limite.
Toute source de données peut faire l'objet d'un pilote Ole DB si un éditeur le décide.
L'intérêt est évidemment grand : on a un accès uniforme à une grande variété de données.
La plate-forme .NET est livrée avec deux types de classes d'accès aux données :
les classes SQL Server.NET
les classes Ole Db.NET
Les premières classes permettent un accès direct au SGBD SQL Server de Microsoft sans
pilote intermédiaire tandis que les secondes permettent l'accès aux sources de données
OLE DB.

49
VI.2. Les modes d'exploitation d'une source de données
La plate-forme .NET permet l'exploitation d'une source de données de deux manières
différentes :
mode connecté
mode déconnecté
a) Mode connecté
En mode connecté, l'application
1. ouvre une connexion avec la source de données ;
2. travaille avec la source de données en lecture/écriture ;
3. ferme la connexion.
b) Mode déconnecté
En mode déconnecté, l'application
1. ouvre une connexion avec la source de données
2. obtient une copie mémoire de tout ou partie des données de la source ;
3. ferme la connexion ;
4. travaille avec la copie mémoire des données en lecture/écriture ;
5. lorsque le travail est fini, ouvre une connexion, envoie les données modifiées à la
source de données pour qu'elle les prenne en compte, ferme la connexion.
Dans les deux cas, c'est l'opération d'exploitation et de mise à jour des données qui prend du
temps
Quels sont les avantages et inconvénients des deux méthodes ?
Une connexion est coûteuse en ressources système. S'il y a beaucoup de
connexions simultanées, le mode déconnecté permet de réduire leurs durées à un
minimum. C'est le cas des applications web ayant des milliers d'utilisateurs.
L'inconvénient du mode déconnecté est la gestion délicate des mises à jour
simultanées. L'utilisateur U1 obtient des données au temps T1 et commence à les
modifier. Au temps T2, l'utilisateur U2 accède lui aussi à la source de données et
obtient les mêmes données. Entre-temps l'utilisateur U1 a modifié certaines données
mais ne les a pas encore transmises à la source de données. U2 travaille donc avec
des données dont certaines sont erronées.
Les classes .NET offrent des solutions pour gérer ce problème mais il n'est pas
simple à résoudre.
En mode connecté, la mise à jour simultanée de données par plusieurs utilisateurs ne
pose normalement pas de problème. La connexion avec la base de données étant
maintenue, c'est la base de données elle-même qui gère ces mises à jour
simultanées. Tant que un enregistrement est en cours de modification, il restera
verrouillée donc inaccessible aux autres utilisateurs jusqu'à ce que celui qui l'a
modifiée valide (Commit) sa modification ou l'abandonne (Rollback).
Si les données doivent circuler sur le réseau, le mode déconnecté est à choisir. Il
permet d'avoir une photo des données dans un objet appelé DataSet qui représente
une base de données à lui tout seul.
Un DataSet est composé de DataTable qui représente une structure de table en
mémoire centrale.
Dans le cadre de cette formation, nous utiliserons le mode connecté en utilisant le pilote Ole
DB.
VI.3. Structuration du logiciel en couche

Il est conseillé d’organiser les classes qui interagissent avec la base de données dans une
couche appelé « Persistance » ou « Data Access Objet (DAO) ». Le but étant de tirer profit

50
de la structuration d’une application en couche.
L’explorateur de solution du SGAE devient :
VI.4. Notion de base de données (SGBD PostgreSql)

VI.4.1. Administration de base de données
1. Gestion des utilisateurs et groupes
2. Création des bases de données et des tables
3. Les vues, les fonctions et les déclencheurs
VI.4.2. Le langage SQL (Standard Query Language)

La manipulation de données de la base de données est effectuée à l’aide de requête SQL
(Standard Query Language). L’utilisation du langage SQL est du domaine de l’administration
de base de données, néanmoins nous allons voir les clauses essentielles de ce langage.
Considérons le schéma de la base de données suivant (sgae_db) :
- SELECT : permet d’extraire les données provenant d’une table ou de plusieurs tables
(Jointure).
Exemple :
a) Extraction du code et nom de toutes les directions :
SELECT code, nom FROM direction
b) Extraction du nom de la direction ainsi que le code et le nom du département
correspondant :

51
SELECT dir.nom as direction, dep.code, dep.nom FROM direction dir JOIN
department dep ON dir.direction_id=dep. direction_id
- Insert : permet d’ajouter un enregistrement dans une table
Exemple : Insertion de la direction « DRH » dans la table direction
INSERT INTO direction(code,nom) VALUES(‘D10’, ‘DRH’)
- Update : permet de modifier un ou plusieurs enregistrements d’une table.
Exemple :
a) Modifie le nom de la direction ayant le code égal à D10
UPDATE direction SET nom =’Ressources humaines’ WHERE code=‘D10’
b) Modifie le nom et le code de la direction ayant direction_id égal à 10
UPDATE direction SET nom =’Ressources humaines’, code =’D12’ WHERE
direction_id=10
- DELETE : permet de supprimer un ou plusieurs enregistrements d’une table.
Exemple :
a) Suppression de la direction ayant direction_id égal à 10
DELETE FROM direction where direction_id = 10
b) Suppression de tous les enregistrements de la table direction
DELETE FROM direction
VI.5. Connexion à une base de données

La connexion à un serveur de base de données via un programme demande de bâtir la
chaine de connexion qui doit comprendre les éléments ci-après :
Le nom du fournisseur ;
L’adresse réseau (Adresse IP) du serveur de base de données ;
le port du serveur de base de données ;
nom de la base de données ;
l’utilisateur et le mot de passe.
Etant données que nous allons utiliser PostgreSql comme serveur de base de données,
ajoutons les assemblages Npgsql et MonoSecurity comme ressources dans le projet SGAE.
Ajoutons ensuite les références de ces deux assemblages dans le projet SGAE et importons
les espaces de noms Npgsql et NpgsqlTypes
Créons la classe UtilisateurDao, dans laquelle nous implémentons la méthode Connecter :
Public Class UtilisateurDao
Private _chaineDeConnexion As String
'Propriétés
Property chaineDeConnexion() As String
Get
Return _chaineDeConnexion
End Get
Set(ByVal value As String)
_chaineDeConnexion = value
End Set
End Property
Public Function Connecter(ByVal _utilisateur As Utilisateur) As Boolean
If _chaineDeConnexion = "" Then
Throw New Exception("La chaine de connesxion est vide.")
Else
Dim connexion As NpgsqlConnection = New NpgsqlConnection(_chaineDeConnexion)
Try
connexion.Open()
If connexion.State = ConnectionState.Open Then

52
Return True
Else
Return False
End If
Throw ex
Finally
connexion.Close()
connexion.Dispose()
End Try
End If
End Function
End Class
Remarquer que la classe UtilisateurDao utilise les classes de l’espace de nom Npgsql, ce
qui justifie l’importation de cet espace de nom dans le projet.
La méthode Connecter de cette classe vérifie si le moteur de la base de données accepte
l’authentification de l’utilisateur spécifié.
VI.6. Extraction des données dans la base de données

Créons dans le même projet SGAE la classe AccesBaseDeDonnees dans laquelle nous
ajoutons la méthode Extraire et ExtraireCommande.
Public Function Extraire(ByVal requete As String) As DataTable
Dim connexion As New NpgsqlConnection(_chaineDeConnexion)
Dim adaptateur As New NpgsqlDataAdapter(requete, connexion)
Dim dt As New DataTable()
Try
connexion.Open()
adaptateur.Fill(dt)
Return dt
Finally
connexion.Close()
connexion.Dispose()
End Try
End Function
Public Shared Function ExtraireCommande(ByRef commande As NpgsqlCommand) As DataTable
Dim adaptateur As New NpgsqlDataAdapter(commande)
Dim dt As New DataTable()
commande.Connection = connexion
Try
connexion.Open()
adaptateur.Fill(dt)
Return dt
Finally
connexion.Close()
commande.Dispose()
connexion.Dispose()
End Try
End Function
VI.6. Mise à jour de la base de données

Dans le même projet SGAE ajoutons la méthode Executer() et ExecuterCommande avec
une surcharge.

53
Public Shared Function Executer(ByVal requete As String) As Integer
Dim resultat As Integer
Dim commande As New NpgsqlCommand(requete, connexion)
Try
connexion.Open()
resultat = commande.ExecuteNonQuery()
Return resultat
Finally
connexion.Close()
commande.Dispose()
connexion.Dispose()
End Try
End Function
Public Shared Function ExecuterCommande(ByRef commande As NpgsqlCommand) As Integer
Dim resultat As Integer
Try
connexion.Open()
resultat = commande.ExecuteNonQuery()
Return resultat
Finally
connexion.Close()
commande.Dispose()
connexion.Dispose()
End Try
End Function
Compilons le projet puis ajoutant le fichier dll généré dans les références du projet SGAE.
VI.7. Notions de transaction

Dans une base de données, il est assez courant de se retrouver dans un cas où les
opérations à effectuer doivent se faire de manière atomique, c'est-à-dire si une partie échoue
toute l’opération échoue. L’exemple le plus simple est le cas d’un transfert d’argent d’un
compte A vers un compte B, si l’argent est débiter dans le compte B et qu’un problème
provoque l’échec lorsque le même montant est créditer dans le compte A, il faudra annuler
(Rollback) l’opération qui a débiter le compte B. Si tout s’est bien passé alors on valide
l’opération toute entière (Commit).
Exemple :
Imports Npgsql
Imports NpgsqlTypes
Public Class AdresseDao
Public Shared Sub AjouterCommunesVille(ByVal nomVille As String, ByVal nomsCommunes() As
String)
Dim connexion As NpgsqlConnection = New
NpgsqlConnection(AccesBaseDeDonnees.chaineDeConnexion)
Dim commande As NpgsqlCommand = New NpgsqlCommand()
Dim transaction As NpgsqlTransaction
Dim requete As String
transaction = connexion.BeginTransaction(IsolationLevel.ReadCommitted)
Try
connexion.Open() 'Ouverture de la connexion

54
commande.Transaction = transaction
'Insertion de la ville
requete = "insert into ville(nom) values (@nom)"
commande.CommandText = requete
commande.Parameters.Clear()
commande.Parameters.Add("@nom", NpgsqlDbType.Varchar, 64).Value = nomVille
If commande.ExecuteNonQuery() = -1 Then
transaction.Rollback()
Throw New Exception("Echec de l'insertion de la ville.")
End If
'Insertion des communes de la ville
For i As Integer = 0 To nomsCommunes.Length
requete = "insert into commune(nom,ville_id) values (@nom,currval('ville_ville_id_seq'))"
commande.CommandText = requete
commande.Parameters.Clear()
commande.Parameters.Add("@nom", NpgsqlDbType.Varchar, 64).Value =
nomsCommunes(i)
If commande.ExecuteNonQuery() = -1 Then
Throw New Exception("Echec d'insertion d'une commune.")
End If
Next i
'Validation de l'opération
transaction.Commit()
Throw ex
Finally
connexion.Close()
commande.Dispose()
connexion.Dispose()
End Try
End Sub
End Class
L’exemple illustre une transaction qui ajoute une ville et les communes qui la composent.
VI.8. Utilisation d’un fichier de configuration

Un fichier de configuration sert à contenir les valeurs permettant de rendre un logiciel
paramétrable. Le choix de paramètres à placer dans un fichier de configuration est fait en
fonction de leur changement, par exemple l’adresse IP d’un serveur de base de données, le
port du serveur de base de données, le nom de la base de données, …
Visual basic 2008 utilise un fichier XML (eXtensible Modeling Language) comme fichier de
configuration, il est ajouter en sélectionnant « Fichier de configuration de l’application »
dans la boite de dialogue Ajouter un nouvel élément. Le nom par
défaut du fichier est app.config et il contient à sa création le nœud system.diagnostics.
Vous pouvez ajouter les nœuds appSettings qui contiendra des sous nœud qui seront utiliser
par le projet.
Par exemple :
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
...
<appSettings >
<add key ="adresseServeur" value ="127.0.0.1"/>

55
<add key ="nomBaseDeDonnees" value ="sgae_db"/>
...
</appSettings>
</configuration>
La classe ConfigurationManager possède la propriété AppSettings() permettant d’accéder à
la valeur d’un nœud (value) à partir de sa clé (key). Pour utiliser cette classe, il faut ajouter la
référence System.Configuration et importer l’espace de nom System.Configuration.
Par exemple :
‘'Lecture de l'adresse du serveur
Dim ipServeur As String = ConfigurationManager.AppSettings("adresseServeur")
SECTION II : LA GENERATION DES RAPPORTS (REPORTING)

VI.9. Création des rapports avec Crystal Report
Un rapport en Crystal Report nécessite une source de données afin de l’utiliser comme
modèle de données pour ensuite concevoir la présentation du rapport.
Ainsi la création d’un rapport peut se faire en deux étapes :
définition de la source de donnés ;
Création du rapport proprement dit
a) Création de la source de données
Un schéma XML peut être utilisé comme source de données d’un rapport dans Crystal
report, les nœuds constitueront les champs de la source de données.
Voici les étapes de création d’un schéma XML :
Ajout d’un schéma XML
Un schéma XML possède une boîte à outils qui se présente comme suit :

56
Ajout des champs dans le schéma XML (exemple listeDepartement)
L’ajout des champs se fait premièrement en posant un Elément (exemple
listeDepartement) dans lequel chaque champ est associé à un type de données.
b) Ajout du rapport dans un projet

L’ajout d’un rapport dans un projet se fait en sélectionnant Rapport Crystal dans la boite
de dialogue « Ajouter un nouvel élément ».
Une suite d’étapes est à franchir avant d’avoir la fenêtre de conception du rapport :
Choix du mode de création du rapport Crystal (en utilisant l’assistant de création de
rapports, à partir d’un rapport vide ou à partir d’un rapport existant) ;
Choix de la source de données ;

57
Choix des informations à afficher dans le rapport ;
Regroupement des informations dans le rapport.
Différents éléments peuvent être ajoutés dans le rapport grâce à la boite à outils rapport
Crystal.
En définitif, la fenêtre de conception du rapport peut se présenter comme suit :
Une prévisualisation du rapport est possible en cliquant sur l’onglet « Aperçu Rapport
principal », mais les données affiché sont générées aléatoirement.

58
VI.10. Chargement de données dans un rapport ;
Le chargement des données dans un rapport crystal est effectué en utilisant la méthode
setDataSource() d’un objet du rapport. Cette méthode à besoin d’une collection d’objet qui
sera transmis en argument comme source de donnée du rapport.
Exemple :
Dim rapport As ListeDepartement = New ListeDepartement()
rapport.SetDataSource(DepartementDao.ObtenirDepartementParDirection())
...
La méthode DepartementDao.ObtenirDepartementParDirection() retourne une collection d’objet
conforme au nom des champs de la source de données utilisée lors de la conception du rapport.
VI.11. Afficher, Imprimer et Exporter un rapport.

Après avoir chargé les données dans un rapport, la finalité est soit d’afficher le rapport soit
l’imprimer directement soit Exporter le rapport.
VI.11.1. Affichage du rapport
L’affichage d’un rapport se fait à l’aide d’un objet de la boite à outils Visual Basic appelé
CrystalReportViewer qui doit être posé sur un formulaire.
Une fois posé sur un formulaire il faut spécifier le rapport à afficher.

59
Exemple :
Imports System.Windows.Forms
Private Sub PrintPreviewToolStripMenuItem_Click(ByVal sender As
System.Object, ByVal e As System.EventArgs) Handles
PrintPreviewToolStripMenuItem.Click
'Chargement de données dans le rapport
rapport.SetDataSource(Departement.ObtenirDepartementParDirection())
'Affichage du rapport
CrystalReportViewer1.ReportSource = rapport
End Sub
Après l’affichage d’un rapport, il est possible de l’exporter ou de l’imprimer à partir de l’objet
CrystalReportViewer.
VI.11.2. Exportation du rapport
L’exportation d’un rapport consiste à générer le rapport dans un fichier d’un format spécifique
(PDF, HTML, EXCEL,…).
Voyons comment exporter sans passer préalablement à l’affichage.
Exemple : exportation du rapport au format PDF (PortableDocFormat)
Imports CrystalDecisions.Shared
Private Sub ExporterToolStripMenuItem_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles ExporterToolStripMenuItem.Click
REM Chargement de données dans le rapport
rapport.SetDataSource(DepartementDao.ObtenirDepartementParDirection())
REM Preparation de l'exportation
'Affectation du type de format (PDF, HTML, EXCEL,...)
Dim OptionRapport As ExportOptions = New ExportOptions()
OptionRapport.ExportFormatType = ExportFormatType.PortableDocFormat
OptionRapport.ExportDestinationType =
ExportDestinationType.DiskFile
'Affectation du fichier vers lequel exporter
Dim diskOption As DiskFileDestinationOptions = New
DiskFileDestinationOptions()
Dim NomFichier As String = "C:\Liste département par direction.pdf"
diskOption.DiskFileName = NomFichier
OptionRapport.ExportDestinationOptions = diskOption
'Exportation
rapport.Export(OptionRapport)
End Sub
VI.11.3. Impression du rapport

Il peut s’avérer nécessaire d’imprimer un rapport sans afficher au préalable son aperçu avant
impression.
L’exemple ci-dessous montre comment arriver à cette fin :
Private Sub PrintToolStripButton_Click(ByVal sender As System.Object, ByVal
e As System.EventArgs) Handles PrintToolStripButton.Click
REM Chargement de données dans le rapport
Dim rapport As ListeDepartement =
Departement.ChargerRapportParDirection()
REM Assignation des valeurs par défaut de l'umpression
Dim PageDebut, PageFin As Integer

60
Dim dialogueImpression As PrintDialog = New PrintDialog()
dialogueImpression.PrinterSettings.Collate = True
dialogueImpression.AllowSelection = True
dialogueImpression.AllowSomePages = True
dialogueImpression.AllowPrintToFile = True
dialogueImpression.AllowCurrentPage = True
REM Affichage de la boite de dialogue d'impression
dialogueImpression.ShowDialog()
REM Assignation des paramètres de l'utilisateur
rapport.PrintOptions.PrinterName = New
PrintDialog().PrinterSettings.PrinterName
Dim NbrePage As Integer =
Convert.ToInt32(dialogueImpression.PrinterSettings.Copies)
Dim Collated As Boolean =
dialogueImpression.PrinterSettings.Collate
PageDebut = dialogueImpression.PrinterSettings.FromPage
PageFin = dialogueImpression.PrinterSettings.ToPage
'Test si le numéro de la page de debut est inférieur ou egal à
celui de la page de fin
If PageDebut <= PageFin Then
REM Impression
rapport.PrintToPrinter(NbrePage, Collated, PageDebut, PageFin)
Else
MessageBox.Show("Le numéro de la page de départ ne peut être
supérieur au numéro de fin. Veuillez entrer des valeurs valides.",
Application.ProductName);
End If
End Sub

61
VII. EMPAQUETAGE ET DEPLOIEMENT DE L’APPLICATION
VII.1. Ajout d’un projet Configuration et déploiement dans la solution
Menu Fichier – Ajouter – Nouveau projet
Dans la figure ci-dessous, nous remarquons la présence d’une solution « Solution ‘SGAE’ (2
projets) » et d’un nouveau projet Setup SGAE.
En plus, l’éditeur de fichier s’affiche dans la zone de travail avec deux zones (panneaux) :
Système de fichiers de l’ordinateur cible et contenu du nœud sélectionné.
D’autres nœuds peuvent être ajouté dans le Système de fichiers de l’ordinateur cible (zone
de gauche) de l’éditeur de fichier en utilisation le menu contextuel.

62
VII.2. Préparation des fichiers du setup
La préparation des fichiers consiste principalement à ajouter le fichier de sortie, les fichiers
additionnels jugés utiles au fonctionnement du logiciel et les raccourcis.
Ajouter du fichier de sortie
Le fichier de sortie est ajouté comme suit :
- Cliquer sur le nœud Dossier d’application ;
- Dans la partie de droite de l’éditeur faites un click droit – Ajouter – Sortie de projet…
- Sélectionner l’item Sortie principale et cliquer sur OK. La zone de droite affiche alors
le fichier de sortie et les références du projet.

63
Ajout du fichier additionnel (Icône et Module de fusion)
- Ajout de l’icône : Click droit sur la zone de droite – Ajouter – Fichier
Parcourez le disque jusqu’à sélectionner le fichier à ajouter (users.ico).
Création des raccourcis
- Click droit sur « Sortie principale de SGAE (Actif) » - Créer un raccourci vers Sortie
principale de SGAE (Actif)
- Renommer le raccourci avec le nom SGAE. Changer la propriété icon du raccourci

en parcourant le disque jusqu’au dossier de l’application.
- Déplacer le raccourci dans le nœud « Bureau de l’utilisateur » ou « Menu
Programmes de l’utilisateur » situé dans la zone de gauche de l’éditeur de fichier.
Cette procédure peut être appliquée pour placer un raccourci dans le Menu
programme de l’utilisateur.
VII.3. Embarquer les composants requis dans le projet setup

Ajout des composants requis
Les composants requis sont des composants qui peuvent être utilisés comme pré requis
avant l’installation du logiciel, l’exemple le plus flagrant est le Framework.
Pour l’ajouter il faut procéder comme suit :
- Click droit sur le Projet Setup SGAE - Propriétés

64
- Cliquer sur le bouton Composant requis…
- Cocher les cases à cocher correspondantes au composant requis que vous

souhaiter inclure dans le setup.
- Cocher la case d’option « Télécharger les composants requis à partir de
l’emplacement de mon application » puis cliquer sur le bouton OK.
Note : ces différents composants seront placer dans le dossier bin\Debug du projet Setup
après compilation.
VII.4. Génération du fichier Setup

La création du msi se fait simplement en compilant le projet Configuration et déploiement. Ce
qui implique la création d’un ficher Setup SGAE (par défaut le nom du projet) situé dans le
dossier bin\Debug du projet Setup SGAE.
Ce fichier de sortie peut être personnalisé via la boite de propriété du projet setup SGAE.

65

Support de Formation VB2008 Module1 - v1.0-1

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Support de Formation VB2008 Module1 - v1.0-1

Transféré par

Droits d'auteur :

Formats disponibles

L’ENVIRONNEMENT

De la base du langage basic à la gestion des

Par SEKE MAVINGA Jonathan

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

I.2. La programmation Orienté Objet

SEKE MAVINGA Jonathan / Formateur

I.3. Le langage UML (Unifield Modeling Language)

SECTION II : LES OUTILS D’AN ALYSE ET CONCEPTION

SEKE MAVINGA Jonathan / Formateur

1. L’explorateur des solutions : contient tous les éléments de la solution. Une

2. La boite de propriétés : elle présente les propriétés de l’objet sélectionné.

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

b) Extraction et Archivage des codes sources

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

II.1. Les types de données et déclaration de variable

Type VB Type .NET Taille Plage de valeurs

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

II.2. La conversion de type

II.3. Les structures

II.4. Les operateurs et expressions

II.4.2. Expression arithmétique

SEKE MAVINGA Jonathan / Formateur

II.5. Les instructions de contrôle

SEKE MAVINGA Jonathan / Formateur

If res Mod 7 = 0 Then

b) Fonction IIf : retourne un ou deux objets selon l'évaluation d'une expression.

c) Opérateur If : Utilise l'évaluation de court-circuit pour retourner conditionnellement l'une

SEKE MAVINGA Jonathan / Formateur

II.6. Les structures de répétition

SEKE MAVINGA Jonathan / Formateur

II.7. Les tableaux de données

SEKE MAVINGA Jonathan / Formateur

II.8. Les collections d’objets

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

II.9. La gestion des exceptions (Try, Catch et Finally)

SEKE MAVINGA Jonathan / Formateur

II.10. Passage de paramètres à une fonction

SEKE MAVINGA Jonathan / Formateur

Sub changeInt(ByVal a As Integer)

SEKE MAVINGA Jonathan / Formateur

Public Function Rechercher(...) As DataTable

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

II.12. Les méthodes et attributs de classe (Shared)

II.13. Les objets et les références d’objets

II.14. Passage d’un objet à une fonction

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur

Voyons à travers un exemple comment crée-t-on un Assemblage (Assembly) dans Visual

SEKE MAVINGA Jonathan / Formateur

Private Sub btnValider_Click(ByVal sender As System.Object, ByVal e As

Ajoutons la classe Login décrit comme suit :

Compilons le projet puis parcourons le dossier Login\bin\Debug dans son emplacement,

Nous utiliserons ce fichier par la suite.

SEKE MAVINGA Jonathan / Formateur

SEKE MAVINGA Jonathan / Formateur