Lycée Technique Qualifiant de Settat

BTS DSI
Développement des
Systèmes d’Information

Support de cours de

Visual Basic .NET

Réalisé par : Redouane Nejjahi

Année scolaire : 2015/2016

Table des matières
Partie 1 .................................................................................................................................................... 4
Prologue .................................................................................................................................................. 5
Chapitre 1 Notion de programme et instructions de base ................................................................... 11
I- Notion de programme ............................................................................................................... 11
1- Définition ............................................................................................................................... 11
2- Exemple ................................................................................................................................. 11
II - Notion de donnée.................................................................................................................. 11
1- Constantes & Variables ......................................................................................................... 12
2- Identifier les données ............................................................................................................ 13
3- Types de données .................................................................................................................. 14
4- Déclaration des données ....................................................................................................... 16
III - Les instructions de base ........................................................................................................ 17
1- Affectation ............................................................................................................................. 17
2- Lecture ................................................................................................................................... 17
3- Ecriture .................................................................................................................................. 18
Chapitre 2 Structures de contrôle de base............................................................................................ 22
I- Expressions et opérateurs ......................................................................................................... 22
1- Définition ............................................................................................................................... 22
2- Les opérateurs ....................................................................................................................... 22
3- Priorité des opérateurs.......................................................................................................... 29
4- Exemple d’un programme simple en Visual Basic ................................................................. 29
5- Exercices ................................................................................................................................ 30
II - La structure sélective............................................................................................................. 31
1- Structure sélective simple ..................................................................................................... 31
2- Structure selective alternative .............................................................................................. 31
3- Structures sélectives imbriquées........................................................................................... 32
4- Structures à choix multiples .................................................................................................. 33
Chapitre 3 Structures répétitives .......................................................................................................... 36
I- La boucle While ......................................................................................................................... 36
II - La boucle Do .......................................................................................................................... 39
1- Première forme ..................................................................................................................... 39
2- Deuxième forme .................................................................................................................... 39
3- Troisième forme .................................................................................................................... 39
4- Quatrième forme ................................................................................................................... 40
5- Exemples................................................................................................................................ 40

2
 III - La boucle For ......................................................................................................................... 41
IV - La boucle For Each ................................................................................................................. 42
V- Continue et Exit ..................................................................................................................... 42
Chapitre 4 Des types de variables plus complexes ............................................................................... 43
I- Les tableaux ............................................................................................................................... 43
1- Introduction ........................................................................................................................... 43
2- Déclaration et redimensionnement ...................................................................................... 44
3- Remplissage des valeurs d’un tableau .................................................................................. 45
4- Tableaux multidimensionnels ............................................................................................... 46
II - Les structures ........................................................................................................................ 47
III - Les énumérations .................................................................................................................. 49
Chapitre 5 Les sous-programmes .......................................................................................................... 51
1- Notion de sous-programme .................................................................................................. 51
2- Fonctions et procédures ........................................................................................................ 54
3- Les paramètres ...................................................................................................................... 54
4- Déclaration des fonctions et des procédures........................................................................ 55

3
Partie 1

4
Prologue

Visual Basic .NET (abrégé en VB .NET) est un langage de programmation créé par
Microsoft.

L’environnement de développement en VB .NET porte le même nom que le langage.

Ce logiciel fait partie d’une suite de logiciels appelée Microsoft Visual Studio dont la
dernière version est 2015.

Microsoft Visual Studio comporte en plus de Visual Basic : Visual C#, Visual C++ et
Visual F#.

Au lancement de Microsoft Visual Studio, vous vous trouvez face à son écran d’accueil,
semblable à celui-là :

Figure P.1

Sur Page de démarrage (cadre noir) figure la version du logiciel ainsi qu’un ensemble
de choix pour commencer. Pour ce faire, vous pouvez soit démarrer un nouveau projet
(en cliquant sur Nouveau projet…), soit ouvrir un projet qui existe déjà (en cliquant
sur Ouvrir un projet…).

Pour commencer, et puisqu’on n’a pas encore créé de projets VB, on va cliquer sur
Nouveau projet…

5
On se trouvera ainsi avec cette fenêtre :

Figure P.2

On peut choisir de développer en un autre langage de la suite Visual Studio (Visual

C#, Visual C++ ou Visual F#) en cliquant sur Autres langages. Pour notre cas, on garde
Visual Basic.

On peut choisir quel type de projet VB .NET nous voulons créer, à savoir :

Application console (comme les

programmes créés dans les langages C,
C++ et Pascal)

Figure P.3

6
 Application Windows Forms
(application avec des fenêtres, des
boutons, des menus, etc.)

Figure P.4
Pour la suite de ce cours, on va apprendre à développer des applications Console,
jusqu’à ce qu’on maîtrise les éléments de base du langage VB .NET, en ce moment-là
on va entamer la partie visuelle.

En ce qui concerne le nom de notre projet (cf. Figure P.2), Visual Basic donne par défaut
le nom ConsoleApplicaion1, on peut choisir le nôtre en saisissant à la place un autre
nom, par exemple Simple Test.

Cliquons donc sur Application Console, saisissons le nom Simple Test puis cliquons
sur OK (on peut aussi double-cliquer directement sur Application Console après avoir
saisi le nom). On se trouve maintenant dans l’espace de développent d’applications
console :

Figure P.5

On remarque bien que le titre de cette fenêtre est « Simple Test – Microsoft Visual
Studio ».

7
L’onglet au centre de la fenêtre porte le nom de Module1.vb, il s’agit du fichier source
qui contient notre programme. Le contenu de ce fichier est affiché en-dessous.

Module1.vb : est le nom du fichier

Examinons maintenant le code source :
Code
Module Module1

Sub Main()

End Sub

End Module

Figure P.6

Le code source est délimité par les mots-clés Module et End Module, entre ces deux
limites vont figurer toutes les fonctions et procédures composant le programme, on
voit déjà que Visual Basic nous fournit un code minimum, il s’agit de :
Sub Main()

End Sub

c’est le programme principal (Main en anglais). On voit bien qu’il est délimité par les
mots-clés Sub et End Sub.

Sub est l’abréviation de Subroutine qui veut dire sous-programme. Les sous-
programmes (fonctions et procédures) seront étudiés en détail plus loin dans ce cours.
Pour le moment, sachez qu’il faut avoir obligatoirement la procédure Main, car c’est le
programme principal, et c’est là-dedans qu’on va mettre les instructions à exécuter.

Pour commencer, on va essayer de réaliser le programme Hello World, qui consiste en

l’affichage du message : « Hello World ! ».

Plaçons-nous donc entre Sub Main() et End Sub.

Saisissons les deux instructions suivantes :

Code
Console.WriteLine("Hello World!")
Console.ReadLine()

8
Figure P.7

Le nom de l’onglet devient Module1.vb*, l’astérisque veut dire qu’on n’a pas encore
enregistré les modifications faites, cliquons alors sur l’un des boutons Enregistrer
(pour enregistrer Module1.vb) ou Enregistrer tout (si on veut enregistrer le fichier
Module1.vb et le cas échéant d’autres fichiers ouverts) :

Figure P.8

Après avoir cliqué sur l’un des deux boutons, le nom de l’onglet ne porte plus
d’astérisque.

Pour tester notre programme « Simple Test », cliquons sur le bouton Démarrer au-
dessus de l’onglet Module1 :

Figure P.9

Une fenêtre console se lance, affichant le message « Hello World ! » et mettant le

curseur à la ligne. Le programme attend à ce qu’on tape Entrée pour se fermer.

9
Figure P.10

Tapez donc Entrée, vous vous retrouverez dans l’espace de développement avec le
code source du programme Simple Test, si vous voulez en ajouter des instructions ou
modifier celles existantes.

10
Chapitre 1

Notion de programme et instructions de base

I- Notion de programme
1- Définition
Un programme est une suite d’actions précises (appelées instructions) qui doivent
être exécutées dans un ordre déterminé en vue de la résolution d’un problème.

2- Exemple
Pour calculer la somme de deux nombres, on donne à l’ordinateur l’ordre pour :

 demander l’utilisateur de saisir la valeur du premier nombre

 enregistrer cette valeur
 demander l’utilisateur de saisir la valeur du deuxième nombre
 enregistrer cette nouvelle valeur
 additionner les deux valeurs et enregistrer le résultat
 afficher à l’utilisateur le résultat

II - Notion de donnée
Les programmes généralement agissent sur des données. Par exemple, le programme
de connexion du site Facebook a besoin des données « Adresse électronique ou
téléphone » et « Mot de passe » ; si c’est la première fois qu’on se connecte à ce site
Web, il nous demande de remplir les champs suivants, à savoir sept données
différentes : « Prénom », « Nom de famille », « Adresse électronique ou numéro de
mobile », « Confirmer l’adresse électronique ou le numéro… », « Nouveau mot de
passe », « Date de naissance » et de préciser le « Sexe » (Femme ou Homme).

11
Figure 1.1

Le programme de connexion de Facebook va prendre ces données et les mettre

chacune dans une place mémoire pour pouvoir les récupérer quand il en aura besoin.

Si, à un certain moment, il veut savoir quel est le mot de passe que l’utilisateur a saisi,
pour le comparer à celui enregistré dans le serveur, il va aller à la mémoire pour le
récupérer, mais la mémoire contient des milliers et des milliers de cases, laquelle garde
la donnée représentant le mot de passe ? Pour ce faire, on doit désigner chaque donnée
par un nom unique dans le programme qui permet par la suite de la repérer dans la
mémoire.

Nom de la donnée Valeur de la donnée

………
………
firstName Ali
lastNom Idrissi
email [email protected]
confirmedEmail [email protected]
password azertyqwerty
dateOfBirth 05/03/1987
sexe 2
………

1- Constantes & Variables

Les données peuvent varier, on les appelle VARIABLES (comme par exemple le nom,
le prénom et la date de naissance qui varient d’un utilisateur à l’autre, ou le rayon d’un
cercle qui varie d’un cercle à l’autre). Les données peuvent aussi avoir une valeur fixe
tout au long du programme, on les appelle CONSTANTES (comme par exemple le
coefficient de mathématiques qui est fixe pour tous les élèves d’une classe, ou la valeur

12
de π nécessaire pour le calcul de la surface d’un cercle et qui vaut approximativement
3.14 quel que soit le cercle).

Sachez aussi que Visual Basic .NET a prédéfini quelques constantes qui sont
généralement utilisées dans l’impression et l’affichage. Parmi ces constantes, on peut
citer :

Constante Description
vbCrLf Combinaison de retour chariot et de saut de ligne
vbCr Caractère de retour chariot
vbLf Caractère de saut de ligne
vbNewLine Caractère de saut de ligne
vbTab Caractère de tabulation
vbBack Caractère de retour arrière

2- Identifier les données

Ces données, qu’elles soient constantes ou variables, sont représentées dans les
programmes par des noms qui les identifient, par exemple : prenom, nom, x, y,
longueur, largeur, age, date_de_naissance, etc.

Le nom de la variable ou de la constante doit être le plus explicite possible.

Par défaut, en Visual Basic .NET, la casse des variables ne permet pas de les
distinguer ; c’est-à-dire qu’on ne peut pas déclarer deux variables ayant comme noms :
a et A; en fait, en Visual Basic .NET, il s’agit de la même variable.

Figure 1.2

13
3- Types de données
Les données sont de types différents, par exemple les variables nom et prenom sont
des textes, la variable age est de type entier naturel, temperatue est de type entier
relatif, poid et de type décimal, et ainsi de suite.

Les types de données en Visual Basic .NET sont :

SByte Byte Short Ushort Integer UInteger Long Ulong

Single Double Decimal
Char String Boolean Date Object

Les types de la première ligne, à savoir, SByte, Byte, Short, Ushort, Integer, UInteger,
Long et Ulong correspondent au type Entier ; la moitié est de type Entier naturel (en
couleur rouge) et l’autre moitié est de type Entier Relatif (en couleur bleu).

Alors, pourquoi a-t-on quatre types différents pour représenter les entiers positifs ? La
même question se pose pour les entiers relatifs ? On sait que le type Entier relatif
englobe le type Entier, alors n’est-il pas possible d’utiliser un seul type pour tous les
entiers. La réponse est oui, mais il y aura un problème de gestion de la mémoire.

En fait ces types n’occupent pas tous la même taille dans la mémoire. Par exemple, le
type Byte occupe un octet dans la mémoire, et on sait qu’un octet ne peut coder que
256 valeurs différentes, alors Visual Basic .NET utilise ce type pour représenter les
valeurs entières comprises entre 0 et 255 (ce qui donne 256 valeurs). Le type UShort
occupe, quant à lui, deux octets dans la mémoire, ce qui lui permet de coder 65 536
valeurs différentes ; et VB .NET l’utilise ainsi pour représenter les valeurs entières
comprises entre 0 et 65 535.

Donc si vous voulez travailler sur le nombre d’élèves, vous déclarerez une variable
que vous pouvez appeler nbrEleves. S’il s’agit du nombre d’élèves d’une classe, alors
le type Byte est bien adéquat, ainsi, la variable nbrEleves va occuper un seul octet dans
la mémoire. Si vous déclarer cette variable comme étant un UShort, le programme
fonctionne sans problème, car avec UShort vous pouvez utiliser les valeurs entre 0 et
65 535, ce qui est largement suffisant pour représenter le nombre d’élèves d’une classe.
Donc, avec Byte ou UShort, le programme fonctionne, mais le problème est qu’avec
UShort on utilise deux octets de la mémoire alors qu’on n’a besoin que d’un seul octet.

Supposons maintenant qu’on veut représenter le nombre d’élèves d’un établissement

scolaire, le type Byte ne suffira pas, puisqu’il est limité à 255, alors que le nombre
d’élèves du lycée par exemple peut être 2000. Ici, on doit avoir recours au type UShort.

14
Tout est question de ne pas gaspiller de la mémoire. Donc pour déclarer des variables,
pensez au type le plus adéquat.

Voici un tableau représentant les différents types de données sous VB .NET, avec leurs
tailles et plages des valeurs possibles :

Type Plage des valeurs Taille

SByte -128 à 127 1 octet
Byte 0 à 255 1 octet
Short -32 768 à 32 767 2 octets
UShort
Entier

0 à 65 535 2 octets
Integer -2 147 483 648 à 2 147 483 647 4 octets
UInteger 0 à 4 294 967 295 4 octets
-9 223 372 036 854 775 808 à
Long 9 223 372 036 854 775 807
8 octets

ULong 0 à 18 446 744 073 709 551 615 8 octets

-3,4028235E+38 à -1,401298E-45
Nombres à virgule flottante

pour les valeurs négatives

Single 1,401298E-45 à 3,4028235E+38
4 octets
pour les valeurs positives
-1,79769313486231570E+308 à
-4,94065645841246544E-324
Réels

pour les valeurs négatives

Double
ou

8 octets
4,94065645841246544E-324 à
1,79769313486231570E+308
pour les valeurs positives
+/- 79 228 162 514 264 337 593 543 950 335
sans chiffre décimal
Decimal +/- 7,922 816 251 426 433 759 354 395 033 5
16 octets
avec 28 positions à droite de la virgule
Char Un symbole Unicode entre 0 et 65 535 2 octets
Texte

Dépend de
Une chaine Unicode avec une longueur
String maximum de 2 147 483 647 caractères.
la
plateforme
Booléen / Dépend de
Boolean True ou False la
Logique plateforme
Du 1 janvier 0001 00:00:00 AM au
Date Date 31 décembre 9999 11:59:59 PM
8 octets
4 octets
sur 32-bit
Tout type peut être enregistré dans une
Objet Object variable de type object.
et
8 octets
sur 64-bit

15
Exemples de valeurs possibles :
Pour les types nombres, à savoir, SByte, Byte, Short, UShort, Integer, UInteger, Long,
ULong, Single, Double et Decimal, toutes leurs valeurs possibles sont déjà
mentionnées dans le tableau. En ce qui concerne les autres types, des exemples de
valeurs possibles sont données ci-après :

Char : "A" "G" "m" "+" "?" "." "’" " " "0" "5" "@" "€" etc.

String : "Ahmed" "527" "[email protected]" "20, Bd. 3 Mars, Settat" etc.

Boolean : True False etc.

Date : "15/02/2005" "12:51:36" "05:34" "15/02/2005 12:28" etc.

Objet : les variables de type objet peuvent contenir n’importe quelle valeur.
Remarques :
 Les caractères (Char) sont représentés dans les programmes entre deux
guillemets " ".
 "1" représente le caractère 1 et non pas la valeur entière 1.
 Une chaîne de caractères (String) est une donnée qui contient une suite de
caractères, comme le prénom d’un utilisateur. Les chaînes de caractères sont
aussi représentées entre deux guillemets " ".
 Le fait de représenter les caractères et les chaînes de caractères entre deux
guillemets permet de les distinguer des noms des variables. Par exemple : x, A,
Adresse sont des noms des données (constantes ou variables), alors que "x", "A",
"Adresse" sont des valeurs de type caractère pour les deux premières valeurs et
de type chaîne de caractères pour la troisième valeur.

4- Déclaration des données

En Visual Basic .NET il y a deux instructions pour déclarer les constantes et les
variables, à savoir Const et Dim respectivement.

Pour les constantes, la syntaxe est :

Syntaxe
Const nom_de_constante As Type_de_la_constante = valeur_de_la_constante

16
Par exemple :

Code
Const coefMath As Byte = 4
Const tva As Single = 0.2
Const Pi As Single = 3.14

Pour les variables, la syntaxe est :

Syntaxe
Dim nom_de_la_variable As Type_de_la_variable
Dim nom_de_la_variable As Type_de_la_variable = valeur_d_initialisation
Dim nom_de_variable_1, nom_de_variable_2, ... As Type_des_variables

Par exemple :

Code
Dim a As Byte
Dim b As Byte = 20
Dim prenom, nom, adresse As String

III - Les instructions de base

On désigne par les instructions de base les instructions qu’on trouve souvent dans tous
les programmes. Il s’agit des instructions de lecture, d’écriture et d’affectation.

1- Affectation
L’affectation est une attribution d’une valeur à une variable. Elle se note en VB .NET
avec le signe =. On l’a déjà vu lors de la déclaration des variables et des constantes.

Exemples :
Soient A, B et S trois variables de type Integer.

A = 23 cette instruction attribue à la variable A la valeur 23

A=B cette instruction attribue à la variable A la valeur de la variable B
cette instruction additionne la valeur de la variable A à celle de la variable
S=A+B
B et attribue le résultat à la variable S
Remarques :
 L’affectation ne modifie que ce qui est à gauche de l’opérateur d’affectation =.
 Les deux membres de l’affectation doivent être de même type.

L’instruction A = 23 peut être lue : A reçoit 23.

2- Lecture
La lecture est l’opération qui permet de lire des données tapées au clavier par
l’utilisateur et de les affecter à des variables.

17
Exemple :
Soit la variable Age de type Byte.
L’instruction :
Age = Console.ReadLine()

permet à l’utilisateur d’entrer une valeur pour la variable Age, cette valeur sera
automatiquement affectée à cette variable.

En VB .NET, il y a trois instructions de lecture, à savoir : Console.ReadKey(),

Console.Read() et Console.ReadLine()
 Console.ReadKey() permet de lire le caractère suivant ou la touche de fonction sur
laquelle l’utilisateur a appuyé.
 Console.Read() permet de lire le caractère suivant que l’utilisateur a entré. La
valeur retournée est de type Integer représentant le code du caractère.
 Console.ReadLine() permet de lire ce que l’utilisateur a saisi au clavier comme
étant une chaîne de caractères puis le convertir au type de la variable recevant
cette valeur.
Remarques :
Les trois instructions de lecture retournent une valeur qu’il faut attribuer à une
variable (faire attention au type de la valeur retournée) ou l’utiliser là où on
peut utiliser une variable. Par exemple :
Console.WriteLine(Console.ReadLine()) cette instruction affiche ce que l’utilisateur
a tapé.

Dim ch1, ch2 As String

ch1 = "Bonjour "
Console.Write("Entrez votre nom: ")
ch2 = ch1 & Console.ReadLine()
Si l’utilisateur a entré Said, alors la valeur de ch2 sera : "Bonjour Said"

L’utilisation de l’instruction « Console.ReadLine() » tout court, sans une variable

qui recevra l’entrée de l’utilisateur, sert à garder l’affichage à l’écran jusqu’à ce
que l’utilisateur tape la touche Entrée.

3- Ecriture
L’écriture est l’opération qui permet au programme de communiquer des valeurs à
l’utilisateur, d’afficher des messages ou de combiner les deux.

Exemples :
 Console.WriteLine("Bonjour tout le monde.")
Cette instruction affiche à l’écran le message : Bonjour tout le monde.
 Console.WriteLine(Salaire)
Cette instruction affiche le contenu de la variable Salaire, c.-à-d. sa valeur.
 Console.WriteLine("Le salaire mensuel est : " & Salaire)

18
 Si on suppose que Salaire = 7500.38, alors cette instruction affichera :
Le salaire mensuel est : 7500.38

L’opérateur & (qu’on étudiera après inchaa Allah) permet de concaténer le message à
la valeur de la variable Salaire.

En Visual Basic .NET, l’écriture existe sous deux formats : Console.Write() et

Console.WriteLine()
 Console.Write() permet d’afficher quelque chose à l’écran, à condition qu’on lui
donne quelque chose à afficher ! Après avoir affiché ce qu’on lui a demandé
d’afficher le curseur reste à sa place, c.-à-d. après le dernier caractère affiché.
 Console.WriteLine() permet d’afficher ce qu’on lui a donné entre les parenthèses,
et après l’avoir affiché, elle provoque un retour à la ligne. Si on n’avait rien mis
entre les parenthèses, cette instruction consistera simplement en un retour à la
ligne.
Combiner plusieurs messages et valeurs dans une seule instruction d’écriture :
Supposons qu’on a effectué les instructions suivantes :
A=5
B=7
S=A+B
Alors la valeur de S est 12.
L’instruction suivante :
Console.WriteLine("La somme de " & A & " et " & B & " est : " & S)
permet d’afficher :
La somme de 5 et 7 est : 12
Une autre alternative pour avoir le même résultat est :
Console.WriteLine("La somme de {0} et {1} est : {2}", A, B, S)
Les variables A, B et S dont on veut afficher la valeur sont numérotées dans l’ordre de
leur apparition en commençant par 0 ; soit A 0, B  1 et S 2. A chaque fois que le
programme rencontre dans la chaîne de caractères un numéro mis entre accolades, il
le remplace par la valeur de la variable qui lui correspond. Par exemple, l’instruction :
Console.WriteLine("{2} est la somme de {0} et {1}. c.-à-d. {0} + {1} = {2}", A, B, S)
va afficher :
12 est la somme de 5 et 7. c.-à-d. 5 + 7 = 12
On vient de voir que l’instruction d’écriture est l’opération qui permet au programme
de communiquer des valeurs à l’utilisateur, d’afficher des messages ou de combiner
les deux. En fait, cette instruction permet au programme d’afficher des constantes, des
valeurs de variables ou les deux. Les messages n’étant qu’un cas particulier de
constantes, il s’agit des constantes de type chaîne de caractères. Donc on peut afficher
toutes sorte de constantes, soit par des valeurs directes ou via des noms des constantes
définies par l’utilisateur.

19
Par exemple :
Code Résultats
Console.WriteLine(7)
Console.WriteLine(-3.5)
Console.WriteLine(214748364718446744)
Console.WriteLine(9223372036854775807)
Console.WriteLine("m")
Console.WriteLine("Bonjour tous")
Console.WriteLine(True)
Console.WriteLine(False)

Nous avons vu que les constantes prédéfinies par Visual Basic .NET sont souvent
utilisées dans l’impression et l’affichage. Si vous remarquez bien sur l’image
précédente présentant les résultats de l’exécution du code, les valeurs affichées sont
collées à la borne gauche de la fenêtre. Pour une bonne présentation, il vaut mieux les
décaler un peu à droite, si on veut que ce décalage soit automatique, on a recours à la
constante vbTab. Aussi on peut regrouper toutes ces valeurs dans une seule instruction
WriteLine et garder le retour à la ligne après avoir affiché chaque valeur, c’est ce que
nous pouvons faire avec la constante vbCrLf.
Les deux instructions suivantes :
Code
Console.WriteLine(vbCrLf & vbCrLf & vbCrLf & vbTab & 7)
Console.WriteLine(vbTab & -3.5 & vbCrLf & vbTab & "m" & vbCrLf &
vbTab & "Bonjour tous" & vbCrLf & vbTab & True)

permettent d’avoir le résultat suivant :

Exercice 1.1
Soient A et B deux variables de type Single. Donner les instructions qui permettent
d’échanger leurs valeurs.
Solution
On veut attribuer la valeur de A à B et celle de B à A.
Si on procède comme suit :
A=B
B=A

20
Ces deux instructions vont mettre dans les deux variables A et B la même valeur, à
savoir celle de B.
Si, au départ, on a :
A 3.5
B 7
Alors, la première instruction, à savoir : A = B va attribuer à la variable A la valeur de
B:
A 7
B 7
La deuxième instruction, B = A, va écraser la valeur de B qui est 7 pour mettre celle de
A qui est aussi 7, pour avoir en résultat :
A 7
B 7
Pour résoudre ce problème, il faut qu’on utilise une troisième variable (qui joue le rôle
de variable auxiliaire) pour y stocker la valeur initiale de A avant l’écraser, d’où les
instructions suivantes :
Dim C As Single
C=A
A=B
B=C
1ère instruction 2ème instruction 3ème instruction 4ème instruction
Dim C As Single C=A A=B B=C
A 3.5 A 3.5 A 7 A 7
B 7 B 7 B 7 B 3.5
C ? C 3.5 C 3.5 C 3.5

Exercice 1.2 (Exercice de réflexion)

Il s’agit de la même question mais cette fois-ci sans utiliser une variable auxiliaire.
Solution
A étudier et tester ces instructions à titre reposé :
A=A+B A=A-B A=A*B A=A/B
B=A-B B=A+B B=A/B B=A*B
A=A-B A=B-A A=A/B A=B/A

21
Chapitre 2

Structures de contrôle de base

I- Expressions et opérateurs
1- Définition
Une expression est une ensemble de valeurs, reliées par des opérateurs et
équivalente à une seule valeur.
Un opérateur est un signe qui relie deux valeurs pour produire un résultat
(cas d’opérateur binaire).
Exemple

S=A+B

A+B est une expression

+ est un opérateur (c’est l’opérateur de l’addition)
S = A + B est une instruction (c’est l’instruction de l’affectation)
2- Les opérateurs
On peut répertorier les opérateurs selon leurs fonctionnalités :
 Opérateurs arithmétiques
 Opérateurs de comparaison
 Opérateurs de concaténation
 Opérateurs logiques/de bits
 Opérateurs de décalage de bits
 Opérateurs d'assignation
a. Les opérateurs arithmétiques
Les opérateurs arithmétiques définis dans Visual Basic sont les suivants :
^ * / \ Mod + -
Pour les opérateurs + et -, il s’agit d’opérateurs à la fois unaires et binaires.
L’opérateur puissance (^)
L’opérateur puissance élève un nombre à la puissance d'un autre nombre.
Syntaxe :
nombre ^ exposant

22
Exemple :
5^2
Le résultat est 25
L’opérateur de multiplication (*)
L’opérateur de multiplication multiplie un nombre par un autre nombre.
Syntaxe :
nombre1 * nombre2
Exemple :
5*2
Le résultat est 10
L’opérateur de division (/)
L’opérateur de division divise un nombre par un autre nombre.
Syntaxe :
nombre1 / nombre2
Exemple :
5/2
Le résultat est 2.5
L’opérateur de division entière (\)
L’opérateur de division entière donne le quotient de la division euclidienne (entière)
d’un nombre par un autre nombre.
Syntaxe :
nombre1 \ nombre2
Exemple :
5\2
Le résultat est 2
L’opérateur modulo (Mod)
L’opérateur modulo donne le reste de la division euclidienne (entière) d’un nombre
par un autre nombre.
Syntaxe :
nombre1 Mod nombre2
Exemple :
5 Mod 2
Le résultat est 1

23
L’opérateur d’addition (+)
L’opérateur d’addition additionne un nombre et un autre nombre.
Syntaxe :
nombre1 + nombre2
Exemple :
5+2
Le résultat est 7
L’opérateur de soustraction (-)
L’opérateur de soustraction retranche un nombre à un autre nombre.
Syntaxe :
nombre1 – nombre2
Exemple :
5-2
Le résultat est 4
b. Les opérateurs de comparaison
Les opérateurs de comparaison définis dans Visual Basic sont les suivants :
< <= > >= = <>
inférieur supérieur
inférieur à supérieur à égal à différent de
ou égal à ou égal à
Exemple :

Code
Dim test As Boolean
Dim Moy_Gen As Single
Moy_Gen = 10.29
test = Moy_Gen >= 10
Console.WriteLine(test)

Ce code affichera : True

c. L’opérateur de concaténation (& ou +)
C’est l’opérateur qui permet de concaténer ou de joindre deux chaînes de
caractères.

24
Exemples :

Code
Dim A, B, C As String
A = "Pro"
B = "gramme"
C = A & B '(ou C = A + B)
Console.WriteLine(C)
Ce code affichera : Programme

Code
A = "Bonjour" & " " & "tous"
'(ou A = "Bonjour" + " " + "tous")

La valeur de A est : "Bonjour tous"

Question :
Y a-t-il une différence entre ces deux formes d’opérateur (& et +) ?
d. Les opérateurs logiques/de bits
Les opérateurs de bits (ou opérateurs logiques) définis dans Visual Basic sont les
suivants :
And Or Xor Not AndAlso OrElse IsFalse IsTrue

Tous ces opérateurs agissent sur des valeurs booléennes et retournent comme
résultat une valeur booléenne. Par contre, les opérateurs AND, Not, Or et XOR
peuvent aussi agir sur des données numériques et retournent ainsi des valeurs
numériques.
L’opérateur NOT est un opérateur unaire.
Soient p, q et r trois variables booléennes.
L’opérateur AND
r = p AND q
r vaut True si les deux variables p et q valent toutes les deux True.
L’opérateur OR
r = p OR q
r vaut True si au moins l’une des deux variables p et q vaut True.
L’opérateur XOR
r = p XOR q
r vaut True si l’une des deux variables p et q vaut True et l’autre vaut False ; c.-à-
d. si les deux variables p et q ont deux valeurs opposées.

25
L’opérateur NOT
r = NOT p ou r = NOT (p)
La valeur de r est la négation de celle de p.
Exercice :
Compléter les tableaux suivants :
A B A AND B
True True
True False
False True
False False

A B A OR B
True True
True False
False True
False False

A B A XOR B
True True
True False
False True
False False

A NOT (A)
True
False

Quant à l’utilisation des opérateurs AND, OR, XOR et NOT avec des valeurs
numériques, les opérations s’effectuent sur les bits de même position comme suit :
Soient A et B deux variables entières.
Et si le bit Le bit résultant pour l’opération au-dessous a
Si le bit dans
dans la la valeur
la variable A
variable B a la
a la valeur AND OR XOR
valeur
1 1 1 1 0
1 0 0 1 1
0 1 0 1 1
0 0 0 0 0

26
 Le bit résultant pour l’opération
Si le bit dans la variable A a la valeur
NOT(A) a la valeur
1 0
0 1
e. Les opérateurs de décalage de bits
Les opérateurs de décalage de bits définis dans Visual Basic sont les suivants :
<< >>
Ces deux opérateurs binaires permettent d’effectuer sur une valeur (le premier
opérande) un décalage de bits d’un nombre de positions à gauche (<<) ou à
droite (>>).
Syntaxe :
resultat = valeur_initiale << nombreDeBitsADecaler
resultat = valeur_initiale >> nombreDeBitsADecaler
Remarque :
Les bits qui débordent de la plage des valeurs possibles sont perdus,
tandis que les valeurs libérées sont remplacées par des zéros.
Exemples :
1– Dim A, B, C As Short
A=6
B=2
C = A << B

La variable C vaut 24

2- A=6
B=2
C = A >> B

La variable C vaut 1
Exercice :
Dim valeur_initiale As Short = 192
' La valeur de la variable valeur_initiale en binaire est : 0000 0000 1100 0000.
Dim resultat1, resultat2, resultat3, resultat4, resultat5 As Short
resultat1 = valeur_initiale << 0
resultat2 = valeur_initiale << 4
resultat3 = valeur_initiale << 9
resultat4 = valeur_initiale << 17
resultat5 = valeur_initiale << -1

27
Quelles sont les valeurs des variables resultat1, resultat2, resultat3, resultat4 et
resultat5 ?

valeur_initiale As Short = 2560

resultat1 = valeur_initiale << 0
resultat2 = valeur_initiale << 4
resultat3 = valeur_initiale << 10
resultat4 = valeur_initiale << 18
resultat5 = valeur_initiale << -1

Quelles sont maintenant les nouvelles valeurs des variables resultat1, resultat2,
resultat3, resultat4 et resultat5 ?
f. Les Opérateurs d'assignation
Les opérateurs d'assignation définis dans Visual Basic sont les suivants :
= ^= *= /= \= += -= <<= >>= &=
Remarque :
MOD= n’est pas valide. Par exemple : A MOD= B (Faites attention)
Outre l’opérateur d’assignation = vu précédemment et qui permet d’affecter
(assigner) une valeur à une variable, les opérateurs restant ne sont qu’une amélioration
du code.
Reprenons le tableau mentionnant les cas d’utilisation de l’opérateur d’assignation =.
A = 23 cette instruction attribue à la variable A la valeur 23
A=B cette instruction attribue à la variable A la valeur de la variable B
cette instruction additionne la valeur de la variable A à celle de la variable
S=A+B
B et attribue le résultat à la variable S

C’est dans le troisième cas, à savoir attribuer à une variable le résultat d’une opération
(par exemple : S = A + B), et quand le premier opérande de l’opération est la variable
elle-même (par exemple S = S + B) qu’on peut utiliser ces opérateurs.
Par exemple, S = S + B peut s’écrire S += B.
Ainsi :
L’instruction Equivaut à
x ^= y x=x^y
x *= y x=x*y
x /= y x=x/y
x \= y x=x\y
x += y x=x+y
x -= y x=x-y
x <<= y x = x << y
x >>= y x = x >> y
x &= y x=x&y

28
3- Priorité des opérateurs
On veut dire par la priorité des opérateurs l’ordre dans lequel se fait des opérations
quand une instruction contient plusieurs opérateurs.
Par exemple : a = 2 + 3 * 2. Visual Basic .NET considère cette instruction comme
étant l’affectation de la valeur de 8 (et non pas 10) à la variable a.
L’ordre de priorité des opérateurs dans Visual Basic est comme suit :

Opérateurs Désignation
^ Élévation à une puissance

+ - Identité et négation unaires

* / Multiplication et division à virgule flottante

\ Division entière

Mod Modulo arithmétique

+ - Ajout et soustraction

& Concaténation de chaînes

<< >> Décalage de bits arithmétique

= <> < <= > >= Tous les opérateurs de comparaison

Not Négation

And Conjonction

Or Disjonction inclusive

Xor Disjonction exclusive

Quand plusieurs opérateurs de même priorité apparaissent dans une expression,

l’évaluation se fait de gauche à droite ; par exemple : a = 2 – 3 + 2 affecte à la variable
a la valeur 1 et non pas la valeur -3.
Pour ne pas avoir l’ordre de priorité préétabli par Visual Basic ou pour plus de
clarté il vaut mieux d’utiliser des parenthèses. Par exemple : a = 2 + 3 * 2 affecte à la
variable a la valeur 8 de même que : a = 2 + (3 * 2) ; alors que : a = (2 + 3) * 2 affecte
à la variable a la valeur 10.

4- Exemple d’un programme simple en Visual Basic

Il s’agit du programme permettant d’effectuer la somme de deux nombres saisis
par l’utilisateur.
Analyse :
Le programme a besoin de deux valeurs qui seront saisies par l’utilisateur au
clavier ; puis le programme effectuera le calcul de leur somme pour afficher ainsi
le résultat trouvé.
On remarque que ce programme va agir sur trois données différentes, à savoir les
deux nombres donnés par l’utilisateur et leur somme.

29
 Les valeurs de ces données ne sont pas connues au préalable, et vont varier pour
chaque utilisation du programme ; donc il s’agit de variables et non pas de
constantes.
Définissons maintenant leurs types.
Pour calculer la somme de deux nombres, il n’y a pas de contraintes particulières,
par contre s’il s’agissait de calculer le PGCD (Plus Grand Commun Diviseur) de
deux nombres, ces nombres ainsi que le résultat doivent être de type entier.
Le programme complet de la somme peut être comme suit :

Code
Module Module1

Sub Main()
Dim A, B, S As Double
Console.Write("Entrez la valeur du premier nombre: ")
A = Console.ReadLine()
Console.Write("Entrez la valeur du deuxième nombre: ")
B = Console.ReadLine()
S = A + B
Console.WriteLine("La somme de {0} et {1} est: {2}", A, B, S)
Console.ReadLine()
End Sub

End Module

5- Exercices
Pour bien intégrer toutes les notions vues jusqu’ici, essayons de pratiquer en résolvant
les exercices suivants.
Exercice 2.1
Ecrire un programme VB .NET qui permet de calculer et d’afficher la surface d’un
rectangle.
Exercice 2.2
Ecrire un programme VB .NET qui permet de calculer et d’afficher la surface d’un
cercle.
Exercice 2.3
Ecrire un programme VB .NET qui permet de calculer et d’afficher le périmètre et la
surface d’un cercle.
Exercice 2.4
Ecrire un programme VB .NET qui demande les notes des deux contrôles et la note de
l’examen puis calcule et affiche la note finale de la matière.
(Note contrôle  30% et Note examen  40%)

30
II - La structure sélective
La structure sélective permet d’exécuter telles instructions ou telles autres en fonction
de réponses à des conditions.
Dans ce genre de programmes, utilisant des structures sélectives, certaines instructions
peuvent ne pas être exécutées même si elles sont mises dans le programme.
Il y a trois types de structures sélectives :
 Structure sélective simple
 Structure alternative
 Structure à choix multiples

1- Structure sélective simple

Syntaxe
If condition Then
Instructions
End If

Ou bien:
Syntaxe
If condition Then Instructions

Ici, les instructions –qui peuvent bien sûr être une seule instruction- ne sont exécutées
que si la condition est remplie ; sinon, l’ordinateur ne fait rien et passe directement à
la suite du programme pour continuer son exécution.
Par exemple :
Code
If (Moyenne_Generale >= 10) Then
Console.WriteLine("Vous avez réussi.")
End If

Remarque :
Dans le cas où on utilise la structure sélective sur une seule ligne, on ne doit
pas mettre le mot-clé End If.

2- Structure selective alternative

Syntaxe
If condition Then
Instructions_1
Else
Instructions_2
End If
Ou bien:
Syntaxe
If condition Then Instructions_1 Else Instructions_2

31
Ici, les instructions du bloc n° 1 qui peut toujours être une seule instruction ne sont
exécutées que si la condition est remplie ; sinon, ce sont les instructions du bloc n° 2
qui seront exécutées. Dans tous les cas, une fois les instructions du bloc n° 1 ou 2 sont
exécutées l’ordinateur passe à la suite du programme pour continuer son exécution.
Par exemple :
Code
If (Moyenne_Generale >= 10) Then
Console.WriteLine("Vous avez réussi.")
Else
Console.WriteLine("Vous avez échoué.")
End If

3- Structures sélectives imbriquées

Quand il s’agit d’effectuer plusieurs tests, on imbrique les structures sélectives, c.à.d.
que le bloc d’instructions peut lui-même être une autre structure sélective simple ou
alternative.
Supposons qu’on a les mentions suivantes :
Passable pour [10, 12[ ; Assez-Bien pour [12, 14[ et Bien pour [14, 20]. Bien sûr pour
Moyenne_Generale < 10, on affiche « Echoué ». Après avoir calculé la moyenne
générale, et pour afficher la mention, on peut utiliser le code suivant :
Code
If Moyenne_Generale < 10 Then
Console.WriteLine("Echoué")
Else
If Moyenne_Generale < 12 Then
Console.WriteLine("Passable")
Else
If Moyenne_Generale < 14 Then
Console.WriteLine("Assez-Bien")
Else
Console.WriteLine("Bien")
End If
End If
End If

Remarque :
Dans le deuxième If on n’a pas besoin de mettre la condition comme suit :
Moyenne_Generale >= 10 And Moyenne_Generale < 12, car on est déjà dans la
clause de Else du 1er If Moyenne_Generale < 10, ce qui veut dire que dans cet
Else, Moyene_Generale est déjà supérieure ou égale à 10.
Visual Basic .NET offre une autre alternative au code précédent qui n’a de rôle que
pour améliorer la lisibilité du code. Il s’agit du code suivant :

32
 Code
If Moyenne_Generale < 10 Then
Console.WriteLine("Echoué")
ElseIf Moyenne_Generale < 12 Then
Console.WriteLine("Passable")
ElseIf Moyenne_Generale < 14 Then
Console.WriteLine("Assez-Bien")
Else
Console.WriteLine("Bien")
End If

4- Structures à choix multiples

Cette structure vient améliorer grandement la lisibilité du code quand il s’agit de tester
si une variable ou une expression vaut une valeur dans un ensemble de valeurs. Ici,
toutes les conditions doivent être de la forme : variable = valeur (resp. expression =
valeur), avec valeur qui change pour chaque test et non pas variable (resp. expression).
Par exemple, dans un menu de jeu, on a demandé à l’utilisateur de choisir le niveau
de jeu souhaité ou de quitter l’application.

La valeur entrée par l’utilisateur est enregistré dans une variable de type Byte appelée
choix grâce à l’instruction : choix = Console.readline()
Maintenant pour effectuer le test sur cette valeur pour lancer le jeu en mode Débutant,
Intermédiaire ou Avancé ou même pour quitter l’application, on peut utiliser les
structures sélectives imbriquées comme suit :

33
 Code
If choix = 1 Then
lancer_jeu_debutant()
Else
If choix = 2 Then
lancer_jeu_intermediaire()
Else
If choix = 3 Then
lancer_jeu_avance()
Else
If choix = 4 Then
End
Else
Console.WriteLine("Choix non valide!!")
End If
End If
End If
End If
Ou bien:
Code
If choix = 1 Then
lancer_jeu_debutant()
ElseIf choix = 2 Then
lancer_jeu_intermediaire()
ElseIf choix = 3 Then
lancer_jeu_avance()
ElseIf choix = 4 Then
End
Else
Console.WriteLine("Choix non valide!!")
End If

Pour ce genre de structure, Visual Basic .NET propose une nouvelle structure appelée
à choix multiple. Le code précédent peut être écrit comme suit :
Code
Select Case choix
Case 1
lancer_jeu_debutant()
Case 2
lancer_jeu_intermediaire()
Case 3
lancer_jeu_avance()
Case 4
End
Case Else
Console.WriteLine("Choix non valide!!")
End Select

34
Exercice 2.5
Ecrire un programme VB .NET en mode console qui lit deux entiers puis les affiche
dans l’ordre croissant.
Exercice 2.6
Ecrire un programme VB .NET qui affiche, selon un numéro entré par l’utilisateur
compris entre 1 et 7, le jour de la semaine correspondant (1 étant Samedi).

35
Chapitre 3

Structures répétitives

Les structures répétitives (ou boucles) nous permettent de gagner énormément de

temps en éliminant les répétitions. Imaginez que vous avez à exécuter une certaine
instruction (ou un bloc d’instructions) un certain nombre de fois, disons 20 fois, alors
au lieu de taper cette instruction (ou ce bloc d’instructions) 20 fois, les structures
répétitives nous permettent de la taper une seule fois en indiquant le nombre de fois
que l’ordinateur doit l’exécuter.
Visual Basic .NET proposent quatre types de structures répétitives, il s’agit de :
While...End While Do...Loop For...Next For Each...Next

I - La boucle While
Cette structure permet de répéter l’exécution d’une instruction (ou un bloc
d’instructions) tant qu’une condition est remplie (Tant que : en anglais, While).
Nous avons déjà vu l’exemple de programme de jeu proposant un menu (Débutant,
Intermédiaire, Avancé et Quitter).
Le code que nous avons utilisé était comme suit :

Code
Select Case choix
Case 1
lancer_jeu_debutant()
Case 2
lancer_jeu_intermediaire()
Case 3
lancer_jeu_avance()
Case 4
End
Case Else
Console.WriteLine("Choix non valide!!")
End Select

36
Si l’utilisateur répond à la demande « Entrez votre choix : » par un nombre autre que
1, 2, 3 et 4 ; alors le programme va lui afficher le message : Choix non valide!! et c’est
terminé. Mais ce que nous voulons réellement est que, lorsque l’utilisateur n’entre pas
une donnée valide, on lui réaffiche le menu précédent après avoir indiqué ce message
d’erreur. Alors on va tout d’abord afficher le menu et demander à l’utilisateur d’entrer
son choix. Si le choix n’est pas valide (c’est-à-dire autre que 1, 2, 3 et 4) alors on affiche
le message : Choix non valide!!, puis on réaffiche le menu précédent et on redemande
à l’utilisateur d’entrer son choix. Et si cette fois-ci encore l’utilisateur se trompe dans
son entrée, alors on refait le même traitement, et ainsi de suite. On affiche le menu, on
demande l’entrée, si l’entrée n’est pas valide, on affiche le message d’erreur et réaffiche
le menu, et ainsi de suite. Tout ce traitement va se répéter TANT QUE l’utilisateur n’a
pas encore entré un nombre valide (soit 1, 2, 3 ou 4).
La syntaxe de la boucle While est comme suit :
Syntaxe
While condition
Instructions
End While
Les instructions mises entre « While condition » et « End While » vont s’exécuter tant que
la condition est remplie. Cette condition peut être n’importe quelle expression
booléenne. Pour notre programme, la condition est :
« choix <> 1 And choix <> 2 And choix <> 3 And choix <> 4 »
Alors, pour répondre à ce besoin, à savoir toujours afficher le menu jusqu’à ce que
l’utilisateur tape une réponse valide, on peut utiliser le code suivant :
Code
Console.Clear()
Console.WriteLine(vbCrLf & vbTab & "1 - Débutant")
Console.WriteLine(vbTab & "2 - Intermédiaire")
Console.WriteLine(vbTab & "3 - Avancé")
Console.WriteLine(vbTab & "4 - Quitter")
Console.WriteLine(vbCrLf & vbTab & "Entrez votre choix: ")
choix = Console.ReadLine()

While choix <> 1 And choix <> 2 And choix <> 3 And choix <> 4
Console.WriteLine("Choix non valide!!")
Console.ReadLine()
Console.Clear()
Console.WriteLine(vbCrLf & vbTab & "1 - Débutant")
Console.WriteLine(vbTab & "2 - Intermédiaire")
Console.WriteLine(vbTab & "3 - Avancé")
Console.WriteLine(vbTab & "4 - Quitter")
Console.WriteLine(vbCrLf & vbTab & "Entrez votre choix: ")
choix = Console.ReadLine()
End While
L’instruction Console.Clear() permet d’effacer l’écran.

37
Essayons de voir un autre aspect de l’utilisation de la boucle While. Supposons qu’on
veut calculer le factoriel d’un nombre entier positif saisi par l’utilisateur.
On rappelle que le calcul de factoriel de n se fait comme suit :
n! = n * (n – 1) * (n – 2) * (n – 3) * . . . . . . . . . . * 3 * 2 * 1
Donc il s’agit de multiplier la valeur entrée par l’utilisateur, soit n, par n -1, puis
multiplier le résultat par n-2, et ainsi de suite jusqu’à ce qu’on arrive à 1.
On peut coder ceci en Visual Basic .NET comme suit :
Code
Module Module1

Sub Main()
Dim n, i As Byte
Dim fact As ULong = 1

Console.Clear()
Console.WriteLine("Bienvenue dans ce programme qui calcule le
factoriel...")
Console.ReadLine()
Console.Write("Entrez un nombre entier positif < 21: ")
n = Console.ReadLine()
i = 1
While i <= n
fact = fact * i
i = i + 1
End While
Console.WriteLine("Le factoriel de " & n & " est: " & fact)
Console.ReadLine()
End Sub

End Module
On a demandé à l’utilisateur d’entrer un nombre entier positif < 21 car le plus grand
nombre dont on peut calculer le factoriel est 20, si on essaye avec ce code de calculer
le factoriel de 21, ça va générer une erreur lors de l’exécution.
On a initialisé la variable i par 1, et on a demandé à l’ordinateur de tester si i ≤ n. Si
cette condition est remplie, on rentre dans la boucle pour exécuter les deux instructions
dedans. Une fois les deux instructions exécutées, on refait le test pour voir si la
condition est toujours remplie. Une fois on trouve que la condition n’est plus remplie,
c.à.d. que i > n, on sort de la boucle.
Si on n’oublie de mettre la deuxième instruction (i = i + 1), alors le programme va
simplement multiplier 1 par 1 et attribuer le résultat à la variable fact d’une manière
infinie.
La condition est parfois appelée « test d’arrêt », car c’est elle qui permet de ne pas
exécuter les instructions de la boucle « infiniment ».

38
II - La boucle Do
Il existe quatre variantes de la boucle Do.
Syntaxe
Do While condition
Instructions
Loop
Do Until condition
Instructions
Loop
Do
Instructions
Loop While condition
Do
Instructions
Loop Until condition

1- Première forme
Do While condition
Instructions
Loop
La première forme est équivalente à la boucle While … End While qu’on a vu
précédemment. Lo mot-clé Loop veut dire faire une boucle.

2- Deuxième forme
Analysons maintenant la deuxième forme, à savoir :
Do Until condition
Instructions
Loop
Until veut dire jusqu’à ; donc le programme va tourner et répéter l’exécution des
instructions de la boucle JUSQU’à ce que la condition soit remplie. Donc ici la
condition doit être la négation de celle mise dans la boucle While … End While.

3- Troisième forme
Do
Instructions
Loop While condition

Ce qui change ici par rapport à la 1ère forme de la boucle Do, à savoir
Do While condition
Instructions
Loop
C’est que la condition est mise à la fin de la boucle, c.-à-d. qu’on exécute d’abord les
instructions puis on teste la condition. Onc, les instructions de la boucle sont exécutées
au moins une fois. Parfois on a besoin de ce genre de structures sous cette forme,
comme par exemple le cas du menu du jeu. On a vu qu’on a dû taper les instructions
qui affichent le menu deux fois, une fois avant d’entrer dans la boucle While … End
While et une deuxième fois dans cette boucle. Avec cette forme de la boucle Do, on ne

39
tape ces instructions qu’une seule fois car on est sûr qu’elles vont s’exécuter au moins
une fois, et garantir ainsi l’affichage du menu.

4- Quatrième forme
Do
Instructions
Loop Until condition
C’est pareil à la 3ème forme, sauf qu’il faut mette la négation de la condition (Until étant
le contraire de While).

5- Exemples
Essayons de réaliser le programme qui calcule le factoriel avec ces différentes formes
de la boucle Do.

1ère forme
fact = 1
i = 1
Do While i <= n
fact = fact * i
i = i + 1
Loop

2ème forme
fact = 1
i = 1
Do Until i > n
fact = fact * i
i = i + 1
Loop

3ème forme
fact = 1
i = 1
Do
fact = fact * i
i = i + 1
Loop While i <= n

4ème forme
fact = 1
i = 1
Do
fact = fact * i
i = i + 1
Loop Until i > n

40
III - La boucle For
La boucle For est peut-être la boucle la plus utilisée. On l’utilise généralement quand
le nombre d’itérations est connu au préalable. Sa syntaxe est comme suit :

Syntaxe
For compteur As type_de_donnée = debut To fin Step pas
Instructions
Next compteur

compteur est une variable qui sert à compter le nombre d’itérations de la boucle. On
peut ne pas préciser son type, dans ce cas elle sera de type Integer.
debut est la valeur de départ de la variable compteur.
fin est la valeur finale de la variable compteur.
pas est la valeur d’incrémentation (si pas est positif) ou de décrémentation (si pas est
négatif) de la variable compteur.
Step pas est facultatif, s’il est omis, alors la valeur d’incrémentation est prise égale à 1.
compteur qui vient à la fin après le mot-clé Next est facultatif.
D’où la syntaxe réduite suivante :

Syntaxe
For compteur = debut To fin
Instructions
Next
Par exemple, le code permettant de calculer le factoriel avec la boucle For peut être
donné comme suit :

Code
Module Module1

Sub Main()
Dim n As Byte
Dim fact As ULong = 1

Console.Clear()
Console.WriteLine("Bienvenue dans ce programme qui calcule le
factoriel...")
Console.ReadLine()
Console.Write("Entrez un nombre entier positif < 21: ")
n = Console.ReadLine()

For i = 1 To n
fact = fact * i
Next

41
 Console.WriteLine("Le factoriel de " & n & " est: " & fact)
Console.ReadLine()
End Sub

End Module

IV - La boucle For Each

La boucle For Each permet de répéter l’exécution d’un bloc d’instructions non pas un
certain nombre de fois comme le fait la boucle For, mais elle permet de répéter son
exécution pour chaque élément d’une liste. On l’utilise avec les contrôles Listbox et
DataGridView qu’on verra inchaa Allah plus loin dans ce cours. Sa syntaxe est comme
suit :

Syntaxe
For Each element As type_de_donnée In group
Instructions
Next element
Par exemple:

Code
Dim group() As Integer = {5, 9, 2, -4}

For Each element As Integer In group

Console.Write(vbTab & element)
Next element

Console.WriteLine(vbCrLf)

Ce code affichera : 5 9 2 -4

V - Continue et Exit
Pour toutes les boucles qu’on a vues (For, For Each, While et Do), si on veut à un certain
moment passer à l’itération suivante sans exécuter les instructions restantes, on utilise
l’instruction Continue :

Boucle For Boucle For Each Boucle While Boucle Do

Continue For Continue For Continue While Continue Do

Si on veut arrêter l’exécution de toute la boucle et passer au code qui suit la fin de la
boucle, on utilise l’instruction Exit :

Boucle For Boucle For Each Boucle While Boucle Do

Exit For Exit For Exit While Exit Do

42
Chapitre 4

Des types de variables plus complexes

Jusqu’à maintenant on a travaillé avec plusieurs types de variables, des entiers, des
réels, des caractères, etc. Les variables de l’un de ces types sont dites variables de type
primitif ou simple, on parle aussi de variables scalaires. Outre ces types, Visual Basic
.NET nous permet de déclarer des variables avec d’autres types plus complexes qui
faciliteront grandement notre développement d’applications. Il s’agit des tableaux,
structures et énumérations.

I- Les tableaux
1- Introduction
Un tableau est une variable contenant simultanément plusieurs valeurs de même type
qui sont liée de manière logique. Par exemple, les moyennes générales des étudiants
de la classe DSI1. Toutes ces valeurs, en nombre de 30 pour les trente étudiants, sont
de même type, Single. Elles sont liées de manière logique, puisqu’elles représentent la
même notion, moyenne générale. Chacune de ces valeurs est variable, car elle peut
changer à chaque exécution du programme et elle n’est pas connue au préalable. Pour
représenter toutes ces valeurs dans un programme, il va nous falloir déclarer trente
variables de type Single. Par exemple :
Dim MG1, MG2, MG3, MG4, MG5, MG6, MG7, MG8, MG9, …… As Single
ce qui n’est pas pratique.
Avec les tableaux, on peut déclarer une seule variable qu’on peut nommer MG en
précisant le type Single et le nombre de valeurs que cette variable peut contenir
simultanément, soit 30. L’accès à chaque valeur se fait via le nom de la variable, suivi
de l’indice (ou index) de cette valeur entre parenthèses. L’indice de la première valeur
est 0. Donc pour un tableau de 30 valeurs, l’indice de la dernière valeur est 29.
Syntaxe
Dim nom_du_tableau(plus_grand_indice) As type_de_données

Par exemple :
Code
Dim MG(29) As Single

On a déjà vu qu’une variable est un emplacement dans la mémoire de l’ordinateur (la

RAM) qui porte un nom qui l’identifie, et qui sert à stocker une valeur d’un certain
type. Selon ce type de donnée, s’identifie la taille de cet emplacement ; pour le type de
donnée Byte, la variable occupe dans la RAM un emplacement d’un octet, pour le type
Integer, quatre octets, pour le type Char, deux octets, et ainsi de suite. Ceci concerne

43
une variable de type simple. Pour le cas des tableaux, la variable va occuper un
emplacement dans la mémoire dont la taille est le nombre d’octets nécessaires pour le
type choisi multiplié par le nombre de valeurs à stocker simultanément. Par exemple,
notre tableau MG de 30 valeurs de type Single va occuper dans la mémoire un
emplacement de taille = 30 * 4 octets, soit 120 octets.
Le tableau MG
0 1 2 …… …… ….. ….. 27 28 29
12.75 17.34 9.5 ….. ….. ….. ….. 11.86 10.22 12.54

2- Déclaration et redimensionnement
Si, au moment de la déclaration, on ne connaît pas le nombre de cases que va contenir
le tableau, on peut ne pas le préciser. Pour ce faire, il faut utiliser l’une des deux
syntaxes suivantes :
Syntaxe
Dim nom_du_tableau As type_de_données()

Ou bien :
Syntaxe
Dim nom_du_tableau() As type_de_données

Qu’on utilise l’une ou l’autre des deux instructions, il faut dans le programme préciser
la taille du tableau de manière dynamique avec l’instruction Redim.
Syntaxe
ReDim nom_du_tableau(plus_grand_indice)

Par exemple :
Code
Dim MG As Single()
ReDim MG(29)
Ou bien :
Code
Dim MG() As Single
ReDim MG(29)
Ici, on a déclaré un tableau appelé MG qui contiendra des valeurs de type Single, puis
on a précisé que sa taille est 30 (car 29 représente le dernier indice, et le premier est à
0).
L’instruction Redim sert à définir la taille d’un tableau dont on n’a pas précisé la taille
lors de sa déclaration ou de changer sa taille si elle est déjà définie.
Syntaxe
ReDim nom_du_tableau(nouveau_plus_grand_indice)

Ou bien :
Syntaxe
ReDim Preserve nom_du_tableau(nouveau_plus_grand_indice)

44
Le modificateur Preserve est utilisé pour conserver les données du tableau ; s’il n’est
pas utilisé, les anciennes valeurs seront perdues.
Pour obtenir la taille du tableau à n’importe quel moment, on utilise la fonction
Legnth(). Par exemple, l’instruction :

Code
Console.WriteLine(MG.Length())

Retourne la valeur 30 qui représente le nombre d’éléments et non pas le dernier indice.

3- Remplissage des valeurs d’un tableau

Pour renseigner les valeurs d’un tableau, on utilise son nom suivi de l’indice entre
parenthèses. Par exemple, si le 1er étudiant a eu la moyenne générale 12.75 et le 5ème
8.46, on peut renseigner ceci comme suit :
Code
MG(0) = 12.75
MG(4) = 8.46

Si on veut que l’utilisateur nous renseigne ces valeurs, on peut utiliser les boucles. Par
exemple :
Code
For i As Integer = 0 To 29
Console.WriteLine("Entrer l'élément n° " & i + 1 & " : ")
MG(i) = Console.ReadLine()
Next
Ou bien :
Code
For i As Integer = 0 To MG.Length - 1
Console.WriteLine("Entrer l'élément n° " & i + 1 & " : ")
MG(i) = Console.ReadLine()
Next

On peut aussi initialiser le tableau dès sa déclaration, on parle alors de tableau littéral.
Un tableau littéral se compose d'une liste de valeurs séparées par des virgules et
placées entre accolades {}. Quand on crée un tableau littéral, on peut ne pas indiquer
son type, et c’est le compilateur qui essayera d’en déterminer à l’aide des valeurs mises
entre accolades, c’est ce qu’on appelle l’inférence de type1. Par exemple :
Code
Dim nbresEntiers = New Integer() {1, 2, 4, 8}
Dim nbresReels = New Single() {1.5, 2, 9.9, 18}

1
L'inférence de types est un mécanisme qui permet à un compilateur ou un interpréteur de rechercher
automatiquement les types associés à des expressions, sans qu'ils soient indiqués explicitement dans le code
source. (d’après wikipedia)

45
Ou bien :
Code
Dim nbresEntiers As Integer() = {1, 2, 4, 8}
Dim nbresReels() As Single = {1.5, 2, 9.9, 18}

Ou bien :
Code
Dim nbresEntiers = {1, 2, 4, 8}
Dim nbresReels = {1.5, 2, 9.9, 18}
Dans le troisième cas, c’est le compilateur qui déterminera que le 1er tableau
nbresEntiers est de type Integer et le 2ème tableau nbresReels est de type Double ! Donc,
il vaut mieux indiquer le type explicitement.

4- Tableaux multidimensionnels
Un tableau multidimensionnel est un tableau à plusieurs dimensions. Les tableaux
qu’on a vus jusqu’à présent sont des tableaux à une dimension :

Un tableau à une dimension contenant 8 cases

Les tableaux à deux dimensions contiennent des lignes et des colonnes :

Un tableau à deux dimensions contenant 3 lignes et 5 colonnes

Les tableaux à trois dimensions contiennent en plus des lignes et des colonnes une
autre dimension. On peut schématiser un tableau à trois dimensions comme étant un
ensemble de tableaux à deux dimensions chacun mis dans une page d’un livre, l’indice
de la page constitue la troisième dimension :

Un tableau à trois dimensions contenant 4 éléments (4 pages) chacun contenant un

tableau à deux dimensions de 3 lignes et 5 colonnes

Dans la plupart des cas, on n’aura besoin que des tableaux à deux dimensions.

46
Pour illustrer la déclaration et l’utilisation des tableaux à deux dimensions, supposons
que notre tableau à deux dimensions comportant 3 lignes et 5 colonnes, soit 3 * 5 = 15
cases, est de type String :
Code
Dim monTableau(2, 4) As String
monTableau(0, 0) = "Janvier"
monTableau(0, 1) = "Février "
monTableau(0, 2) = "Mars"
monTableau(0, 3) = "Avril"
monTableau(0, 4) = "Mai"
monTableau(1, 0) = "January"
monTableau(1, 1) = "February"
monTableau(1, 2) = "March"
monTableau(1, 3) = "April"
monTableau(1, 4) = "May"
monTableau(2, 0) = "Enero"
monTableau(2, 1) = "Febrero "
monTableau(2, 2) = "Marzo"
monTableau(2, 3) = "Abril"
monTableau(2, 4) = "Mayo"

Console.WriteLine(vbCrLf)
For i As Integer = 0 To 2
For j As Integer = 0 To 4
Console.Write(vbTab & monTableau(i, j))
Next
Console.WriteLine()
Next
Console.ReadLine()
L’exécution de ce code donne le résultat suivant :

II - Les structures
On a vu que les tableaux permettent de stocker plusieurs données de même type.
Quant aux structures (appelées aussi enregistrements), elles permettent de stocker
plusieurs données mais pas forcément de même type. Par exemple si on veut
manipuler les informations des étudiants de DSI1, à savoir le nom, le prénom et l’âge,
on va créer une structure qui regroupera ces trois différentes données. Par la suite on

47
peut créer un tableau à une seule dimension de taille 30 ayant comme type cette
structure récemment créée.
Code
Module Module1
Public Structure Etudiant
Public nom As String
Public prenom As String
Public age As Byte
End Structure

Sub Main()

End Sub

End Module
La déclaration de la structure se fait en dehors de la procédure Main. Elle est délimitées
par les mots-clés Public Structure et End Structure. A l’intérieur de la procédure Main,
on peut créer des variables de type Etudiant comme si on crée des variables de type
primitif. On dit qu’on a défini notre propre type, à savoir le type Etudiant. Pour
accéder à chacun des éléments de la structure on utilise le nom de la variable suivi du
nom de l’élément, séparés par un point. Le code suivant :
Code
Sub Main()
Dim Etd1 As Etudiant
Etd1.nom = "Idrissi"
Etd1.prenom = "Said"
Etd1.age = 19
Console.WriteLine("L'étudiant " & Etd1.prenom & " " & Etd1.nom
& " a " & Etd1.age & " ans.")
Console.ReadLine()
End Sub
génère le résultat :

On peut aussi créer un tableau de structures et l’utiliser comme si on utilise un tableau

de type primitif. Par exemple :
Code
Dim Etd(29) As Etudiant

Etd(4).nom = "Rachidi"
Etd(4).prenom = "Khalid"
Etd(4).age = 25

48
Ce code crée un tableau à une dimension de type Etudiant comportant 30 cases. Ici on
a renseignées les informations du 5ème étudiant (indice 4).

III - Les énumérations

Les énumérations sont utilisées lorsqu’on veut représenter un ensemble de valeurs
constantes qui sont liées de manière logique. Par exemple, si on veut représenter les
niveaux d’un jeu on peut utiliser les énumérations. Au lieu de travailler avec des
constantes littérales 1, 2 et 3 qui ne sont pas si significatives, on peut les remplacer par
des noms significatifs. Puisqu’on ne peut pas avoir en même temps deux valeurs
différentes pour le niveau de jeu, au lieu d’utiliser trois constantes symboliques
différentes : DEBUTANT, INTERMEDIAIRE et AVANCE, on va utiliser une seule
énumération qui contiendra les trois éléments Debutant, Intermediaire et Avance.
On présente ci-après deux codes sources pour la gestion de jeu, l’un utilisant les
constantes littérales et l’autre l’énumération :
Code
Module Module1
Sub Main()
Dim choix As Byte
Do
Console.Clear()
Console.WriteLine(vbCrLf & vbTab & "1 - Débutant")
Console.WriteLine(vbTab & "2 - Intermédiaire")
Console.WriteLine(vbTab & "3 - Avancé")
Console.WriteLine(vbTab & "4 - Quitter")
Console.WriteLine(vbCrLf & vbTab & "Entrez votre choix: ")
choix = Console.ReadLine()
Loop While choix <> 1 And choix <> 2 And choix <> 3 And choix <> 4

Select Case choix

Case 1
lancer_jeu_debutant()
Case 2
lancer_jeu_intermediaire()
Case 3
lancer_jeu_avance()
Case 4
End
End Select

Console.ReadLine()
End Sub

End Module

49
 Code
Module Module1
Enum Niveau
Debutant = 1
Intermediaire = 2
Avance = 3
End Enum
Sub Main()
Dim choix As Niveau

Do
Console.Clear()
Console.WriteLine(vbCrLf & vbTab & "1 - Débutant")
Console.WriteLine(vbTab & "2 - Intermédiaire")
Console.WriteLine(vbTab & "3 - Avancé")
Console.WriteLine(vbTab & "4 - Quitter")
Console.WriteLine(vbCrLf & vbTab & "Entrez votre choix: ")
choix = Console.ReadLine()
Loop While choix <> 1 And choix <> 2 And choix <> 3 And choix <>
4
Select Case choix
Case Niveau.Debutant
lancer_jeu_debutant()
Case Niveau.Intermediaire
lancer_jeu_intermediaire()
Case Niveau.Avance
lancer_jeu_avance()
Case 4
End
End Select
Console.ReadLine()
End Sub

End Module

On peut ne pas indiquer les valeurs des éléments de l’énumération, dans ce cas, le 1 er
élément va prendre la valeur 0, le 2ème la valeur 1 et ainsi de suite.

50
Chapitre 5

Les sous-programmes

1- Notion de sous-programme
Jusqu’à maintenant, toutes les instructions qu’on a données à l’ordinateur étaient
mises dans la procédure Main, délimitées par les mots-clés Sub Main et End Sub. Au
lancement du programme, l’ordinateur commence par exécuter la première
instruction qui vient après Sub Main, puis la deuxième, et ainsi de suite jusqu’à ce qu’il
rencontre End Sub qui veut dire la fin du programme. L’exécution des instructions se
trouvant dans des boucles (For, While, Do) ou dans des clauses conditionnelles (If,
Else, Select Case) dépendra des conditions mentionnées.
Supposons maintenant qu’on veut réaliser un programme qui permet de calculer le
factoriel d’un nombre entier positif saisi par l’utilisateur, faire la somme de deux
nombres, puis calculer le factoriel d’un nouveau nombre. On peut résoudre ce
problème comme suit :
Code
Module Module1
Sub Main()
Dim n As Byte
Dim fact As ULong
Dim x, y, somme As Double
Console.Clear()
Console.WriteLine(vbCrLf & vbTab & vbTab & vbTab & "***** Calcul du
factoriel *****" & vbCrLf)
Console.Write("Entrez un nombre entier naturel < 21: ")
n = Console.ReadLine()
fact = 1
For i As Byte = 1 To n
fact = fact * i
Next
Console.WriteLine("Le factoriel de {0} est: {1}", n, fact)
Console.ReadLine()
Console.WriteLine(vbCrLf & vbTab & vbTab & vbTab & "***** Calcul de
la somme *****" & vbCrLf)
Console.Write("Entrez le premier nombre: ")
x = Console.ReadLine()
Console.Write("Entrez le deuxième nombre: ")
y = Console.ReadLine()
somme = x + y
Console.WriteLine("La somme de {0} et {1} est: {2}", x, y, somme)
Console.ReadLine()

51
 Console.WriteLine(vbCrLf & vbTab & vbTab & vbTab & "***** Calcul du
factoriel *****" & vbCrLf)
Console.Write("Entrez un nombre entier naturel < 21: ")
n = Console.ReadLine()
fact = 1
For i As Byte = 1 To n
fact = fact * i
Next
Console.WriteLine("Le factoriel de {0} est: {1}", n, fact)
Console.ReadLine()
End Sub
End Module
Le résultat obtenu est :

Comme on peut remarquer sur le code VB .NET, il y a une redondance de code

permettant de calculer le factoriel, et ce parce que le problème exige à ce qu’on calcule
le factoriel deux fois non successives. Si on voulait tout simplement calculer le factoriel
de deux nombres ou même 30 nombres, on pouvait utiliser les boucles et mettre le
code de calcul de factoriel une seule fois. Mais ici, on veut réutiliser ce code de calcul
de factoriel dans plusieurs endroits dans notre programme.
C’est ainsi que se propose cette notion de sous-programme en VB .NET qui permet
premièrement d’éviter cette redondance de code. Le principe est qu’on va regrouper
tout le code réalisant une tâche spécifique, et qui se répète dans le programme, dans
un bloc appelé sous-programme. Ce bloc sera représenté par un nom qui permet de
l’identifier, et à chaque fois qu’on a besoin de ce code, il suffira de l’appeler en mettant
son nom.

52
 Code
Module Module1

Sub Main()
Dim n As Byte
Dim x, y, somme As Double

Console.Clear()
Console.WriteLine(vbCrLf & vbTab & vbTab & vbTab & "***** Calcul du
factoriel *****" & vbCrLf)
Console.Write("Entrez un nombre entier naturel < 21: ")
n = Console.ReadLine()
Console.WriteLine("Le factoriel de {0} est: {1}", n, factoriel(n))
Console.ReadLine()

Console.WriteLine(vbCrLf & vbTab & vbTab & vbTab & "***** Calcul de
la somme *****" & vbCrLf)
Console.Write("Entrez le premier nombre: ")
x = Console.ReadLine()
Console.Write("Entrez le deuxième nombre: ")
y = Console.ReadLine()
somme = x + y
Console.WriteLine("La somme de {0} et {1} est: {2}", x, y, somme)
Console.ReadLine()

Console.WriteLine(vbCrLf & vbTab & vbTab & vbTab & "***** Calcul du
factoriel *****" & vbCrLf)
Console.Write("Entrez un nombre entier naturel < 21: ")
n = Console.ReadLine()
Console.WriteLine("Le factoriel de {0} est: {1}", n, factoriel(n))
Console.ReadLine()
End Sub

Function factoriel(ByVal n As Byte) As ULong

Dim fact As ULong = 1
For i As Byte = 1 To n
fact = fact * i
Next
Return fact
End Function
End Module

Pour le résultat, il n’y a pas de changement :

53
2- Fonctions et procédures
Comme on peut le voir dans le programme précédent, on a regroupé tout le code qui
permet de calculer le factoriel dans un bloc qu’on a appelé factoriel (on peut l’appeler
comme on veut à condition qu’on respecte les règles d’appellation des identificateurs),
et à chaque fois qu’on a besoin dans le programme de calculer le factoriel, il suffit
d’appeler ce bloc par son nom en indiquant entre parenthèses le nombre dont veut
calculer le factoriel.
Un autre avantage des sous-programmes est qu’ils sont prêts à les réutiliser dans
n’importe quel autre programme en faisant un copier-coller.
Le mot-clé qu’on a utilisé pour indiquer qu’il s’agit d’un sous-programme est Function
(fonction en français). En fait, les sous-programmes se présentent en deux types : les
fonctions et les procédures. Toutes les deux sont des blocs d’instructions qui
regroupent chacun un ensemble d’instructions qui font un certain traitement, à la
différence que les fonctions doivent retourner une valeur après avoir effectué le
traitement souhaité, d’où l’utilisation du mot-clé Return, tandis que les procédures ne
le font pas. Les fonctions se déclarent avec le mot-clé Function tandis que les
procédures se déclarent avec le mot-clé Sub. Visual Basic .NET appellent toutes les
deux procédures. On parle donc de procédure Function et de procédure Sub.
Supposons qu’on veut créer un sous-programme dont le rôle est seulement d’afficher
le menu d’un jeu. Ce sous-programme ne doit pas retourner une valeur au programme
principal (Sub Main), donc on parle de procédure. Par contre, si on veut réaliser un
sous-programme qui calcule le factoriel, ce sous-programme doit retourner au
programme principal la valeur calculée, à savoir le factoriel ; on parle donc de fonction.

3- Les paramètres
Qu’il s’agisse d’une procédure ou d’une fonction, le sous-programme peut avoir
besoin de données (variables) sur quoi il va agir, on parle de paramètres. Ces
paramètres sont déclarés entre deux parenthèses qui suivent le nom du sous-

54
programme. Si on veut que le sous-programme travaille sur une copie des valeurs de
ces paramètres, c.-à-d. que les variables passées comme paramètres gardent leurs
valeurs, on les déclare par le mot-clé ByVal2, on dit qu’on effectue un passage par
valeur. Par contre, si on veut que le sous-programme travaille directement sur les
variables, c.-à-d. que les modifications effectuées au sein du sous-programme affectent
directement les variables passées comme paramètres, on les déclare par le mot-clé
ByRef3, on dit qu’on effectue un passage par référence.

4- Déclaration des fonctions et des procédures

La forme la plus utilisée de la déclaration des fonctions et des procédures est comme
suit :
Pour les fonctions :
Syntaxe
Function nom_de_la_fonction(paramètres) As Tye_de_retour
instructions
Return valeur_à_retourner
End Function

Et pour les procédures :

Syntaxe
Sub nom_de_la_procédure(paramètres)
instructions
End Sub
Pour les fonctions, et pour retourner une valeur, on peut utiliser l’une des deux
syntaxes suivantes :
Return valeur_à_retourner
ou bien :
nom_de_la_fonction = valeur_à_retourner
La différence entre ces deux instructions est qu’avec Return, l’exécution de la fonction
s’arrête, c.-à-d. qu’on quitte immédiatement la fonction pour retourner la valeur ;
tandis qu’avec le nom de la fonction, on continue l’exécution des autres instructions
qui viennent après (s’il y en a) jusqu’à End Function, puis on retourne la valeur. Pour
quitter une fonction ou une procédure avant de terminer l’exécution de toutes les
instructions, on utilise l’instruction Exit Function pour les fonctions et Exit Sub pour les
procédures.
Quant aux paramètres, si on en a plusieurs, on les sépare par des virgules. Leurs
déclarations sont de la forme :
ByVal n As Byte
ByRef nom As String
ByVal x As Double, ByVal y As Double, ByRef z As Double
a As Integer
Si on n’a pas besoin de passer des paramètres aux sous-programmes, on laisse les
parenthèses vides.

2
ByVal vient de By Value qui veut dire en français : Par Valeur
3
ByRef vient de By Reference qui veut dire en français Par Référence

55
La syntaxe des fonctions diffère de celle des procédures du fait qu’elle requiert la
déclaration du type de retour comme on déclare le type d’une variable : As
Tye_de_retour et l’utilisation du mot-clé Return suivi de la valeur à retourner juste avant
la fin de la fonction (End Function).
Une bonne pratique de la programmation est qu’on essaye au maximum de regrouper
tous les traitements spécifiques dans des sous-programmes. Le programme principal
(sous-programme Main ou procédure Main) peut ne contenir que des appels aux sous-
programmes.
Par exemple :
Code
Module Module1

Sub Main()
While True
traitement(menu())
End While
End Sub

Function menu() As Byte

Dim choix As Byte
Do
Console.Clear()
Console.WriteLine(vbCrLf & vbTab & "1 - Débutant")
Console.WriteLine(vbTab & "2 - Intermédiaire")
Console.WriteLine(vbTab & "3 - Avancé")
Console.WriteLine(vbTab & "4 - Quitter")
Console.WriteLine(vbCrLf & vbTab & "Entrez votre choix: ")
choix = Console.ReadLine()
If ((choix <> 1) And (choix <> 2) And (choix <> 3) And
(choix <> 4)) Then
Console.WriteLine("Choix non valide. Appuyer sur Entrée pour
réessayer...")
Console.ReadLine()
End If
Loop Until (choix = 1) Or (choix = 2) Or (choix = 3) Or (choix = 4)
Return choix
End Function

Sub traitement(ByVal choix As Byte)

Select Case choix
Case 1
lancer_jeu_debutant()
Case 2
lancer_jeu_intermediaire()
Case 3
lancer_jeu_avance()

56
 Case 4
End
Case Else
Console.WriteLine("Choix non valide!!")
End Select
End Sub

Sub lancer_jeu_debutant()
'Traitement spécifique au niveau débutant du jeu
End Sub

Sub lancer_jeu_intermediaire()
'Traitement spécifique au niveau intermédiaire du jeu
End Sub

Sub lancer_jeu_avance()
'Traitement spécifique au niveau avancé du jeu
End Sub

End Module

57
Chapitre 5

Travailler avec les chaînes de caractères et les

dates

I- Les chaînes de caractères

5- Introduction
Le traitement des chaînes de caractères en VB .NET présente une panoplie de
fonctions. Après avoir présenté la déclaration des chaînes de caractères, on cite les
différentes fonctions qui les traitent.

g. Déclaration
Dim ch As String = "Bonjour tout le monde."

h. Les différentes fonctions traitant des chaînes de caractères

Asc, AscW Retourne une valeur de type Integer qui représente le code de caractère
correspondant à un caractère.

Chr, ChrW Retourne le caractère associé au code du caractère spécifié.

Filter Retourne un tableau de base zéro et contenant un sous-ensemble d'un tableau

de chaînes (String) basé sur des critères de filtre spécifiés.

Format Retourne une chaîne mise en forme conformément aux instructions contenues
dans une expression String de format.

FormatCurrency Retourne une expression sous forme de valeur monétaire utilisant le symbole
monétaire défini dans le Panneau de configuration du système.

FormatDateTime Retourne une expression de chaîne représentant une valeur de date/d'heure.

FormatNumber Retourne une expression sous forme de nombre.

FormatPercent Retourne une expression formatée sous forme de pourcentage (c'est-à-dire

multipliée par 100) avec un caractère de fin %.

InStr Retourne un entier spécifiant la position de début de la première occurrence

d'une chaîne à l'intérieur d'une autre.

InStrRev Retourne la position de la première occurrence d'une chaîne dans une autre, à
partir du côté droit de la chaîne.

58
Join Retourne une chaîne créée par la jonction de plusieurs sous-chaînes contenues
dans un tableau.

LCase Retourne une chaîne ou un caractère converti en lettres minuscules.

Left Retourne une chaîne contenant un nombre spécifié de caractères en partant de

la gauche d'une chaîne.

Len Retourne un entier contenant le nombre de caractères dans une chaîne.

LSet Retourne une chaîne alignée à gauche contenant la chaîne spécifiée ajustée à la
longueur spécifiée.

LTrim Retourne une chaîne contenant une copie d'une chaîne spécifiée sans espaces à
gauche.

Mid Retourne une chaîne contenant un nombre spécifié de caractères d'une chaîne.

Replace Retourne une chaîne dans laquelle une sous-chaîne spécifiée a été remplacée
par une autre sous-chaîne, un nombre de fois déterminé.

Right Retourne une chaîne contenant un nombre spécifié de caractères depuis la

partie droite d'une chaîne.

RSet Retourne une chaîne alignée à droite contenant la chaîne spécifiée ajustée à la
longueur spécifiée.

RTrim Retourne une chaîne contenant une copie d'une chaîne spécifiée sans espaces à
droite.

Space Retourne une chaîne composée d'un nombre spécifié d'espaces.

Split Retourne un tableau à une dimension de base zéro et contenant le nombre

spécifié de sous-chaînes.

StrComp Retourne -1, 0 ou 1, à partir du résultat d'une comparaison de chaînes.

StrConv Retourne une chaîne convertie comme spécifié.

StrDup Retourne une chaîne ou un objet constitué du caractère spécifié répété le

nombre de fois spécifié.

StrReverse Retourne une chaîne dans laquelle l'ordre des caractères d'une chaîne donnée a
été inversé.

Trim Retourne une chaîne contenant une copie d'une chaîne spécifiée sans espaces à
gauche ni à droite.

59
 UCase Retourne une chaîne ou un caractère contenant la chaîne spécifiée convertie en
majuscules.

6- Les fonctions Asc, AscW, Chr et ChrW – Conversion caractère->code

et code->caractère
a. Les syntaxes correspondantes :
Public Shared Function Asc ( Public Shared Function Asc (
caractere As Char chaine As String
) As Integer ) As Integer
Public Shared Function AscW ( Public Shared Function AscW (
caractere As Char chaine As String
) As Integer ) As Integer
Public Shared Function Chr (
CharCode As Integer
) As Char
Public Shared Function ChrW (
CharCode As Integer
) As Char
La fonction Asc retourne le code ASCII du caractère passé en paramètre. Si le
paramètre est une chaîne de caractères, alors la fonction Asc retourne le code ASCII
du premier caractère de la chaîne passée en paramètre.

La fonction AscW fait le même travail que la fonction Asc, sauf que la valeur retournée
est le code Unicode e no pas ASCII.

La fonctions Chr et ChrW sont les fonctions inverses des fonctions Asc et AscW. C.-à-
d. qu’elles retournent le caractère correspondant au nombre (compris entre 0 et 255,
pour le cas de Chr et entre -32768 et 65535, pour le cas de ChrW) passé en argument.

b. Exemples :
Instruction Valeur
Asc("B") 66
Asc("A"c) 65
Asc("Bonjour") 66
Asc("Au revoir les amis!!") 65
Asc(" ") 32
Asc("0") 48
Asc(vbCrLf) 13
Asc("") N’est pas valide

AscW("‫)"أ‬ 1571
AscW("‫"ب‬c) 1576
AscW("‫)"أدب‬ 1571
AscW("‫)"بديع‬ 1576
AscW(" ") 32
AscW("0") 48
AscW(vbCrLf) 13

60
 AscW("") N’est pas valide

Chr(68)) D
'Console.WriteLine(Chr(-68)) N’est pas valide
'Console.WriteLine(Chr(1571)) N’est pas valide
'Console.WriteLine(Chr(256)) N’est pas valide
'Console.WriteLine(Chr(-1)) N’est pas valide
ChrW(68) D
MsgBox(ChrW(-68))
'Pour illustrer la différence avec
le caractère E, utiliser : Un caractère spécial
MsgBox(ChrW(-68) & vbCrLf &
ChrW(69))
MsgBox(ChrW(1571)) ‫أ‬

7- La fonction Filter – Filtrer un tableau de chaînes de caractères

c. La syntaxe :
Public Shared Function Filter ( Public Shared Function Filter (
Source As Object(), Source As String(),
Match As String, Match As String,
Include As Boolean, Include As Boolean,
Compare As CompareMethod Compare As CompareMethod
) As String() ) As String()
Source : Le tableau de chaînes de caractères à filtrer

Match : La sous-chaîne de caractères à rechercher

Include : Paramètre booléen, s’il vaut True, la fonction retourne les chaînes de
caractères contenant la sous-chaîne, s’il vaut False, elle retourne les autres chaînes de
caractères (c.-à-d. ne contenant pas la sous-chaîne)

Compare : indique si la comparaison doit se faire en mode Text ou Binary.

d. Exemples :
Dim tableauDeChaines(3) As String
tableauDeChaines(0) = "20, rue Tahrane, qrt. Al Kassam Settat"
tableauDeChaines(1) = "Résidence Malak, Imm 365, Apprt. 9, qrt. Nassim, Casablanca"
tableauDeChaines(2) = "imm 25, apprt. 3, bd. 3 mars, settat maroc"
tableauDeChaines(3) = "Résidence Jaouhara, imm III, qrt. Nahda, Khouribga"

Dim tableauFiltre() As String

tableauFiltre = Filter(tableauDeChaines, "Settat", True, CompareMethod.Text)

Ce code produira le résultat suivant :
20, rue Tahrane, qrt. Al Kassam Settat
imm 25, apprt. 3, bd. 3 mars, settat maroc

tableauFiltre = Filter(tableauDeChaines, "Settat", True, CompareMethod.Binary)

Ce code produira le résultat suivant :
20, rue Tahrane, qrt. Al Kassam Settat

tableauFiltre = Filter(tableauDeChaines, "Settat", False, CompareMethod.Binary)

Ce code produira le résultat suivant :

61
 Résidence Malak, Imm 365, Apprt. 9, qrt. Nassim, Casablanca
imm 25, apprt. 3, bd. 3 mars, settat maroc
Résidence Jaouhara, imm III, qrt. Nahda, Khouribga

8- La fonction GetChar – Extraire un caractère

e. La syntaxe :
Public Shared Function GetChar (
str As String,
Index As Integer
) As Char
str : Est la chaîne de caractère en question

Index : L’indice de du caractère dans la chaîne qui doit être retourner. A noter que
Index ici représente la position et non pas l’indice du tableau.

f. Exemple :
Dim chaine As String = "Bonjour !"
Console.WriteLine("Le 1er caractère est : " & GetChar(chaine, 1))
Console.WriteLine("Le 2e caractère est : " & GetChar(chaine, 2))
Console.WriteLine("Le 9e caractère est : " & GetChar(chaine, 9))

Ce code donnera comme résultat :

Le 1er caractère est : B
Le 2e caractère est : o
Le 9e caractère est : !

62
9- La fonction InStr – Rechercher la première occurrence d’une sous-
chaîne
g. La syntaxe :
Public Shared Function InStr ( Public Shared Function InStr (
Start As Integer, String1 As String,
String1 As String, String2 As String,
String2 As String, Compare As CompareMethod
Compare As CompareMethod ) As Integer
) As Integer
Start : [Facultatif] Indique la position à partir de laquelle doit se faire la recherche. Le
1er caractère est à position 1 et non pas 0. Si ce paramètre est omis, alors c’est comme il
pris égal 1

String1 : La chaîne de caractère dans laquelle se fait la recherche

String2 : La sous-chaîne à rechercher

Compare : [Facultatif] Indique le type de comparaison

h. Exemple :
Dim chaine As String = "Bonjour tout le monde"
Dim sous_chaine As String = "On"
Dim position As Integer
Instruction Valeur
position = InStr(8, chaine, sous_chaine, CompareMethod.Text) 18
position = InStr(8, chaine, sous_chaine, CompareMethod.Binary) 0
position = InStr(1, chaine, sous_chaine, CompareMethod.Text) 2
position = InStr(chaine, sous_chaine) 0
position = InStr(chaine, sous_chaine, CompareMethod.Text) 2
position = InStr(1, chaine, "x") 0

10- La fonction InStrRev – Rechercher la première occurrence en

commençant de droite
i. La syntaxe :
Public Shared Function InStrRev (
StringCheck As String,
StringMatch As String,
Start As Integer,
Compare As CompareMethod
) As Integer
Start : [Facultatif] Indique la position à partir de laquelle doit se faire la recherche. Le
1er caractère est à position 1 et non pas 0. Start précise la position à partir de la gauche
puis la recherche commence de cette position vers la gauche. Si ce paramètre est omis,
alors la recherche commence à partir du dernier caractère

j. Suite de l’exemple précédent :

63
 Instruction Valeur
InStrRev(chaine, sous_chaine, 8, CompareMethod.Text) 2
InStrRev(chaine, sous_chaine, 8, CompareMethod.Binary) 0
InStrRev(chaine, sous_chaine, 1, CompareMethod.Text) 0
InStrRev(chaine, sous_chaine) 0
InStrRev(chaine, sous_chaine, , CompareMethod.Text) 18
InStrRev(chaine, "x", 1) 0

11- Les fonctions LCase et UCase – Convertir en lettres minuscules

ou majuscules
k. La syntaxe :
Public Shared Function LCase ( Public Shared Function LCase (
Value As Char Value As String
) As Char ) As String
Public Shared Function UCase ( Public Shared Function UCase (
Value As Char Value As String
) As Char ) As String

12- Les fonctions Left, Right, LSet, RSet et Mid – Extraire des sous-
chaînes
l. La syntaxe :
Public Shared Function Left ( Public Shared Function Right (
str As String, str As String,
Length As Integer Length As Integer
) As String ) As String
Public Shared Function LSet ( Public Shared Function RSet (
Source As String, Source As String,
Length As Integer Length As Integer
) As String ) As String
Public Shared Function Mid ( Public Shared Function Mid (
str As String, str As String,
Start As Integer Start As Integer,
) As String Length As Integer
) As String
Les fonctions LSet et RSet servent pour l’alignement.

Tous les paramètre sont obligatoires sauf pour la fonction Mid, où le paramètre Length
est facultatif. S’il est omis, on retourne tous les caractères à partir de la position Start
jusqu’à la fin de la chaîne.

m. Exemple :
Dim chaine As String = "Bonjour tout le monde!"
Dim sous_chaine As String
Instruction Valeur de sous_chaine
sous_chaine = Left(chaine, 4) Bonj

64
 sous_chaine = Left(chaine, 100) Bonjour tout le monde!
sous_chaine = Right(chaine, 4) nde!
sous_chaine = Right(chaine, 100) Bonjour tout le monde!

sous_chaine = LSet(chaine, 4) Bonj

sous_chaine = LSet(chaine, 100) Bonjour tout le monde!

sous_chaine = RSet(chaine, 4) Bonj

sous_chaine = RSet(chaine, 100)
Bonjour tout le monde!

sous_chaine = Mid(chaine, 9) tout le monde!

sous_chaine = Mid(chaine, 9, 4) tout

13- Les fonctions LTrim, RTrim et Trim – Supprimer les espaces à

l’extrémité
n. La syntaxe :
Public Shared Function LTrim | RTrim | Trim (
str As String
) As String
La fonction Trim supprime les espaces à gauche et à droite.

Question : Quel est l’équivalent de la fonction Trim ?

14- La fonction Space – Créer des chaînes contenant des espaces

o. La syntaxe :
Public Shared Function Space (
Number As Integer
) As String

p. Exemple :
Dim prenom, nom, chaine_vide As String
prenom = "Rachid"
nom = "Alami"
chaine_vide = Space(10)

Console.WriteLine(prenom & chaine_vide & nom)

Console.WriteLine(prenom & Space(5) & nom)

Ce code générera le résultat suivant :

Rachid Alami
Rachid Alami

15- La fonction StrComp – Comparer deux chaînes de caractères

q. La syntaxe :
Public Shared Function StrComp (
String1 As String,

65
 String2 As String,
Compare As CompareMethod
) As Integer
Cette fonction retourne -1, 0 ou 1 selon que String1 se situe avant String2 (ordre de tri
alphanumérique), les deux chaînes sont égales ou String1 se situe après String2.

r. Exemple :
Dim ch1, ch2, ch3, ch4, ch5, ch6 As String
ch1 = "Bonjour"
ch2 = "BONJOUR"
ch3 = "Bon"
ch4 = "a"
ch5 = "A"
ch6 = "1"

Instruction Résultat
StrComp(ch1, ch2) 1
StrComp(ch1, ch3) 1
StrComp(ch2, ch3) -1
StrComp(ch1, ch4) -1
StrComp(ch1, ch5) 1
StrComp(ch4, ch5) 1
StrComp(ch5, ch6) 1

StrComp(ch1, ch2, CompareMethod.Text) 0

StrComp(ch1, ch3, CompareMethod.Text) 1
StrComp(ch2, ch3, CompareMethod.Text) 1
StrComp(ch1, ch4, CompareMethod.Text) 1
StrComp(ch1, ch5, CompareMethod.Text) 1
StrComp(ch4, ch5, CompareMethod.Text) 0
StrComp(ch5, ch6, CompareMethod.Text) 1

16- La fonction StrConv – Convertir une chaîne de caractères

s. La syntaxe :
Public Shared Function StrConv (
str As String,
Conversion As VbStrConv,
LocaleID As Integer
) As String
Cette fonction s’utilise mieux avec les langues asiatiques.

Seul le paramètre LocalID est facultatif, s’il est omis, c’est la valeur du système qui est
prise. Quant au paramètre Conversion, il s’agit d’un membre de l’énumération
VbStrConv qui permet de spécifier le type de conversion à effectuer.

t. Exemple :
Dim chaine As String
chaine = "bonjour TOUT le mONde. je ""Vous"" souHAIte la bienvenue, A+"

Instruction Résultat

66
 StrConv(chaine, VbStrConv.Lowercase) bonjour tout le monde. je "vous" souhaite
la bienvenue, a+
StrConv(chaine, VbStrConv.Uppercase) BONJOUR TOUT LE MONDE. JE "VOUS" SOUHAITE
LA BIENVENUE, A+
StrConv(chaine, VbStrConv.None) bonjour TOUT le mONde. je "Vous" souHAIte
la bienvenue, A+
StrConv(chaine, VbStrConv.ProperCase) Bonjour Tout Le Monde. Je "Vous" Souhaite
La Bienvenue, A+
StrConv(chaine, VbStrConv.Lowercase, 6145) bonjour tout le monde. je "vous" souhaite
la bienvenue, a+

17- La fonction StrDup – Créer un chaîne en dupliquant des

caractères
u. La syntaxe :
Public Shared Function StrDup (
Number As Integer,
Character As Char
) As String
Public Shared Function StrDup (
Number As Integer,
Character As Object
) As Object
Public Shared Function StrDup (
Number As Integer,
Character As String
) As String

Cette fonction retourne un objet ou une chaîne de caractères contenant le caractère

passé en paramètre répété le nombre de fois spécifié (Number).

Character, qui est de type Char, Object ou String, doit avoir une valeur de type Char
ou String obligatoirement. Seul le premier caractère de Character (même dans le cas
de String) est pris pour le dupliquer dans la chaîne de caractères retournée.

v. Exemple :
Dim caractere As Char = "R"c
Dim chaine As String = "Bonjour tout le monde!"
Dim objet As Object = "Une chaîne de caratère"

Instruction Résultat
StrDup(5, caractere) RRRRR
StrDup(5, chaine) BBBBB
StrDup(5, objet) UUUUU

18- La fonction StrReverse – Renverser une chaîne de caractères

w. La syntaxe :
Public Shared Function StrReverse (
Expression As String

67
) As String

x. Exemple :
Dim chaine As String = "Bonjour tout le monde !"
Console.WriteLine(StrReverse(chaine))

Ce code générera le résultat suivant :

! ednom el tuot ruojnoB

19- La fonction Format

y. La syntaxe :
Public Shared Function Format (
Expression As Object,
Style As String
) As String

z. Formater les dates et heures

Formats de Date/Heure prédéfinis

Nom de Description
format

General Date Affiche une date et/ou une heure. Par exemple, 3/12/2008 11:07:31 AM.
ou G L'affichage de la date est déterminé par la valeur de la culture en cours de votre
système.

Long Date, Affiche une date en fonction du format de date longue de la culture actuelle. Par
Medium exemple, Wednesday, March 12, 2008.
Date ou D

Short Date Affiche une date en utilisant le format de date courte de la culture actuelle. Par
ou d exemple, 3/12/2008.
Le caractère d affiche le jour dans un format de date défini par l'utilisateur.

Long Time, Affiche une heure en utilisant le format d'heure longue de la culture actuelle ;
Medium comprend généralement les heures, minutes, secondes. Par exemple, 11:07:31
Time ou T AM.

Short Time Affiche une heure en utilisant le format d'heure courte de la culture actuelle. Par
ou t exemple, 11:07 AM.
Le caractère t affiche les valeurs AM ou PM pour les paramètres régionaux utilisant
une horloge de 12 heures dans un format horaire défini par l'utilisateur.

f Affiche la date longue et l'heure courte en fonction du format de la culture

actuelle. Par exemple, Wednesday, March 12, 2008 11:07 AM.

F Affiche la date longue et l'heure longue en fonction du format de la culture

actuelle. Par exemple, Wednesday, March 12, 2008 11:07:31 AM.

68
 g Affiche la date courte et l'heure courte en fonction du format de la culture en
cours. Par exemple, 3/12/2008 11:07 AM.

M, m Affiche le mois et le jour d'une date. Par exemple, March 12.

Le caractère M affiche le mois dans un format de date défini par l'utilisateur. Le
caractère m affiche les minutes dans un format horaire défini par l'utilisateur.

R, r Met en forme la date en fonction de la propriété RFC1123Pattern. Par

exemple, Wed, 12 Mar 2008 11:07:31 GMT. La date mise en forme n'ajuste pas
la valeur de l'horodatage. Vous devez définir la valeur d'horodatage GMT avant
d'appeler la fonction Format.

s Met en forme la date et l'heure sous la forme d'un index pouvant être trié. Par
exemple, 2008-03-12T11:07:31.
Le caractère s affiche les secondes dans un format horaire défini par l'utilisateur.

u Met en forme la date et l'heure sous la forme d'un index GMT pouvant être trié.
Par exemple, 2008-03-12 11:07:31Z.

U Met en forme la date et l'heure avec la date longue et l'heure longue en heure
GMT. Par exemple, Wednesday, March 12, 2008 6:07:31 PM.

Y, y Met en forme la date sous la forme année et mois. Par exemple, March, 2008.
Les caractères Y et y affichent l'année dans un format de date défini par
l'utilisateur.

Formats de Date/Heure définis par l’utilisateur

Caractère Description

(:) Séparateur d'heure. Dans certains paramètres régionaux, d'autres caractères peuvent
être utilisés pour représenter le séparateur d'heure. Le séparateur d'heure sépare les
heures, les minutes et les secondes lorsque les valeurs d'heure sont mises en forme. Le
caractère réel utilisé comme séparateur d'heure dans le résultat mis en forme est
déterminé par la valeur de la culture actuelle de votre application.

(/) Séparateur de date. Dans certains paramètres régionaux, d'autres caractères peuvent
être utilisés pour représenter le séparateur de date. Le séparateur de date sépare le
jour, le mois et l'année lorsque les valeurs de date sont mises en forme. Le caractère
réel utilisé comme séparateur de date dans le résultat mis en forme est déterminé par
la culture actuelle de votre application.

(%) Utilisé pour indiquer que le caractère suivant doit être lu comme un format d'une seule
lettre sans tenir compte des lettres de fin. Utilisé également pour indiquer qu'un format
d'une seule lettre est lu comme un format défini par l'utilisateur. Consultez ce qui suit
pour des détails supplémentaires.

69
d Affiche le jour sous la forme d'un nombre sans zéro non significatif (par exemple, 1).
Utilisez %d s'il s'agit du seul caractère dans le format numérique défini par l'utilisateur.

dd Affiche le jour sous la forme d'un nombre avec un zéro non significatif (par
exemple, 01).

ddd Affiche le jour sous la forme d'une abréviation (par exemple, Sun).

dddd Affiche le jour sous la forme d'un nom complet (par exemple, Sunday).

M Affiche le mois sous la forme d'un nombre sans zéro non significatif (par exemple,
janvier correspond à 1). Utilisez %M s'il s'agit du seul caractère dans le format
numérique défini par l'utilisateur.

MM Affiche le mois sous la forme d'un nombre avec un zéro non significatif (par
exemple, 01/12/01).

MMM Affiche le mois sous la forme d'une abréviation (par exemple, Jan).

MMMM Affiche le mois sous la forme d'un nom de mois complet (par exemple, January).

gg Affiche la chaîne de période/ère (par exemple, A.D.).

h Affiche l'heure sous la forme d'un nombre sans zéros non significatifs en utilisant
l'horloge au format 12 heures (par exemple,1:15:15 PM). Utilisez %h s'il s'agit du seul
caractère dans le format numérique défini par l'utilisateur.

hh Affiche l'heure sous la forme d'un nombre avec des zéros non significatifs en utilisant
l'horloge au format 12 heures (par exemple,01:15:15 PM).

H Affiche l'heure sous la forme d'un nombre sans zéros non significatifs en utilisant
l'horloge au format 24 heures (par exemple,1:15:15). Utilisez %H s'il s'agit du seul
caractère dans le format numérique défini par l'utilisateur.

HH Affiche l'heure sous la forme d'un nombre avec des zéros non significatifs en utilisant
l'horloge au format 24 heures (par exemple,01:15:15).

m Affiche les minutes sous la forme d'un nombre sans zéros non significatifs (par
exemple, 12:1:15). Utilisez %m s'il s'agit du seul caractère dans le format numérique
défini par l'utilisateur.

mm Affiche les minutes sous la forme d'un nombre avec des zéros non significatifs (par
exemple, 12:01:15).

s Affiche les secondes sous la forme d'un nombre sans zéros non significatifs (par
exemple, 12:15:5).Utilisez %s s'il s'agit du seul caractère dans le format numérique
défini par l'utilisateur.

70
 ss Affiche les secondes sous la forme d'un nombre avec des zéros non significatifs (par
exemple, 12:15:05).

f Affiche les fractions de secondes. Par exemple, ff affiche les centièmes de secondes,
tandis que ffff affiche les dizaines de milliers de secondes. Vous pouvez utiliser jusqu'à
7 symboles f dans un format défini par l'utilisateur. Utilisez %f s'il s'agit du seul
caractère dans le format numérique défini par l'utilisateur.

t Utilise l'horloge de 12 heures et affiche un A majuscule pour toute heure avant midi ;
affiche un P majuscule pour toute heure entre midi et 11:59. Utilisez %t s'il s'agit du
seul caractère dans le format numérique défini par l'utilisateur.

tt Pour les paramètres régionaux qui utilisent l'horloge au format 12 heures, affiche AM en
majuscules pour toutes les heures avant midi ; affiche PM en majuscules pour toutes les
heures entre midi et 11:59 P.M.
Pour les paramètres régionaux qui utilisent l'horloge au format 24 heures, n'affiche rien.

y Affiche l'année sous la forme d'un nombre (0-9) sans zéros non significatifs.
Utilisez %y s'il s'agit du seul caractère dans le format numérique défini par l'utilisateur.

yy Affiche l'année sous un format numérique à deux chiffres avec un zéro non significatif,
le cas échéant.

yyy Affiche l'année sous un format numérique à quatre chiffres.

yyyy Affiche l'année sous un format numérique à quatre chiffres.

z Affiche le décalage horaire sous la forme d'un nombre sans zéro non significatif (par
exemple, -8).Utilisez %z s'il s'agit du seul caractère dans le format numérique défini par
l'utilisateur.

zz Affiche le décalage horaire sous la forme d'un nombre avec un zéro non significatif (par
exemple, -08).

zzz Affiche le décalage horaire complet (par exemple, -08:00).

aa. Exemple :
Sub Main()
Dim x As DateTime = #07/25/2014 09:05:02#

Console.WriteLine(vbTab & vbTab & x)

Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""General Date""" & vbTab & Format(x, "General
Date"))
'Peu importe la casse de la chaîne "General Date"
Console.WriteLine("Format --> ""G""" & vbTab & vbTab & vbTab & Format(x, "G"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""Long Date""" & vbTab & vbTab & Format(x, "Long
Date"))
Console.WriteLine("Format --> ""Medium Date""" & vbTab & Format(x, "Medium
Date"))

71
 Console.WriteLine("Format --> ""D""" & vbTab & vbTab & vbTab & Format(x, "D"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""Short Date""" & vbTab & vbTab & Format(x, "Short
Date"))
Console.WriteLine("Format --> ""d""" & vbTab & vbTab & vbTab & Format(x, "d"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""Long Time""" & vbTab & vbTab & Format(x, "Long
Time"))
Console.WriteLine("Format --> ""Medium Time""" & vbTab & Format(x, "Medium
Time"))
Console.WriteLine("Format --> ""T""" & vbTab & vbTab & vbTab & Format(x, "T"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""Short Time""" & vbTab & vbTab & Format(x, "Short
Time"))
Console.WriteLine("Format --> ""t""" & vbTab & vbTab & vbTab & Format(x, "t"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""f""" & vbTab & vbTab & vbTab & Format(x, "f"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""F""" & vbTab & vbTab & vbTab & Format(x, "F"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""g""" & vbTab & vbTab & vbTab & Format(x, "g"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""M""" & vbTab & vbTab & vbTab & Format(x, "M"))
Console.WriteLine("Format --> ""m""" & vbTab & vbTab & vbTab & Format(x, "m"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""R""" & vbTab & vbTab & vbTab & Format(x, "R"))
Console.WriteLine("Format --> ""r""" & vbTab & vbTab & vbTab & Format(x, "r"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""s""" & vbTab & vbTab & vbTab & Format(x, "s"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""u""" & vbTab & vbTab & vbTab & Format(x, "u"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""U""" & vbTab & vbTab & vbTab & Format(x, "U"))
Console.WriteLine("*********************************************************")
Console.WriteLine("Format --> ""Y""" & vbTab & vbTab & vbTab & Format(x, "Y"))
Console.WriteLine("Format --> ""y""" & vbTab & vbTab & vbTab & Format(x, "y"))
Console.WriteLine("*********************************************************")

Console.ReadLine()
End Sub

Ce code génère le résultat suivant :

25/07/2014 09:05:02
***************************************************************************
Format --> "General Date" 25/07/2014 09:05:02
Format --> "G" 25/07/2014 09:05:02
***************************************************************************
Format --> "Long Date" vendredi 25 juillet 2014
Format --> "Medium Date" vendredi 25 juillet 2014
Format --> "D" vendredi 25 juillet 2014
***************************************************************************
Format --> "Short Date" 25/07/2014
Format --> "d" 25/07/2014
***************************************************************************
Format --> "Long Time" 09:05:02
Format --> "Medium Time" 09:05:02
Format --> "T" 09:05:02
***************************************************************************
Format --> "Short Time" 09:05
Format --> "t" 09:05

72
***************************************************************************
Format --> "f" vendredi 25 juillet 2014 09:05
***************************************************************************
Format --> "F" vendredi 25 juillet 2014 09:05:02
***************************************************************************
Format --> "g" 25/07/2014 09:05
***************************************************************************
Format --> "M" 25 juillet
Format --> "m" 25 juillet
***************************************************************************
Format --> "R" Fri, 25 Jul 2014 09:05:02 GMT
Format --> "r" Fri, 25 Jul 2014 09:05:02 GMT
***************************************************************************
Format --> "s" 2014-07-25T09:05:02
***************************************************************************
Format --> "u" 2014-07-25 09:05:02Z
***************************************************************************
Format --> "U" vendredi 25 juillet 2014 08:05:02
***************************************************************************
Format --> "Y" juillet 2014
Format --> "y" juillet 2014
***************************************************************************

Et le code suivant :
Sub Main()
Dim x As DateTime = #07/02/2008 19:05:02#

Console.WriteLine(vbTab & vbTab & x)

Console.WriteLine("************************************************************")
Console.WriteLine("Format --> ""d/M/y""" & vbTab & vbTab & Format(x, "d/M/y"))
Console.WriteLine("Format --> ""dd/M/y""" & vbTab & vbTab & Format(x,
"dd/M/y"))
Console.WriteLine("Format --> ""ddd/M/y""" & vbTab & vbTab & Format(x,
"ddd/M/y"))
Console.WriteLine("Format --> ""dddd/M/y""" & vbTab & vbTab & Format(x,
"dddd/M/y"))
Console.WriteLine("Format --> ""dddddddd/M/y""" & vbTab & Format(x,
"dddddddd/M/y"))

Console.WriteLine("************************************************************")
Console.WriteLine("Format --> ""ddd d/M/y""" & vbTab & vbTab & Format(x, "ddd
d/M/y"))
Console.WriteLine("Format --> ""dddd d/M/y""" & vbTab & vbTab & Format(x, "dddd
d/M/y"))

Console.WriteLine("************************************************************")
Console.WriteLine("Format --> ""d/M/y""" & vbTab & vbTab & Format(x, "d/M/y"))
Console.WriteLine("Format --> ""d/MM/y""" & vbTab & vbTab & Format(x,
"d/MM/y"))
Console.WriteLine("Format --> ""d/MMM/y""" & vbTab & vbTab & Format(x,
"d/MMM/y"))
Console.WriteLine("Format --> ""d/MMMM/y""" & vbTab & vbTab & Format(x,
"d/MMMM/y"))

Console.WriteLine("************************************************************")
Console.WriteLine("Format --> ""d/M/y""" & vbTab & vbTab & Format(x, "d/M/y"))
Console.WriteLine("Format --> ""d/M/yy""" & vbTab & vbTab & Format(x,
"d/M/yy"))

73
 Console.WriteLine("Format --> ""d/M/yyy""" & vbTab & vbTab & Format(x,
"d/M/yyy"))
Console.WriteLine("Format --> ""d/M/yyyy""" & vbTab & vbTab & Format(x,
"d/M/yyyy"))

Console.WriteLine("************************************************************")
Console.WriteLine("Format --> ""d/M/yyyy gg""" & vbTab & Format(x, "d/M/yyyy
gg"))

Console.WriteLine("************************************************************")
Console.WriteLine("Format --> ""h:m:s""" & vbTab & vbTab & Format(x, "h:m:s"))
Console.WriteLine("Format --> ""hh:mm:ss""" & vbTab & vbTab & Format(x,
"hh:mm:ss"))
Console.WriteLine("Format --> ""H:mm:ss""" & vbTab & vbTab & Format(x,
"H:mm:ss"))
Console.WriteLine("Format --> ""HH:mm:ss""" & vbTab & vbTab & Format(x,
"HH:mm:ss"))
Console.WriteLine("Format --> ""hh:mm:ss""" & vbTab & vbTab & Format(x,
"hh:mm:ss"))
Console.WriteLine("Format --> ""hh:mm:ss:f""" & vbTab & vbTab & Format(x,
"hh:mm:ss:f"))
Console.WriteLine("Format --> ""hh:mm:ss:ff""" & vbTab & Format(x,
"hh:mm:ss:ff"))
Console.WriteLine("Format --> ""hh:mm:ss:fff""" & vbTab & Format(x,
"hh:mm:ss:fff"))
Console.WriteLine("Format --> ""hh:mm:ss:fffffff""" & vbTab & Format(x,
"hh:mm:ss:fffffff"))

Console.WriteLine("************************************************************")
Console.WriteLine("Format --> ""HH:mm:ss t""" & vbTab & vbTab & Format(x,
"HH:mm:ss t"))
Console.WriteLine("Format --> ""HH:mm:ss tt""" & vbTab & Format(x, "HH:mm:ss
tt"))
Console.WriteLine("Format --> ""hh:mm:ss t""" & vbTab & vbTab & Format(x, "hh:mm:s
Console.WriteLine("Format --> ""hh:mm:ss tt""" & vbTab & Format(x, "hh:mm:ss tt"))

Console.WriteLine("************************************************************")
Console.WriteLine("Format --> ""HH:mm:ss z""" & vbTab & vbTab & Format(x,
"HH:mm:ss z"))
Console.WriteLine("Format --> ""HH:mm:ss zz""" & vbTab & Format(x, "HH:mm:ss
zz"))
Console.WriteLine("Format --> ""HH:mm:ss zzz""" & vbTab & Format(x, "HH:mm:ss
zzz"))

Console.WriteLine("************************************************************")

Console.ReadLine()
End Sub
Générera le résultat suivant :
02/07/2008 19:05:02
***************************************************************************
Format --> "d/M/y" 2/7/8
Format --> "dd/M/y" 02/7/8
Format --> "ddd/M/y" mer./7/8
Format --> "dddd/M/y" mercredi/7/8
Format --> "dddddddd/M/y" mercredi/7/8
***************************************************************************
Format --> "ddd d/M/y" mer. 2/7/8

74
Format --> "dddd d/M/y" mercredi 2/7/8
***************************************************************************
Format --> "d/M/y" 2/7/8
Format --> "d/MM/y" 2/07/8
Format --> "d/MMM/y" 2/juil./8
Format --> "d/MMMM/y" 2/juillet/8
***************************************************************************
Format --> "d/M/y" 2/7/8
Format --> "d/M/yy" 2/7/08
Format --> "d/M/yyy" 2/7/2008
Format --> "d/M/yyyy" 2/7/2008
***************************************************************************
Format --> "d/M/yyyy gg" 2/7/2008 ap. J.-C.
***************************************************************************
Format --> "h:m:s" 7:5:2
Format --> "hh:mm:ss" 07:05:02
Format --> "H:mm:ss" 19:05:02
Format --> "HH:mm:ss" 19:05:02
Format --> "hh:mm:ss" 07:05:02
Format --> "hh:mm:ss:f" 07:05:02:0
Format --> "hh:mm:ss:ff" 07:05:02:00
Format --> "hh:mm:ss:fff" 07:05:02:000
Format --> "hh:mm:ss:fffffff" 07:05:02:0000000
***************************************************************************
Format --> "HH:mm:ss t" 19:05:02 P
Format --> "HH:mm:ss tt" 19:05:02 PM
Format --> "hh:mm:ss t" 07:05:02 P
Format --> "hh:mm:ss tt" 07:05:02 PM
***************************************************************************
Format --> "HH:mm:ss z" 19:05:02 +1
Format --> "HH:mm:ss zz" 19:05:02 +01
Format --> "HH:mm:ss zzz" 19:05:02 +01:00
***************************************************************************

bb.Formater les nombres

Formats numériques prédéfinis

Nom de format Description

General Affiche le nombre sans séparateur de milliers.

Number, G Par exemple, Format(&H3FA, "g") retourne 1018.
ou g

75
Currency, C Affiche le nombre avec séparateur de milliers, le cas échéant ; affiche deux
ou c chiffres à droite du séparateur décimal. Le résultat est fonction des paramètres
régionaux du système.
Par exemple, Format(1234567, "c") retourne $1,234,567.00.

Fixed, F ou f Affiche au moins un chiffre à gauche et deux chiffres à droite du séparateur

décimal.
Par exemple, Format(1234567, "f") retourne 1234567.00.

Standard, N Affiche un nombre avec séparateur de milliers, au moins un chiffre à gauche et

ou n deux chiffres à droite du séparateur décimal.
Par exemple, Format(1234567, "n") retourne 1,234,567.00.

Percent Affiche le nombre multiplié par 100 avec un signe de pourcentage (%) ajouté
immédiatement à droite ; affiche toujours deux chiffres à droite du séparateur
décimal.
Par exemple, Format(0.4744, "Percent") retourne 47.44%.

P ou p Affiche un nombre avec un séparateur de milliers multiplié par 100 avec un signe
de pourcentage (%) ajouté à droite et séparé par un seul espace ; affiche
toujours deux chiffres à droite du séparateur décimal.
Par exemple, Format(0.80345, "p") retourne 80.35 %.

Scientific Utilise la notation scientifique standard, en fournissant deux chiffres significatifs.

Par exemple, Format(1234567, "Scientific") retourne 1.23E+06.

E ou e Utilise la notation scientifique standard, en fournissant six chiffres significatifs.

Par exemple, Format(1234567, "e") retourne 1.234567e+006.

D ou d Affiche le nombre sous forme de chaîne contenant la valeur du nombre au

format décimal (base 10). Cette option n'est prise en charge que pour les types
entiers (Byte, Short, Integer, Long).
Par exemple, Format(&H7F, "d") retourne 127.

X ou x Affiche le nombre sous forme de chaîne contenant la valeur du nombre au

format hexadécimal (base 16). Cette option n'est prise en charge que pour les
types entiers (Byte, Short, Integer, Long).
Par exemple, Format(127, "x") retourne 7f.

Yes/No Affiche No si le nombre est 0 ; sinon, affiche Yes.

Par exemple, Format(0, "Yes/No") retourne No.

True/False Affiche False si le nombre est 0 ; sinon, affiche True.

Par exemple, Format(1, "True/False") retourne True.

On/Off Affiche Off si le nombre est 0 ; sinon, affiche On.

Par exemple, Format(1, "On/Off") retourne On.

76
Formats numériques définis par l’utilisateur

Caractère Description

None Affiche le nombre sans mise en forme.

(0) Espace réservé à un chiffre. Affiche un chiffre ou un zéro. Affiche un chiffre si

l'expression a un chiffre dans la position où le zéro apparaît dans la chaîne de format ;
sinon, affiche un zéro dans cette position.
Si le nombre contient moins de chiffres que de zéros (de part et d'autre du séparateur
décimal) dans l'expression de format, affiche des zéros non significatifs ou à droite. Si le
nombre contient davantage de chiffres à droite du séparateur décimal qu'il n'y a de
zéros à droite du séparateur décimal dans l'expression de format, arrondit le nombre à
autant de positions décimales qu'il y a de zéros. Si le nombre contient davantage de
chiffres à gauche du séparateur décimal qu'il n'y a de zéros à gauche du séparateur
décimal dans l'expression de format, affiche les chiffres supplémentaires sans
modification.

Exemple :
Format(123.4, "00000.00")  00123,40
Format(123.4260423, "00.00")  123,43

(#) Espace réservé à un chiffre. Affiche un chiffre ou rien. Affiche un chiffre si l'expression a
un chiffre dans la position où le caractère # apparaît dans la chaîne de format ; sinon,
n'affiche rien dans cette position.
Ce symbole fonctionne comme l'espace réservé au 0, sauf que les zéros non
significatifs et à droite ne s'affichent pas si le nombre contient moins de chiffres qu'il
n'y a de caractères # de part et d'autre du séparateur décimal dans l'expression de
format.

(.) Espace réservé aux décimales. L'espace réservé à la décimale détermine le nombre de
chiffres affichés à gauche et à droite du séparateur décimal. Si l'expression de format
ne contient que des caractères # à gauche de ce symbole, les nombres inférieurs à 1
commencent par un séparateur décimal. Pour afficher un zéro non significatif avec des
nombres fractionnaires, utilisez zéro comme premier espace réservé à un chiffre à
gauche du séparateur décimal. Dans certains paramètres régionaux, une virgule est
utilisée comme séparateur décimal. Le caractère réel utilisé comme espace réservé à la
décimale dans le résultat mis en forme dépend du format de nombre reconnu par
votre système. Vous devriez donc utiliser le point comme espace réservé à la décimale
dans vos mises en forme, même si vos paramètres régionaux utilisent la virgule à cette
fin. La chaîne mise en forme apparaîtra dans le format correct pour les paramètres
régionaux.

(%) Espace réservé à un pourcentage. Multiplie l'expression par 100. Le caractère de

pourcentage (%) est inséré à l'emplacement où il apparaît dans la chaîne de format.

(,) Séparateur de milliers. Le séparateur de milliers sépare les milliers des centaines dans
un nombre qui possède quatre chiffres ou plus à gauche du séparateur décimal.

77
 L'utilisation standard du séparateur de milliers est spécifiée si le format contient un
séparateur de milliers entouré par des espaces réservés aux chiffres (0 ou #).
Un séparateur de milliers placé immédiatement à gauche du séparateur décimal
(qu'une décimale soit spécifiée ou non) ou en tant que caractère le plus à droite dans la
chaîne, signifie « mettre à l'échelle le nombre en le divisant par 1 000, en l'arrondissant
si nécessaire ». Les nombres plus petits que 1 000 mais supérieurs ou égaux à 500 sont
affichés comme 1, et les nombres plus petits que 500 sont affichés comme 0. Deux
séparateurs de milliers adjacents dans cette position ont pour facteur d'échelle
1 million et un facteur complémentaire de 1 000 pour chaque séparateur
supplémentaire.
Les séparateurs multiples dans n'importe quelle position autre que celle
immédiatement à gauche du séparateur décimal ou la position la plus à droite dans la
chaîne sont traités simplement comme le spécifie l'utilisation d'un séparateur de
milliers. Dans certains paramètres régionaux, un point est utilisé comme séparateur de
milliers. Le caractère réel utilisé comme séparateur de milliers dans le résultat mis en
forme dépend du format de nombre reconnu par votre système. Vous devriez donc
utiliser la virgule comme séparateur de milliers dans vos mises en forme, même si vos
paramètres régionaux utilisent le point à cette fin. La chaîne mise en forme apparaîtra
dans le format correct pour les paramètres régionaux.
Par exemple, considérez les trois chaînes de format suivantes :
 "#,0.", qui utilise le séparateur des milliers pour mettre en forme le nombre
100 millions comme chaîne "100 000 000".
 "#0,.", qui utilise un facteur d'échelle égal à mille pour mettre en forme le
nombre 100 millions comme chaîne "100000".
 "#,0,.", qui utilise le séparateur de milliers et un facteur d'échelle égal à mille
pour mettre en forme le nombre 100 millions comme chaîne "100 000".

(:) Séparateur d'heure. Dans certains paramètres régionaux, d'autres caractères peuvent
être utilisés pour représenter le séparateur d'heure. Le séparateur d'heure sépare les
heures, les minutes et les secondes lorsque les valeurs d'heure sont mises en forme. Le
caractère réel utilisé comme séparateur d'heure dans le résultat mis en forme est
déterminé par les paramètres de votre système.

(/) Séparateur de date. Dans certains paramètres régionaux, d'autres caractères peuvent
être utilisés pour représenter le séparateur de date. Le séparateur de date sépare le
jour, le mois et l'année lorsque les valeurs de date sont mises en forme. Le caractère
réel utilisé comme séparateur de date dans le résultat mis en forme est déterminé par
les paramètres de votre système.

(E-E+e- Format scientifique. Si l'expression de format contient au moins un espace réservé au

e+) chiffre (0 ou #) à gauche de E-, E+, e- ou e+, le nombre est affiché au format
scientifique et E ou e est inséré entre le nombre et son exposant. Le nombre d'espaces
réservés aux chiffres à gauche détermine le nombre de chiffres dans l'exposant.
Utilisez E- ou e- pour placer un signe moins à côté des exposants négatifs.
Utilisez E+ ou e+ pour placer un signe moins à côté des exposants négatifs et un signe
plus à côté des exposants positifs. Vous devez également inclure des espaces réservés
aux chiffres à droite de ce symbole pour obtenir une mise en forme correcte.

78
 -+$() Caractères littéraux. Ces caractères sont affichés exactement tels qu'ils sont tapés dans
la chaîne de format. Pour afficher un caractère autre que ceux répertoriés, faites-le
précéder d'une barre oblique inverse (\) ou placez-le entre guillemets (" ").

(\) Affiche le caractère suivant dans la chaîne de format. Pour afficher un caractère ayant
une signification spéciale en tant que caractère littéral, faites-le précéder d'une barre
oblique inverse (\). La barre oblique inverse elle-même n'est pas affichée. L'utilisation
d'une barre oblique inverse revient à placer le caractère suivant entre guillemets
SIMPLES. Pour afficher une barre oblique inverse, utilisez deux barres obliques inverses
(\\).
Parmi les caractères qui ne peuvent être affichés en tant que caractères littéraux, on
peut citer les caractères de mise en forme de date et d'heure
(a, c, d, h, m, n, p, q, s, t, w, y, / et :), les caractères de mise en forme numérique
(#, 0, %, E, e, virgule et point) et les caractères de mise en forme de chaînes
(@, &, <, > et !).

("ABC") Affiche la chaîne en la plaçant entre guillemets (" "). Pour inclure une chaîne dans
l'argument de style à partir du code, vous devez utiliser Chr(34) pour inclure le texte
(34 est le code de caractère pour un guillemet (")).

cc. Exemple :
Sub Main()
Console.WriteLine(Format(123.4, "00000.00"))
Console.WriteLine(Format(123.4260423, "00.00"))
Console.WriteLine("**************************************")
Console.WriteLine(Format(123.4, "000 000.00"))
Console.WriteLine(Format(123456789.4, "000 000.00"))
Console.WriteLine(Format(123.4, "000,000.00"))
Console.WriteLine(Format(123456789.4, "000,000.00"))
Console.WriteLine("**************************************")
Console.WriteLine(Format(123456.789, "0E00"))
Console.WriteLine(Format(123456.789, "0E+00"))
Console.WriteLine(Format(123456.789, "0e+00"))
Console.WriteLine(Format(123456.789, "0E-00"))
Console.WriteLine(Format(123456.789, "0e-00"))
Console.WriteLine("**************************************")
Console.WriteLine(Format(123456789.4, "#,."))
Console.WriteLine(Format(123456789.4, "#,"))
Console.WriteLine(Format(123456789.4, "#,,."))
Console.WriteLine(Format(123456789.4, "#,,"))
Console.WriteLine(Format(123456789.4, "#,#,#,#,#"))
Console.WriteLine(Format(123456789.4, "0,0,0,0,0"))
Console.WriteLine(Format(123456789.4, "0,,"))
Console.WriteLine(Format(123456789.4, "0,,,"))
Console.WriteLine(Format(123456789.4, "#,,,"))
Console.WriteLine(Format(123456789.4, "#,,,.######"))
Console.WriteLine("**************************************")
Console.WriteLine(Format(123.4, "#####.##"))
Console.WriteLine(Format(123.4260423, "##.##"))
Console.WriteLine("**************************************")
Console.WriteLine(Format(123.4260423, "+0.00$"))
Console.WriteLine(Format(123.4260423, "-0.00$"))
Console.WriteLine(Format(123.4260423, "+(0.00$)"))
Console.WriteLine("**************************************")
Console.WriteLine(Format(0.2, "###.## %"))
Console.WriteLine(Format(0.2, "###.##%"))

79
 Console.WriteLine(Format(0.2, "000.00 %"))
Console.WriteLine("**************************************")
Console.WriteLine(Format(System.DateTime.Now, ))
Console.WriteLine(Format(System.DateTime.Now, "dd / MM / yy HH : mm :
s"))
Console.WriteLine(Format(System.DateTime.Now, "M m "))
Console.WriteLine("**************************************")
Dim x As Date = #12/29/2015 15:20:03#
Console.WriteLine(x)
Console.WriteLine(Format(x, "dd/MM/yy HH:mm:s"))
Console.WriteLine(Format(x, "dd/MM/yy hh:mm:s"))
Console.WriteLine(Format(x, "dd/MM/yy h:mm:s"))
Console.WriteLine(Format(x, "dd / MM / yy HH : mm : s"))
Console.WriteLine(Format(x, "yyyyMMddHHmmss"))
Console.WriteLine("**************************************")
Console.WriteLine(Format(123.4260423, "0.00 dirhams"))
Console.WriteLine(Format(123.4, "0.00 DH"))
Console.WriteLine(Format(123.4, "#0.00 DH#"))
Console.WriteLine(Format(123.4, "\#0.00 DH\#"))
Console.WriteLine(Format(123.4, "'#'0.00 DH'#'"))
Console.WriteLine(Format(System.DateTime.Now, "d\d / M\M / yy HH : mm :
s"))
Console.WriteLine("**************************************")

Console.ReadLine()
End Sub

Ce code générera le résultat suivant :

00123,40
123,43
**************************************
000 123,40
123456 789,40
000 123,40
123 456 789,40
**************************************
1E05
1E+05
1e+05
1E05
1e05
**************************************
123457
123457
123
123
123 456 789
123 456 789
123
0

,123457
**************************************
123,4
123,43
**************************************
+123,43$
-123,43$
+(123,43$)
**************************************
20 %

80
20%
020,00 %
**************************************
30/11/2015 01:53:02
30 / 11 / 15 01 : 53 : 2
11 53
**************************************
29/12/2015 15:20:03
29/12/15 15:20:3
29/12/15 03:20:3
29/12/15 3:20:3
29 / 12 / 15 15 : 20 : 3
20151229152003
**************************************
123,43 dirhams
123,40 DH
123,40 DH
#123,40 DH#
#123,40 DH#
30d / 11M / 15 01 : 53 : 2
**************************************

20- La fonction FormatCurrency – formatage monétaire

dd.La syntaxe :
Public Shared Function FormatCurrency (
Expression As Object,
NumDigitsAfterDecimal As Integer,
IncludeLeadingDigit As TriState,
UseParensForNegativeNumbers As TriState,
GroupDigits As TriState
) As String
Seul le paramètre Expression est obligatoire. Il s’agit de la chaîne de caractères à
formater.

Le paramètre NumDigitsAfterDecimal est de type Integer. Il s’agit du nombre de

chiffres après le point décimal.

Les trois autres paramètres, à savoir, IncludeLeadingDigit,

UseParensForNegativeNumbers et GroupDigits sont de type TriState qui est une
énumération qui a comme membres False, True et UseDefault (qui signifie que les
paramètres régionaux seront appliqués).

IncludeLeadingDigit indique si le zéro non significatif (celui à gauche) doit s’afficher

ou non.

UseParensForNegativeNumbers indique si les valeurs négatives doivent être placées

entre parenthèses.

GroupDigits indique si les nombres doivent être regroupés en milliers ou non.

ee. Exemple :
Dim x As Decimal = -12345.6789
Instruction Résultat

81
 x -12345,6789
FormatCurrency(x) -12 345,68 .‫م‬.‫د‬
FormatCurrency(x, 3) -12 345,679 .‫م‬.‫د‬
FormatCurrency(x, 3, TriState.True) -12 345,679 .‫م‬.‫د‬
FormatCurrency(x, 3, TriState.False) -12 345,679 .‫م‬.‫د‬
FormatCurrency(x, 3, TriState.True, TriState.True) (12 345,679 .‫م‬.‫)د‬
FormatCurrency(x, 3, TriState.True, TriState.False) -12 345,679 .‫م‬.‫د‬
FormatCurrency(x, 3, TriState.True, TriState.True, TriState.True) (12 345,679 .‫م‬.‫)د‬
FormatCurrency(x, 3, TriState.True, TriState.True, TriState.False) (12345,679 .‫م‬.‫)د‬

21- La fonction FormatNumber – Formter les nombres

ff. La syntaxe :
Public Shared Function FormatNumber (
Expression As Object,
NumDigitsAfterDecimal As Integer,
IncludeLeadingDigit As TriState,
UseParensForNegativeNumbers As TriState,
GroupDigits As TriState
) As String
Le fonctionnement de la fonction FormatNumber est pareil à celui de la fonction
FormatCurrency mais sans utilisation du symbole monétaire.

22- La fonction FormatPercent – Formater les pourcentages

gg. La syntaxe :
Public Shared Function FormatPercent (
Expression As Object,
NumDigitsAfterDecimal As Integer,
IncludeLeadingDigit As TriState,
UseParensForNegativeNumbers As TriState,
GroupDigits As TriState
) As String
Le fonctionnement de la fonction FormatPercent est pareil à celui de la fonction
FormatCurrency mais avec le symbole de pourcentage à la place du symbole
monétaire. La valeur retournée est multipliée par 100.

23- La fonction FormatDateTime – Formater les dates et heures

hh.La syntaxe :
Public Shared Function FormatDateTime (
Expression As Date,
NamedFormat As DateFormat
) As String
NamedFormat est facultative, il est de type DateFormat qui représente le format selon
lequel doit se faire le formatage.

Les valeurs possibles sont :

82
 Constante Description

DateFormat.GeneralDate Affiche une date et/ou une heure. Affiche une partie de date sous
forme de date courte. En présence d'une partie de date, elle l'affiche
sous forme d'heure complète. Si elles sont présentes, les deux parties
sont affichées.

DateFormat.LongDate Affiche une date au format de date longue spécifié dans les
paramètres régionaux de votre ordinateur.

DateFormat.ShortDate Affiche une date au format de date courte spécifié dans les paramètres
régionaux de votre ordinateur.

DateFormat.LongTime Affiche une heure au format d'heure spécifié dans les paramètres
régionaux de votre ordinateur.

DateFormat.ShortTime Affiche une heure au format 24 heures (hh:mm).

ii. Exemple :
Dim x As DateTime = #07/22/2014 08:07:02#
Console.WriteLine(x)
Console.WriteLine(FormatDateTime(x))
Console.WriteLine(FormatDateTime(x, DateFormat.GeneralDate))
Console.WriteLine("*****************************************")
Console.WriteLine(FormatDateTime(x, DateFormat.LongDate))
Console.WriteLine(FormatDateTime(x, DateFormat.LongTime))
Console.WriteLine(FormatDateTime(x, DateFormat.ShortDate))
Console.WriteLine(FormatDateTime(x, DateFormat.ShortTime))

Le résultat est :
22/07/2014 08:07:02

22/07/2014 08:07:02

22/07/2014 08:07:02

*****************************************

mardi 22 juillet 2014

08:07:02

22/07/2014

08:07

24- La fonction Split – Diviser une chaîne en sous-chaînes

jj. La syntaxe :
Public Shared Function Split (
Expression As String,
Delimiter As String,

83
 Limit As Integer,
Compare As CompareMethod
) As String()
Expression : la chaîne de caractères à diviser

Delimiter : [Facultatif] le caractère ou la chaîne de caractères sur laquelle se base la

division (s’il est omis, alors prendre l’espace comme délimiteur)

Limit : [Facultatif] nombre maximum de sous-chaînes à obtenir (s’il est omis, alors
obtenir toutes les sous-chaînes)

CompareMethod : [Facultatif] est une énumération qui peut prendre l’une des valeurs
Binary ou Text, c.-à-d. CompareMethod.Binary ou CompareMethod.Text.

Avec Binary, la comparaison se fait comme suit :

A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø

Avec Test, la comparaison se fait comme suit :

(A=a) < (À = à) < (B=b) < (E=e) < (Ê = ê) < (Z=z) < (Ø = ø)

kk.Exemples (tirés de MSDN) :

Appel fractionné Valeur de retour

Split("42, 12, 19") {"42," , "12," , "19"}

Split("42, 12, 19", ", ") {"42", "12", "19"}

Split("42, 12, 19", ", ", 2) {"42", "12, 19"}

Split("192.168.0.1", ".") {"192", "168", "0", "1"}

Split("Alice and Bob", " AND ") {"Alice and Bob"}

Split("Alice and Bob", " AND ", ,CompareMethod.Text) {"Alice", "Bob"}

Split("[email protected]", "@",1) {"[email protected]"}

Split("[email protected]", "@",2) {"xyz", "example.com"}

25- La fonction Join – Concaténer des sous-chaînes en une seule

chaîne
ll. La syntaxe :
Public Shared Function Join ( Public Shared Function Join (
SourceArray As Object(), SourceArray As String(),
Delimiter As String Delimiter As String
) As String ) As String

84
Avec SourceArray : un tableau qui contient les sous-chaînes à concaténer

Delimiter : [Facultatif] la chaîne de caractères qui servira comme séparateur entre les
sous-chaînes

mm. Exemple :
Dim TestItem() As String = {"Bonjour", "Rachid", "Alami"}

Dim TestShoppingList As String = Join(TestItem, " - ")

Console.WriteLine(TestShoppingList)

TestShoppingList = Join(TestItem)
Console.WriteLine(TestShoppingList)

TestShoppingList = Join(TestItem, vbTab & vbTab)

Console.WriteLine(TestShoppingList)

Ceci donnera le résultat suivant :

Bonjour - Rachid - Alami

Bonjour Rachid Alami

Bonjour Rachid Alami

26- La fonction Len – La longueur d’une chaîne de caractères

Cette fonction retourne le nombre d’octets d’une chaîne de caractères passée en
argument ou le nombre d’octets si le paramètre est un objet autre que les chaînes de
caractères.

nn.Exemple :
Console.WriteLine(Len("Bonjour tous."))
Console.WriteLine(Len("7"))
Console.WriteLine(Len(7))

Donnera comme résultat :

13

27- La fonction Replace – Remplacer une sous-chaîne par une autre

dans une chaîne de caractères donnée
oo. La syntaxe :
Public Shared Function Replace (
Expression As String,
Find As String,
Replacement As String,
Start As Integer,
Count As Integer,

85
 Compare As CompareMethod
) As String
Expression : la chaîne de caractères sur laquelle s’applique le remplacement

Find : l’ancienne sous-chaîne à remplacer

Replacement : la nouvelle sous-chaîne

Start : [Facultatif] la position à partir de laquelle le traitement commence, les positions

avant Start ne sont pas retournées dans le résultat.

Count : [Facultatif] le nombre de remplacement à effectuer. Si ce paramètre est omis,

toutes les occurrences sont remplacées

Compare : [Facultatif] Binary ou Text

pp.Exemple :
Dim ch1 As String = "Bonjour tout le monde"
Dim ch2 As String

Instruction Valeur de ch2

ch2 = Replace(ch1, "o", "a") Banjaur taut le mande
ch2 = Replace(ch1, "o", "a", 8) taut le mande
ch2 = Replace(ch1, "o", "a", 8, 1) taut le monde
ch2 = Replace(ch1, "O", "a", 8, 1, CompareMethod.Binary) tout le monde
ch2 = Replace(ch1, "O", "a", 8, 1, CompareMethod.Text) taut le monde
ch2 = Replace(ch1, "O", "a", , , CompareMethod.Text) Banjaur taut le mande

86
Chapitre 7
Les dates et les heures
Type de données
Le type de données Visual Basic .NET qui représente les dates et les heures est : Date. Ce type permet
à la fois de représenter les dates, les heures et les deux.

Plage des valeurs

La plage des valeurs du type de données Date en VB .NET est :
du 1er janvier l’année 1 à 00:00:00 (minuit) jusqu’au 31 décembre l’année 9999 à 23:59:59:9999999.

La précision est de l’ordre de 100 nanosecondes.

Valeur par défaut

La valeur par défaut de Date est : 01/01/0001 00:00:00

Déclaration
La déclaration se fait comme pour les autres types de données en Visual Basic :

Dim maVariable As Date

Affectation de valeurs littérales

On peut affecter une valeur littérale de type Date à une variable de même type lors de la déclaration
(on parle de l’initialisation) ou après la déclaration, n’importe où dans le code. L’opérateur
d’assignation (ou d’affectation) est =. La valeur littérale doit se mettre entre deux caractères dièse (#).

Exemples :
Dim maVariable As Date = #05/26/1993 13:05:17#

Ou bien :

Dim maVariable As date

‘Instructions

maVariable = #05/26/1993 13:05:17#

Types de valeurs littérales

On a vu que le type de données Date permet de représenter les dates, les heures et les deux. Une
valeur littérale représentant la date et l’heure se délimite par deux caractères dièse. Entre ces deux
caractères figure la date sous forme de M/j/aaaa, M-j-aaaa, MM/jj/aaaa, MM-jj-aaaa ou aaaa-MM-jj
suivie de l’heure sous forme de h:m:s ; les deux valeurs doivent être séparées par une espace (ou des

87
espaces). En fait, pour une valeur littérale de type Date, on peut renseigner une date seulement, une
heure seulement ou les deux.

Si on a renseigné seulement la valeur de la date, l’heure est prise égale à 00:00:00 (minuit).

Si on a renseigné seulement la valeur de l’heure, la date est prise égale à 01/01/0001.

Si, dans une variable de type Date, la valeur de la date est le 1er janvier de l’année 1 (c.-à-d. la date par
défaut), alors elle ne sera pas affichée.

Si, dans une variable de type Date, la valeur de l’heure est 00:00:00 (c.-à-d. l’heure par défaut qui est
minuit), alors elle ne sera pas affichée.

Si, dans une variable de type Date, on n’a pas encore affecté de valeur ou si on a affectée la valeur
#01/01/0001 00:00:00#, alors la valeur affichée pour cette variable est celle de l’heure, c’est-à-dire
minuit selon les paramètres régionaux.

L’heure peut être renseignée en entrant les heures, les minutes et les secondes.

La mention de AM ou PM est facultative. Si on omet AM et PM et si l’heure est < 12 alors elle est
considérée comme étant AM, sinon elle est prise comme étant PM.

Si on veut mentionner AM ou PM alors les heures doivent être <= 12. 12 AM est équivalente à 00 en
24h et 12 PM est équivalente à 12 en 24h.

On peut se contenter seulement des heures et des minutes. Toutefois, si on veut se contenter
seulement des heures, ce qui est possible, il faut dans ce cas mentionner AM ou PM.

88
Exemples :
Valeur de x
Instruction x = Fuseau horaire 1 Fuseau horaire 1 Fuseau horaire 1
HH:mm:ss hh:m:ss h:m:s tt
00:00:00 12:0:00 12:0:0 AM
#25/2/1980 13:5:2# Date constant is not valid
#2/25/1980 13:5:2# 25/02/1980 13:05:02 25/02/1980 01:5:02 25/02/1980 1:5:2 PM
#2/25/1980 13:5:2# 25/02/1980 13:05:02 25/02/1980 01:5:02 25/02/1980 1:5:2 PM
#2/25/1980# 25/02/1980 25/02/1980 25/02/1980
#2/25/1980 0:00:00# 25/02/1980 25/02/1980 25/02/1980
#13:5:2# 13:05:02 01:5:02 1:5:2 PM
#01/01/0001 13:5:2# 13:05:02 01:5:02 1:5:2 PM
#01/01/0001 00:00:00# 00:00:00 12:0:00 12:0:0 AM
#2/25/80# Date constant is not valid
#2/25/1980
Date constant is not valid
23:59:59,9999999#
#2/25/1980
Date constant is not valid
23:59:59.9999999#
#2/25/1980 8:5:2# 25/02/1980 08:05:02 25/02/1980 08:5:02 25/02/1980 8:5:2 AM
#2/25/1980 8:5:2 AM# 25/02/1980 08:05:02 25/02/1980 08:5:02 25/02/1980 8:5:2 AM
#2/25/1980 8:5:2 PM# 25/02/1980 20:05:02 25/02/1980 08:5:02 25/02/1980 8:5:2 PM
#2/25/1980 18:5:2 AM# Date constant is not valid
#2/25/1980 18:5:2 PM# Date constant is not valid
#2/25/1980 12:5:2 AM# 25/02/1980 00:05:02
#2/25/1980 12:5:2 PM# 25/02/1980 12:05:02
#2/25/1980 12:5:2# 25/02/1980 12:05:02
25/02/1980 25/02/1980 8:12:0
#2/25/1980 8:12# 25/02/1980 08:12:00
08:12:00 AM
#2/25/1980 8# Date constant is not valid
#2/25/1980 8 PM# 25/02/1980 20:00:00 25/02/1980 08:0:00 25/02/1980 8:0:0 PM
#2/25/1980 8 AM# 25/02/1980 08:00:00 25/02/1980 08:0:00 25/02/1980 8:0:0 AM
#2/4/1980#
#02/04/1980#
#02/4/1980#
#2-4-1980#
#02-04-1980#
04/02/1980
#02-4-1980#
#1980/2/4#
#1980/02/04#
#1980-2-4#
#1980-02-04#
#02-04-80# Date constant is not valid
#80-02-04# Date constant is not valid

89
La classe DateTime
On a vu que le type VB .NET qui permet de représenter les dates et les heures est Date. DateTime,
quant à lui est une classe. Elle représente un instant qui s’exprime en date et heure. La précision est
de l’ordre de 100 nanosecondes. La classe DateTime présente une panoplie de constructeurs
surchargés ; ce qui permet une grande liberté pour représenter une date. On se sert de ces
constructeurs pour initialiser ou affecter à une variable de type Date une certaine valeur.

Les différents constructeurs de la classe DateTime sont les suivants :

DateTime(Int32, Int32, Int32)

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)
DateTime(Int32, Int32, Int32, Calendar)
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar)
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, DateTimeKind)
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar,
DateTimeKind)
DateTime(Int64)
DateTime(Int64, DateTimeKind)

90
Nom Description
Date sans l’heure (année, mois, jour)
DateTime(Int32, Int32, Int32)

Public Sub New ( Initialise une nouvelle instance de la

year As Integer, structure DateTime avec l'année, le mois
month As Integer, et le jour spécifiés.
day As Integer
)

DateTime(Int32, Int32, Int32, Calendar)

Public Sub New ( Initialise une nouvelle instance de la

year As Integer, structure DateTime avec l'année, le mois
month As Integer, et le jour spécifiés pour le calendrier
day As Integer, spécifié.
calendar As Calendar
)

Date avec l’heure (année, mois, jour, heure, minute, seconde)

DateTime(Int32, Int32, Int32, Int32, Int32, Int32)

Public Sub New (

year As Integer, Initialise une nouvelle instance de la
month As Integer, structure DateTime avec l'année, le mois,
day As Integer, le jour, l'heure (0-23), la minute et la
hour As Integer, seconde spécifiés.
minute As Integer,
second As Integer
)

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Calendar)

Public Sub New (

year As Integer, Initialise une nouvelle instance de la
month As Integer,
structure DateTime avec l'année, le mois,
day As Integer,
hour As Integer, le jour, l'heure, la minute et la seconde
minute As Integer, spécifiés pour le calendrier spécifié.
second As Integer,
calendar As Calendar
)

DateTime(Int32, Int32, Int32, Int32, Int32, Int32,

DateTimeKind) Initialise une nouvelle instance de la
structure DateTime avec l'année, le mois,
Public Sub New ( le jour, l'heure, la minute, la seconde et
year As Integer, l'heure UTC ou locale spécifiés.
month As Integer,
day As Integer,

91
 hour As Integer,
minute As Integer,
second As Integer,
kind As DateTimeKind
)

Date avec l’heure

(année, mois, jour, heure, minute, seconde, milliseconde)
DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32)

Public Sub New (

year As Integer, Initialise une nouvelle instance de la
month As Integer, structure DateTime avec l'année, le mois,
day As Integer,
le jour, l'heure, la minute, la seconde et
hour As Integer,
minute As Integer, la milliseconde spécifiés.
second As Integer,
millisecond As Integer
)

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32,

Calendar)

Public Sub New (

Initialise une nouvelle instance de la
year As Integer, structure DateTime avec l'année, le mois,
month As Integer,
day As Integer, le jour, l'heure, la minute, la seconde et
hour As Integer, la milliseconde spécifiés pour le
minute As Integer, calendrier spécifié.
second As Integer,
millisecond As Integer,
calendar As Calendar
)

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32,

DateTimeKind)

Public Sub New (

Initialise une nouvelle instance de la
year As Integer, structure DateTime avec l'année, le mois,
month As Integer,
day As Integer, le jour, l'heure, la minute, la seconde, la
hour As Integer, milliseconde et l'heure UTC ou locale
minute As Integer, spécifiés.
second As Integer,
millisecond As Integer,
kind As DateTimeKind
)

DateTime(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Initialise une nouvelle instance de la
structure DateTime avec l'année, le mois,
Calendar, DateTimeKind) le jour, l'heure, la minute, la seconde, la

92
 Public Sub New ( milliseconde et l'heure UTC ou locale
spécifiés pour le calendrier spécifié.
year As Integer,
month As Integer,
day As Integer,
hour As Integer,
minute As Integer,
second As Integer,
millisecond As Integer,
calendar As Calendar,
kind As DateTimeKind
)

Date en nombre de ticks (100 ns) depuis 01/01/0001 à minuit

Initialise une nouvelle instance de la
DateTime(Int64)
structure DateTime avec le nombre de
Public Sub New ( graduations spécifié.
Ticks est la date et l’heure exprimées en
ticks As Long
nombre d'intervalles de 100
) nanosecondes écoulés depuis le 1er
janvier 0001 à 00:00:00.000 (minuit) dans
le calendrier grégorien.
DateTime(Int64, DateTimeKind)
Initialise une nouvelle instance de la
Public Sub New ( structure DateTime avec un nombre
ticks As Long, spécifié de graduations et une heure
kind As DateTimeKind UTC ou locale.
)
DateTimeKind est une énumération qui permet de spécifier si un objet DateTime est exprimé en
horaire local, un horaire UTC ou que l’horaire n’est pas spécifié.
Les membres de l’énumération DateTimeKind sont : Local, Unspecified et Utc.
Pour spécifier un calendrier on instancie la classe Globalization.x avec x étant le calendrier voulu. Par
exemple :
New Globalization.HijriCalendar
New Globalization.UmAlQuraCalendar
New Globalization.GregorianCalendar
New Globalization.ChineseLunisolarCalendar
New Globalization.PersianCalendar
New Globalization.JulianCalendar

Exemples :
Instruction x = Résultat
New DateTime(15, 12, 7) 07/12/0015
New DateTime(2015, 12, 7) 07/12/2015
New DateTime(2015, 12, 7, New 16/01/2016
Globalization.ChineseLunisolarCalendar)
New DateTime(2015, 12, 7, New 26/02/2637
Globalization.PersianCalendar)
New DateTime(2015, 12, 7, New 07/12/2015
Globalization.GregorianCalendar)

93
 New DateTime(2015, 12, 7, New 20/12/2015
Globalization.JulianCalendar)
New DateTime(1437, 2, 25, New 07/12/2015
Globalization.HijriCalendar)
New DateTime(1437, 2, 25, New 07/12/2015
Globalization.UmAlQuraCalendar)
New DateTime(2015, 12, 7, 8, 15, 6) 07/12/2015 08:15:06
New DateTime(2015, 12, 7, 20, 15, 6) 07/12/2015 20:15:06
New DateTime(2015, 12, 7, 20, 15, 6, 07/12/2015 20:15:06
DateTimeKind.Utc)
New DateTime(2015, 12, 7, 20, 15, 6, Résultat avec : & " " & x.Kind
DateTimeKind.Utc) 07/12/2015 20:15:06 1
New DateTime(2015, 12, 7, 20, 15, 6, Résultat avec: & " " & x.Kind.ToString
DateTimeKind.Utc) 07/12/2015 20:15:06 Utc
New DateTime(2015, 12, 7, 20, 15, 6, Résultat avec : & " {0}", x.Kind
DateTimeKind.Utc) 07/12/2015 20:15:06 Utc
New DateTime(2015, 12, 7, 20, 15, 6, & " {0}", x.Kind
DateTimeKind.Local) 07/12/2015 20:15:06 Local
New DateTime(2015, 12, 7, 20, 15, 6, Résultat avec : & " {0}", x.Kind
DateTimeKind.Unspecified) 07/12/2015 20:15:06 Unspecified
New DateTime(2015, 12, 7, 20, 15, 6) Résultat avec : & " {0}", x.Kind
07/12/2015 20:15:06 Unspecified
New DateTime(2015, 12, 7) Résultat avec : & " {0}", x.Kind
07/12/2015 Unspecified
New DateTime(2015, 12, 7, 20, 15, 6, 888) Résultat avec : & " {0}", x.Kind
07/12/2015 20:15:06 Unspecified
New DateTime(636126566400000000) 21/10/2016 14:24:00

La classe DateTimeOffset
La classe DateTimeOffset est, comme la classe DateTime, permet de représenter un instant qui
s’exprime en date et heure, sauf qu’avec DateTimeOffset, l’instant est exprimé par rapport au temps
universel UTC (Universal Time Coordinated). La précision est toujours de l’ordre de 100 nanosecondes.

Les différents constructeurs de la classe DateTimeOffset sont les suivants :

DateTimeOffset(DateTime)
DateTimeOffset(DateTime, TimeSpan)
DateTimeOffset(Int32, Int32, Int32, Int32, Int32, Int32, TimeSpan)
DateTimeOffset(Int32, Int32, Int32, Int32, Int32, Int32, Int32, TimeSpan)
DateTimeOffset(Int32, Int32, Int32, Int32, Int32, Int32, Int32, Calendar, TimeSp
an)
DateTimeOffset(Int64, TimeSpan)
TimeSpan représente l’intervalle de temps entre l’horaire fourni et l’UTC. TimeSpan peut aussi servir
pour mesurer la différence entre deux instants différents.

94
Nom Description
Date sous forme d’un objet DateTime
DateTimeOffset(DateTime)
Initialise une nouvelle instance de la
Public Sub New ( structure DateTimeOffset à l'aide de la
dateTime As Date valeur DateTime spécifiée.
)

DateTimeOffset(DateTime, TimeSpan)
Initialise une nouvelle instance de la
Public Sub New ( structure DateTimeOffset à l'aide de
dateTime As Date, l'offset et de la valeur DateTime
offset As TimeSpan spécifiés.
)

Date avec l’heure

(année, mois, jour, heure, minute, seconde, [milliseconde])
DateTimeOffset(Int32, Int32, Int32, Int32, Int32, Int32, Tim
eSpan)

Public Sub New (

year As Integer, Initialise une nouvelle instance de la
month As Integer, structure DateTimeOffset en utilisant
day As Integer, l'année, le mois, le jour, l'heure, la
hour As Integer, minute, la seconde et l'offset spécifiés.
minute As Integer,
second As Integer,
offset As TimeSpan
)

DateTimeOffset(Int32, Int32, Int32, Int32, Int32, Int32, Int3

2, TimeSpan)

Public Sub New (

year As Integer, Initialise une nouvelle instance de la
month As Integer, structure DateTimeOffset en utilisant
day As Integer, l'année, le mois, le jour, l'heure, la
hour As Integer, minute, la seconde, la milliseconde et
minute As Integer, l'offset spécifiés.
second As Integer,
millisecond As Integer,
offset As TimeSpan
)

DateTimeOffset(Int32, Int32, Int32, Int32, Int32, Int32, Initialise une nouvelle instance de la
Int32, Calendar, TimeSpan) structure DateTimeOffset en utilisant
l'année, le mois, le jour, l'heure, la
Public Sub New ( minute, la seconde, la milliseconde et
year As Integer, l'offset spécifiés pour un calendrier
month As Integer, spécifié.

95
 day As Integer,
hour As Integer,
minute As Integer,
second As Integer,
millisecond As Integer,
calendar As Calendar,
offset As TimeSpan
)

Date en nombre de ticks (100 ns) depuis 01/01/0001 à minuit

DateTimeOffset(Int64, TimeSpan)
Initialise une nouvelle instance de la
Public Sub New ( structure DateTimeOffset à l'aide de
ticks As Long, l'offset et du nombre de graduations
offset As TimeSpan spécifiés.
)

Exemples :
Dim dateTime1 As DateTime
dateTime1 = New DateTime(2015, 12, 25, 18, 41, 23)

Dim dtOffset As DateTimeOffset

Instruction dtOffset = Résultat

New DateTimeOffset(dateTime1) 25/12/2015 18:41:23 +00:00
New DateTimeOffset(dateTime1, New TimeSpan(4, 0, 0)) 25/12/2015 18:41:23 +04:00
New DateTimeOffset(2014, 11, 24, 17, 40, 22, 24/11/2014 17:40:22 +04:00
New TimeSpan(4, 0, 0))
New DateTimeOffset(2014, 11, 24, 17, 40, 22, 88, 24/11/2014 17:40:22 +04:00
New TimeSpan(4, 0, 0))
New DateTimeOffset(2014, 11, 24, 17, 40, 22, 88, 21/06/2576 17:40:22 +04:00
New Globalization.HijriCalendar,
New TimeSpan(4, 0, 0))
New DateTimeOffset(636126566400000000, 21/10/2016 14:24:00 +04:00
New TimeSpan(4, 0, 0))

96
Calcul de différence entre deux dates
On peut calculer la différence entre deux dates par l’opérateur de soustraction - ou avec la fonction
DateDiff.
Dim date1, date2 As Date
Dim dateOffset1, dateOffset2 As DateTimeOffset
Dim difference As TimeSpan

date1 = New DateTime(1980, 02, 25)

date2 = New DateTime(2015, 12, 12)
difference = date2 - date1 (difference  13074.00:00:00)

dateOffset1 = New DateTime(1980, 02, 25)

dateOffset2 = New DateTime(2015, 12, 12)
difference = dateOffset2 - dateOffset1 (difference  13074.00:00:00)

La différence entre Date et DateTimeOffset

Dim date1, date2 As Date
Dim dateOffset1, dateOffset2 As DateTimeOffset
Dim difference As TimeSpan

date1 = Date.Now
date2 = Date.UtcNow
difference = date1 - date2
Console.WriteLine(vbTab & date1 & " - " & date2 & " {0}", difference)
Ce qui donne  14/12/2015 11:03:24 - 14/12/2015 11:03:24 -00:00:00.0080007

dateOffset1 = Date.Now
dateOffset2 = Date.UtcNow
difference = dateOffset1 - dateOffset2
Console.WriteLine(vbTab & date1 & " - " & date2 & " {0}", difference)

Ce qui donne  14/12/2015 11:03:24 - 14/12/2015 11:03:24 00:00:00

Par contre, si on change le fuseau horaire en (UTC +04:00) Abu Dhabi, Muscat, alors
les deux affichages précédents deviendront :
14/12/2015 15:08:25 - 14/12/2015 11:08:25 03:59:59.9990010
14/12/2015 15:08:25 - 14/12/2015 11:08:25 -00:00:00.0730084

La fonction DateDiff
Dim date1, date2 As Date
Dim diffYear, diffMonth, diffDay As Long

date1 = New DateTime(1980, 02, 25)

date2 = New DateTime(2015, 12, 12)

diffYear = DateDiff(DateInterval.Year, date1, date2)

 35
diffMonth = DateDiff(DateInterval.Month, date1, date2)
 430
diffDay = DateDiff(DateInterval.Day, date1, date2)
 13074

97
Chapitre 8

La conversion de type

II - Introduction à la conversion des types

La conversion de type et le fait de changer le type d’une donnée A en un autre type
pour pouvoir établir des opérations. Cette conversion peut être implicite (faite
automatiquement) comme elle peut être explicite (réalisée par le programmeur).

Visual Basic .Net propose une instruction à mettre au tout début du code source qui
permet d’indiquer si la conversion doit se faire d’une manière implicite ou explicite.
Cette instruction est :
Option Strict On|Off

Si elle est On alors la conversion est considérée explicite, c.-à-d. c’est au programmeur
de réaliser la conversion. Si elle est Off alors la conversion est implicite (ce qui est par
défaut), c.-à-d. c’est le compilateur qui réalisera la conversion si besoin est.

Exemple
Dim x As Integer = 3
Dim y As Double = 9.4
Dim z As Integer

z = x
x = y
y = z

 x = 9 et y = 3

x = 3
y = 9.6

z = x
x = y
y = z

 x = 10 et y = 3
Pour la conversion à partir des types réels (Single, Double, Decimal) vers les types
entiers (SByte, Byte, Short, UShort, Integer, UInteger, Long, ULong), l’opération se fait
par arrondissement.

Une variable de type Object peut recevoir la valeur de n’importe quel type et ce peu
importe l’option Strict.

98
Si Option Strict est Off, alors la conversion entre les types numériques (SByte, Byte,
Short, UShort, Integer, UInteger, Long, ULong, Single, Double et Decimal) est, en
général, possible. Par exemple :
Dim vSByte As SByte = -128
Dim vByte As Byte = 255
'vSByte = vByte
'vByte = vSByte
Ces deux instructions ne sont pas possibles à cause du OverFlow. Par contre :
vSByte = 3
vByte = vSByte
vByte = 5
vSByte = vByte
les deux conversions sont possibles.

Si Option Strict est On, alors la conversion entre les types numériques est possible si le
type source inclut le type destination.

Question : pour chacun des onze types numériques, quels sont les types des valeurs
qu’il peut recevoir ?

Si Option Strict est On, alors pour les types non numériques autre que Object, à savoir
Char, String, Date et Boolean, la conversion de type n’est possible que pour le type
Char vers String car le type String englobe le type Char.

Le type Char ne peut en aucun cas être converti en Single, Double, Decimal, Date ou
Boolean.

Le type Char est toujours convertible en String.

Le type Char peut être converti en types entiers, à savoir SByte, Byte, Short, UShort,
Integer, UInteger, Long et ULong, en utilisant les fonctions Asc et AscW pour avoir
respectivement le code ASCII et la valeur Unicode et la fonction Val pour l’interpréter
en tant que chiffre.

Si Option Strict est Off, alors le type Date peut être converti en String et vice versa. Par
exemple :
Dim vDate As Date = #12/25/2015#
Dim vString As String
vString = vDate
Console.WriteLine(vString)  affichera : 25/12/2015

vString = "#31/12/2015#"
vDate = vString
Console.WriteLine(vDate)  affichera : 31/12/2015 00:00:00

Notez la position du jour et du mois.

III - Les littéraux et les types de données

99
Un littéral est une valeur qui est exprimée explicitement dans le code source, comme
le nombre 12, le nombre -3.5, le caractère « G », la chaîne de caractères « Bonjour » , la
valeur True, etc.
Lors de la déclaration d’une constante, on peut ne pas préciser son type si Option Infer
a la valeur On ou si Option Strict a la valeur Off. Le compilateur déterminera alors le
type de données de la constante à partir de la valeur qui lui est assignée. Mais une
valeur peut appartenir à plusieurs types de données en même temps comme le cas de
5 par exemple, qui peut être vu comme étant n’importe quel type numérique (SByte,
Byte, Short, UShort, Integer, UInteger, Long, ULong, Single, Double et Decimal).

Par défaut, un littéral entier est considéré de type Integer, un littéral réel est considéré
de type Double, les mots clés True et False sont considérés de type Boolean et tout
caractère ou suite de caractères mis entre double quottes est considéré de type String.
En résumé :

Type Casté en
SByte
Byte
Short
UShort
Integer
Integer
UInteger
Long
ULong
Single
Double Double
Decimal
Char
String
String
Boolean Boolean
Date Date
Plus précisément :

Type de données par

Forme textuelle de littéral Exemple
défaut
Numérique, aucune partie fractionnaire Integer 2147483647
Numérique, aucune partie fractionnaire, trop
Long 2147483648
grand pour Integer
Numérique, partie fractionnaire Double 1.2
Placé entre guillemets doubles String "A"
#5/17/1993 9:32
Placé entre signes dièse Date
AM#
Pour forcer une valeur littérale à être d’un certain type, on utilise un caractère de type
ou des caractères englobants :

100
 Type de données Caractère englobant Caractère de type de littéral ajouté
SByte
Byte
Short S
UShort US
Integer I ou %
UInteger UI
Long L ou &
ULong UL
Single F ou !
Double R ou #
Decimal D ou @
Char " C
String "
Date #
Boolean
Object
28- Caractères de type d'identificateur
Un caractère de type peut s’ajouter à un identificateur pour désigner son type
correspondant.

Caractère de type d'identificateur Type de données Exemple

% Integer Dim L%
& Long Dim M&
@ Decimal Const W@ = 37.5
! Single Dim Q!
# Double Dim X#
$ String Dim V$ = "Secret"
Avec Option Strict On, toutes les déclarations des variables doivent se faire avec AS
(Dim nom_variable As type_variable) sauf si l’identificateur est préfixé d’un caractère
de type d’identificateur.

29- Littéraux hexadécimaux et octaux

Pour utiliser un littéral entier en forme hexadécimale ou octale, on utilise
respectivement les préfixes &H et &O. On peut aussi combiner pour un littéral le
préfixe et le caractère de type de littéral :

Base numérique Préfixe Valeurs de chiffres valables Exemple

Hexadécimale (base 16) &H 0-9 et A-F &HA8S
Octale (base 8) &O 0-7 &O527US

IV - Type valeur et type référence

101
En Visual Basic .NET, lorsqu’on déclare une variable d’un certain type, elle peut soit
stocker la valeur qu’on lui assigne, soit stocker un pointeur vers un emplacement
mémoire où est stockée la valeur assignée (la variable, dans ce cas-là, stocke en fait une
référence vers une instance de l’objet en mémoire). Si la variable est destinée à stocker
les valeurs directement, on parle alors d’un type valeur. Par contre, si la variable ne
stocke qu’un pointeur vers l’emplacement mémoire stockant la valeur proprement
dite, on parle alors de type référence.

La hiérarchie des types valeur et types référence

Exemples de type valeur :

 Tous les types de données numériques (SByte, Byte, Short, UShort, Integer,
UInteger, Long, ULong, Single, Double et Decimal)
 Les types de données Boolean, Char et Date.
 Les structures
 Les énumérations

Exemples de type référence :

 String
 Les tableaux
 Les classes

Les variables de type Object contiennent toujours un pointeur vers les données et non
pas les données elles-mêmes. On a déjà vu qu’une variable de type Object peut recevoir
la valeur de n’importe quel type de données, alors une variable de type Object se
comporte selon qu’on lui a assignée une valeur de type valeur ou de type référence.
Pour savoir de quel type (valeur ou référence) une variable se comporte, on utilise la
méthode IsReference de la classe Information. Par exemple, le code suivant :
Console.WriteLine(Information.IsReference(vDate))
vObject = "25"
Console.WriteLine(vObject & vbTab & Information.IsReference(vObject))
vObject = 5
Console.WriteLine(vObject & vbTab & Information.IsReference(vObject))

102
 vObject = "F"
Console.WriteLine(vObject & vbTab & Information.IsReference(vObject))
vObject = "F"c
Console.WriteLine(vObject & vbTab & Information.IsReference(vObject))
vObject = "Salam tous"
Console.WriteLine(vObject & vbTab & Information.IsReference(vObject))
vObject = #12/25/2015#
Console.WriteLine(vObject & vbTab & Information.IsReference(vObject))
vObject = New Byte(3) {1, 2, 3, 4}
'Console.WriteLine(vObject & vbTab & Information.IsReference(vObject))
For i As Integer = 0 To 3
Console.Write(vObject(i) & vbTab)
Next
Console.WriteLine(Information.IsReference(vObject))

Générera le résultat suivant :

False
25 True
5 False
F True
F False
Salam tous True
25/12/2015 False
1 2 3 4 True

V- Nothing
Nothing Représente la valeur par défaut de n’importe quel type de données. La valeur
par défaut de tous les types numériques est 0, la valeur par défaut des types Char,
String et Object est NULL, la valeur par défaut de Date est 01/01/0001 00:00:00 et la
valeur par défaut de Boolean est False.

VI - Obtenir et tester les types de données

L’opérateur TypeOf  à traiter inchaa Allah dans la partie « Programmation visuelle »

Pour obtenir le type de données d’une variable, on utilise la fonction ou la méthode

GetType() :
Console.WriteLine(GetType(UInteger))
Console.WriteLine(vSByte.GetType)

VII - La conversion explicite des types de données

Quand l’option strict est On, la conversion des types doit se faire d’une manière
explicite, c.-à-d. par le programmeur via des fonctions prédéfinies par VB .NET. Soit
le code suivant :
Dim vSByte As SByte = 3
Dim vByte As Byte
vByte = vSByte

103
La dernière instruction générera une erreur. Il faut tout d’abord convertir la variable
vSByte en type de données Byte via une fonction adéquate pour pouvoir affecter sa
valeur à la variable vByte.

30- La fonction CType()

Syntaxe :
CType(expression, typename)

A condition qu’expression soit dans la plage autorisée par typename.

Par exemple :
Dim z&
z = CType(1.25, Long)

31- Des fonctions spécifiques

Outre la fonction CType, Visual Basic propose d’autres fonctions de conversion de
type plus spécifiques. Il s’agit des fonctions suivantes :

CSByte CByte CShort CUshort CInt CUInt CLng CULng

CSng CDbl CDec
CChar CStr CBool CDate CObj

Ces fonctions requièrent un seul paramètre, il s’agit de l’expression à convertir qui doit
bien sûr être dans la plage autorisée par le type correspondant à la fonction.

Pour la fonction CBool, toute valeur numérique passée en argument et différente de 0

est convertie en True, sinon elle est convertie en False. La chaîne de caractère « True »
est convertie en True, tandis que « False » est convertie en False peu importe la casse
(« tRuE », « TRUE », etc sont converties en True). Les valeurs booléennes True et False
restent inchangées.

Pour les fonctions de conversion en entier, si le nombre a une partie fractionnaire, alors
il est arrondi en arrondi bancaire qui consiste à supprimer la partie fractionnaire du
nombre et à l’arrondir au nombre entier le plus proche. Si la partie fractionnaire est
exactement 0.5, alors le nombre sera arrondi au nombre entier paire le plus proche ;
par exemple : 0.5 est arrondi en 0 et 1.5 et 2.5 sont tous les deux arrondis en 2.

32- L’opérateur DirectCast()

L’opérateur DirectCast s’utilise de la même façon que la fonction CType à condition
qu’il y ait une relation d’héritage ou d’implémentation entre les deux types. Par
exemple :
vDecimal = DirectCast(vSByte, Decimal)

104
générera une erreur de compilation : Value of type ‘SByte’ cannot be converted to
’Decimal’. Par contre :
Dim f As New System.Windows.Forms.Form
Dim c As System.Windows.Forms.Control
' The following conversion succeeds.
c = DirectCast(f, System.Windows.Forms.Control)
ne générera aucune erreur, car Form hérite de Control.

33- L’opérateur TryCast

S’utilise de la même façon que la fonction CType. TryCast requiert aussi qu’il y ait une
relation d’héritage ou d’implémentation entre les deux types. L’avantage de TryCast
par rapport à CType et DirectCast est que ces deux derniers peuvent générer des
exceptions lors de l’exécution si la conversion échoue ; alors que TryCast retourne
Nothing, ce qui signifie qu’il suffit de comparer la valeur retournée à Nothing.

34- CType-DirectCast-TryCast … en résumé

Types de Échec lors de
Mot clé Relation d'argument
données l'exécution
Une conversion étendue ou
CType Function Tout type de Lève
restrictive doit être définie entre
(Visual Basic) données InvalidCastException
les deux types de données
DirectCast
Tout type de Un type doit hériter de l'autre Lève
Operator (Visual
données type ou l'implémenter InvalidCastException
Basic)
Types référence Un type doit hériter de l'autre
TryCast Retourne Nothing
uniquement type ou l'implémenter

105
Chapitre 9

Traitement des fichiers

VIII - Hiérarchie des classes

IX - La classe FileStream
La classe FileStream permet de manipuler des fichiers ainsi que des périphériques
d’entrée/sortie. Elle peut s’utiliser avec la classe File.

35- Les constructeurs

Il y en a 15 constructeurs dont 4 obsolètes, ce qui donne 11 constructeurs à utiliser.
Parmi ces 11 constructeurs, les plus utilisés sont les 8 qui utilisent comme premier
paramètre le chemin d’accès du fichier à manipuler.

106
Constructeur FileStream(IntPtr, FileAccess)

Obsolète. Initialise une nouvelle instance de la classe FileStream pour le handle

Description
de fichier spécifié, avec l'autorisation d'accès en lecture/écriture spécifiée.

Constructeur FileStream(IntPtr, FileAccess, Boolean)

Obsolète. Initialise une nouvelle instance de la classe FileStream pour le handle

Description de fichier spécifié, avec l'autorisation d'accès en lecture/écriture et la propriété
d'instance FileStream spécifiées.

Constructeur FileStream(IntPtr, FileAccess, Boolean, Int32)

Obsolète. Initializes a new instance of the FileStream class for the specified file
Description handle, with the specified read/write permission, FileStream instance
ownership, and buffer size.

Constructeur FileStream(IntPtr, FileAccess, Boolean, Int32, Boolean)

Obsolète. Initialise une nouvelle instance de la classe FileStream pour le handle

de fichier spécifié, avec l'autorisation d'accès en lecture/écriture, la propriété de
Description
l'instance FileStream, la taille de mémoire tampon et l'état synchrone ou
asynchrone spécifiés.

Constructeur FileStream(SafeFileHandle, FileAccess)

Initialise une nouvelle instance de la classe FileStream pour le handle de fichier

Description
spécifié, avec l'autorisation d'accès en lecture/écriture spécifiée.

Constructeur FileStream(SafeFileHandle, FileAccess, Int32)

Initialise une nouvelle instance de la classe FileStream pour le handle de fichier

Description spécifié, avec l'autorisation d'accès en lecture/écriture et la taille de mémoire
tampon spécifiées.

Constructeur FileStream(SafeFileHandle, FileAccess, Int32, Boolean)

Initialise une nouvelle instance de la classe FileStream pour le handle de fichier

Description spécifié, avec l'autorisation d'accès en lecture/écriture, la taille de mémoire
tampon et l'état synchrone ou asynchrone spécifiés.

107
Constructeur FileStream(String, FileMode)

Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès et

Description
le mode de création spécifiés.

Constructeur FileStream(String, FileMode, FileAccess)

Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le

Description
mode de création et les autorisations de lecture/écriture spécifiés.

Constructeur FileStream(String, FileMode, FileAccess, FileShare)

Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le

Description mode de création, l'autorisation de lecture/écriture et l'autorisation de partage
spécifiés.

Constructeur FileStream(String, FileMode, FileAccess, FileShare, Int32)

Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le

Description mode de création, l'autorisation de lecture/écriture, l'autorisation de partage et
la taille de mémoire tampon spécifiés.

Constructeur FileStream(String, FileMode, FileAccess, FileShare, Int32, Boolean)

Initializes a new instance of the FileStream class with the specified path, creation
Description mode, read/write and sharing permission, buffer size, and synchronous or
asynchronous state.

Constructeur FileStream(String, FileMode, FileAccess, FileShare, Int32, FileOptions)

Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le

mode de création, l'autorisation d'accès en lecture/écriture et de partage, l'accès
Description
que d'autres flux de fichiers peuvent avoir au même fichier, la taille de mémoire
tampon et les options de fichiers supplémentaires spécifiés.

Constructeur FileStream(String, FileMode, FileSystemRights, FileShare, Int32, FileOptions)

108
 Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le
Description mode de création, l'autorisation de droits d'accès, l'autorisation de partage, la
taille de mémoire tampon et les options de fichiers supplémentaires spécifiés.

FileStream(String, FileMode, FileSystemRights, FileShare, Int32, FileOptions,

Constructeur
FileSecurity)

Initialise une nouvelle instance de la classe FileStream avec le chemin d'accès, le

mode de création, l'autorisation de droits d'accès, l'autorisation de partage, la
Description
taille de mémoire tampon, les options de fichiers supplémentaires et la sécurité
de contrôle d'accès et d'audit spécifiés.

Les neuf constructeurs utilisent les énumérations suivantes :

FileMode, FileAccess, FileShare, FileOptions, et FileSystemRights, ainsi que le classe

FileSecurity.

36- L’énumération FileMode

Elle spécifie la façon dont le système d’exploitation doit ouvrir un fichier. Elle
comporte six membres : Append, Create, CreateNew, Open, OpenOrCreate et
Truncate.

Nom de membre Description

Ouvre le fichier s'il existe et accède à la fin du fichier, ou crée
un nouveau fichier. Cela requiert l'autorisation
FileIOPermissionAccess.Append. FileMode.Append peut
seulement être utilisé conjointement avec FileAccess.Write.
Append
Toute tentative d'effectuer une recherche sur une position
avant la fin du fichier lève une exception IOException, et toute
tentative de lecture échoue et lève une exception
NotSupportedException.
Spécifie que le système d'exploitation doit créer un fichier. Si le
fichier existe, il est remplacé. Cela requiert l'autorisation
FileIOPermissionAccess.Write. FileMode.Create équivaut
Create à demander d'utiliser CreateNew si le fichier n'existe pas ; dans
le cas contraire, utilisez Truncate. Si le fichier existe déjà mais
qu'il s'agit d'un fichier masqué, une exception
UnauthorizedAccessException est levée.
Spécifie que le système d'exploitation doit créer un fichier. Cela
CreateNew requiert l'autorisation FileIOPermissionAccess.Write. Si le
fichier existe déjà, une exception IOException est levée.

109
 Spécifie que le système d'exploitation doit ouvrir un fichier
existant. La possibilité d'ouvrir le fichier dépend de la valeur
Open spécifiée par l'énumération FileAccess. Une exception
System.IO.FileNotFoundException est levée si le fichier
n'existe pas.
Spécifie que le système d'exploitation doit ouvrir un fichier s'il
existe ; sinon, un nouveau fichier doit être créé. Si le fichier est
ouvert avec FileAccess.Read, l'autorisation
FileIOPermissionAccess.Read est requise. Si l'accès au
OpenOrCreate fichier est FileAccess.Write, l'autorisation
FileIOPermissionAccess.Write est requise. Si le fichier est
ouvert avec FileAccess.ReadWrite, les autorisations
FileIOPermissionAccess.Read et
FileIOPermissionAccess.Write sont requises.
Spécifie que le système d'exploitation doit ouvrir un fichier
existant. Lorsque le fichier est ouvert, il doit être tronqué afin
que sa taille soit égale à zéro octet. Cela requiert l'autorisation
Truncate
FileIOPermissionAccess.Write. Toute tentative de lecture
d'un fichier ouvert avec FileMode.Truncate entraîne une
exception ArgumentException.

37- L’énumération FileAccess

Elle définit des constantes pour l’accès en lecture, en écriture ou en lecture/écriture.
Les membres de cette énumération sont : Read, Write et ReadWrite.

38- Combinaison des deux énumérations

FileMode.CreateNew, FileAccess.Read  Association non valide

FileMode.Create, FileAccess.Read  Association non valide

FileMode.Truncate, FileAccess.Read  Association non valide

FileMode.Append, FileAccess.Read  Association non valide

--------------------------------------------------------------------------------------
---

 Pas de problème avec FileAccess.Write

--------------------------------------------------------------------------------------
---

FileMode.Append, FileAccess.ReadWrite  Un accès en ajout ne peut être demandé qu'en

mode écriture seule.

--------------------------------------------------------------------------------------
---

39- L’énumération FileShare

110
Contient des constantes pour contrôler le type d'accès d'autres objets FileStream à un
même fichier. Ses membres sont :

Nom de membre Description

Refuse le partage du fichier en cours. Toute demande
None d'ouverture du fichier (par ce processus ou un autre) échouera
jusqu'à la fermeture du fichier.
Permet l'ouverture ultérieure du fichier pour la lecture. Si cet
indicateur n'est pas spécifié, toute demande d'ouverture du
fichier pour la lecture (par ce processus ou un autre) échouera
Read
jusqu'à la fermeture du fichier. Cependant, si cet indicateur est
spécifié, des autorisations supplémentaires peuvent toujours
être nécessaires pour accéder au fichier.
Permet l'ouverture ultérieure du fichier pour l'écriture. Si cet
indicateur n'est pas spécifié, toute demande d'ouverture du
fichier pour l'écriture (par ce processus ou un autre) échouera
Write
jusqu'à la fermeture du fichier. Cependant, si cet indicateur est
spécifié, des autorisations supplémentaires peuvent toujours
être nécessaires pour accéder au fichier.
Permet l'ouverture ultérieure du fichier pour la lecture ou
l'écriture. Si cet indicateur n'est pas spécifié, toute demande
d'ouverture du fichier pour la lecture ou l'écriture (par ce
ReadWrite processus ou un autre) échouera jusqu'à la fermeture du
fichier. Cependant, si cet indicateur est spécifié, des
autorisations supplémentaires peuvent toujours être
nécessaires pour accéder au fichier.
Delete Autorise la suppression ultérieure d'un fichier.
Crée le handle de fichier hérité par les processus enfants. Ceci
Inheritable
n'est pas pris en charge par Win32.

Imports System.ComponentModel

Public Class Form1

Dim monFichier As IO.FileStream

Private Sub Form1_Closing(sender As Object, e As CancelEventArgs) Handles

Me.Closing
monFichier.Dispose()
End Sub

Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

monFichier = New IO.FileStream("zero.txt", IO.FileMode.OpenOrCreate)
End Sub

Private Sub btnLire_Click(sender As Object, e As EventArgs) Handles btnLire.Click

If monFichier.CanRead Then

111
 Dim contenu(1024) As Byte
monFichier.Position = 0
monFichier.Read(contenu, 0, 1024)
txtLecture.Text = ""
For Each lettre As Byte In contenu
txtLecture.Text += Chr(lettre)
Next
End If
End Sub

Private Sub btnEcrire_Click(sender As Object, e As EventArgs) Handles

btnEcrire.Click
If monFichier.CanWrite Then
Dim contenu(1024) As Byte
Dim compteur As Integer = 0
For Each lettre As Char In txtEcriture.Text.ToCharArray
contenu(compteur) = Asc(lettre)
compteur += 1
Next
If chkDebut.Checked Then
monFichier.Position = 0
End If
monFichier.Write(contenu, 0, compteur)
End If
End Sub

Private Sub btnClearLire_Click(sender As Object, e As EventArgs) Handles

btnClearLire.Click
txtLecture.Text = ""
End Sub

Private Sub btnClearEcrire_Click(sender As Object, e As EventArgs) Handles

btnClearEcrire.Click
txtEcriture.Text = ""
End Sub

Private Sub btnClear_Click(sender As Object, e As EventArgs) Handles

btnClear.Click
monFichier.Dispose()
monFichier = New IO.FileStream("zero.txt", IO.FileMode.Create)
End Sub
End Class

--------------------------------------------------------------------------------------------------------------------------------------
Imports System.IO

Public Class Form1

Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click
End
End Sub

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click

File.Move(TextBox1.Text, TextBox2.Text)
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click

File.Copy(TextBox3.Text, TextBox4.Text)
End Sub

Private Sub Button4_Click(sender As Object, e As EventArgs) Handles Button4.Click

112
 File.Delete(TextBox5.Text)
End Sub
End Class
--------------------------------------------------------------------------------------------------------------------------------------
Imports System.IO

Public Class Form1

Const chemin As String = "un.txt"

Private Sub btnLire_Click(sender As Object, e As EventArgs) Handles btnLire.Click

txtLecture.Text = File.ReadAllText(chemin)
End Sub

Private Sub btnClearLire_Click(sender As Object, e As EventArgs) Handles

btnClearLire.Click
txtLecture.Text = ""
End Sub

Private Sub btnClearEcrire_Click(sender As Object, e As EventArgs) Handles

btnClearEcrire.Click
txtEcriture.Text = ""
End Sub

Private Sub btnClear_Click(sender As Object, e As EventArgs) Handles

btnClear.Click
File.WriteAllText(chemin, "")
End Sub

Private Sub btnEcrire_Click(sender As Object, e As EventArgs) Handles

btnEcrire.Click
If chkDebut.Checked Then
File.WriteAllText(chemin, txtEcriture.Text)
Else
File.AppendAllText(chemin, txtEcriture.Text)
End If
End Sub
End Class
--------------------------------------------------------------------------------------------------------------------------------------

113
Chapitre 10

Visual Basic .NET et les bases de données

Il y trois manière pour communiquer à partir d’une application VB .NET avec une base
de données située dans un server, ceci dépend de nos besoins. Ces méthodes sont :

 Accès en écriture
 Accès en lecture de masse
 Accès en lecture unitaire

Le DataReader permet d’établir une connexion vers la base de données, c.-à-d. qu’il
fonctionne en mode connecté (il garde la connexion ouverte tout au long de son
utilisation) ; et c’est pourquoi il ne faut pas l’utiliser si on veut faire un grand traitement
pour chaque ligne, car on va garder la connexion établie pour une longue durée.

Le DataReader fournit les résultats au fur et à mesure de l’exécution de la requête, ces

résultats sont stockés dans la mémoire tampon du réseau coté client en attente de leur

114
sollicitation par ce dernier via la méthode Read, ce qui veut dire qu’on ne stocke dans
la mémoire qu’une seule ligne ; c’est pourquoi il faut utiliser le DataReader pour lire
une grande quantité de données qu’on ne peut ou ne veut mettre dans la mémoire ou
si on a besoin d’accéder rapidement aux données.

Le DataReader fonctionne en mode ForwardOnly ReadOnly, c.-à-d., qu’l ne permet

que de lire les données et non pas les manipuler, et ce en avant seulement.

Le DataSet, quant à lui, est comme une base de données mais qui réside en mémoire.
Le DataSet repose sur le modèle relationnel même s’il peut recevoir des données de
sources différentes. Le DataSet fonctionne en mode déconnecté, et c’est le
DataAdapter qui permet de lui fournir des données issues d’une base de données et
inversement renvoyer des données depuis le DataSet vers la base de données.

Accès en écriture
 Ouvrir la Connexion
 Exécuter la Commande
 Libérer les ressources utilisées par la commande
 Fermer la connexion

Accès en lecture unitaire

 Ouvrir la Connexion
 Exécuter la Commande et l’affecter à un Reader
 Tant qu’on n’a pas encore atteint la fin du Reader
 Lire à partir du Reader
 Libérer les ressources utilisées par la commande
 Fermer la connexion

Accès en lecture de masse

 Ouvrir la Connexion
 Créer la commande et la relier à un Adapter
 Créer le DataSet et y mettre la table issue de l’Adapter
 Parcourir les différentes lignes de la table dans le
DataSet et pour chaque ligne traiter les différentes
colonnes.
 Libérer les ressources utilisées par la commande
 Fermer la connexion
Différentes bases de données
L’espace de nom System.Data, qui représente l’architecture ADO.NET, fournit tous
les moyens pour communiquer avec des bases de données de différents types que ce

115
soit Access, SQL Server ou Oracle, etc. Pour ce faire, l’architecture ADO.NET offre les
namespaces suivants, à utiliser selon le type de la source des données :

Provider Details
SQL Server .NET Found in the System.Data.SqlClient namespace.
Data Provider
Recommended for middle-tier applications using Microsoft SQL
Server version 7.0 or later.

Recommended for single-tier applications using the Microsoft Data

Engine (MSDE) or Microsoft SQL Server 7.0 or later.

For Microsoft SQL Server version 6.5 and earlier, you must use the
OLE DB Provider for SQL Server with the OLE DB .NET Data
Provider.
OLE DB .NET Data Found in the System.Data.OleDb namespace.
Provider
Recommended for middle-tier applications using Microsoft SQL
Server 6.5 or earlier, or any OLE DB provider that supports the OLE
DB interfaces listed in OLE DB Interfaces Used by the OLE DB
.NET Data Provider in the .NET Framework SDK. (OLE DB 2.5
interfaces are not required.)

For Microsoft SQL Server 7.0 or later, the .NET Framework Data
Provider for SQL Server is recommended.

Recommended for single-tier applications using a Microsoft® Access

database. Use of an Access database for a middle-tier application is
not recommended.

Support for the OLE DB Provider for ODBC (MSDASQL) is

disabled. For access to Open Database Connectivity (ODBC) data
sources, an ODBC .NET Data Provider download is available and
will be included in the .NET Framework SDK version 1.1.
ODBC .NET Data The ODBC .NET Data Provider for is available for download.
Provider
Found in the Microsoft.Data.Odbc namespace.

Provides access to data sources that are connected to using an ODBC

driver.

Note The ODBC .NET Data Provider will be included in upcoming

versions of the .NET Framework starting with version 1.1. The
namespace for the included ODBC .NET Data Provider is
System.Data.Odbc.
.NET Data Provider The Microsoft .NET Data Provider for Oracle is available for
for Oracle download.

116
 Found in the System.Data.OracleClient namespace.

Provides access to Oracle data sources (version 8.1.7 and later).

Note The .NET Data Provider for Oracle will be included in

upcoming versions of the .NET Framework starting with version 1.1.
Custom .NET Data ADO.NET provides a minimal set of interfaces to enable you to
Provider implement your own .NET Framework data provider. For more
information about creating a custom data provider, see Implementing
a .NET Data Provider in the .NET Framework SDK.
SQLXML Managed The release of XML for Microsoft SQL Server 2000 (SQLXML 3.0)
Classes contains SQLXML Managed Classes that enable you to access the
XML functionality of Microsoft SQL Server 2000 and later, from the
.NET Framework. For example, these classes enable you to execute
XML templates, perform XML Path Language (XPath) queries over
data at the server, or perform updates to data using Updategrams or
Diffgrams.

Building on the functionality from SQLXML 1.0 and 2.0, SQLXML

3.0 introduces Web Services to SQL Server 2000. With SQLXML
3.0, Stored Procedures and XML Templates can be exposed as a Web
Service through SOAP.

SQLXML 3.0 is available for download.

Nous allons nous intéresser à la communication entre nos applications VB.NET et le

SGBD SQL Server. Pour ce faire, nous allons inclure le namespace
System.Data.SqlClient qui est st le fournisseur de données .NET Framework pour
SQL Server.

Ouvrir la connexion
L’opération d’ouvrir et de fermer la connexion est commune pour les trois types de
communication (l’accès en écriture, l’accès en lecture avec DataReader et l’accès en
lecture avec DataSet).

Informations nécessaires pour établir la connexion

Pour se connecter à une base de données quelconque, on a besoin de ces informations :

1. Le serveur hébergeant la base de données

2. Le nom de la base de données
3. Les informations de login

1 – Le serveur hébergeant la base de données

On fournit cette information de deux manière différente comme suit :

117
 Data Source Server Address Addr Network Address
Par exemple :
Server=myServerAddress

Server=myServerName\myInstanceName

Data Source=myServerAddress

Data Source=190.190.200.100,1433

Addr=myServerAddress

Address=myServerAddress

2 – Le nom de la base de données

On fournit cette information de deux manière différente comme suit :

Initial Catalog Database

Par exemple :
Database=myDataBase

Initial Catalog=myDataBase

3 – Les informations de login

Ici on choisit de se connecter au serveur SQL Server avec son compte Microsoft ou
celui créé sur SQL Server.

Si on choisit d’utiliser l’authentification Windows, alors on fournit l’information

suivante :
Integrated Security=true

ou

Trusted_Connection=true

Les valeurs reconnues sont true, false, yes, no, et sspi (fortement recommandé), ce qui
est équivalent à true. La valeur par défaut est false.

Sinon, c.-à-d. si on choisit de se connecter avec le compte SQL Server, on fournit les
informations suivantes :
User ID ou UID

et

Password ou PWD

Pour se connecter à une base de données SQL Server on crée un objet de la classe
SqlConnection.

Les constructeurs
118
  SqlConnection()
Public Sub New
 SqlConnection(String)
Public Sub New (
connectionString As String
)
 SqlConnection(String, SqlCredential)
Public Sub New (
connectionString As String,
credential As SqlCredential
)

coneectionString est une chaîne de connexion qui contient toutes les informations
nécessaires à la connexion. Ces informations sont séparées par ;

Par exemple :

"Data Source=localhost\SQLExpressRed1; Initial Catalog=GestionBiblio; Integrated

Security=true;"

Donc, on peut instancier la classe SqlConnection de ces deux manières :

119
 Dim ObjetConnection As SqlConnection
ObjetConnection = New SqlConnection()
Dim strConn As String
strConn = "Data Source=localhost\SQLExpressRed1; Initial Catalog=GestionBiblio; Integrated
Security=true;"
ObjetConnection.ConnectionString = strConn
Dim strConn As String
strConn = "Data Source=localhost\SQLExpressRed1; Initial Catalog=GestionBiblio; Integrated
Security=true;"
Dim ObjetConnection As SqlConnection
ObjetConnection = New SqlConnection(strConn)
Comme on peut raccourcir ces codes comme suit :
Dim ObjetConnection As SqlConnection = New SqlConnection()
ObjetConnection.ConnectionString = "Data Source=localhost\SQLExpressRed1; Initial
Catalog=GestionBiblio; Integrated Security=true;"
strConn = Dim ObjetConnection As SqlConnection = New SqlConnection("Data
Source=localhost\SQLExpressRed1; Initial Catalog=GestionBiblio; Integrated Security=true;"
)

Ouvrir la connexion
ObjetConnection.Open()

Fermer la connexion
ObjetConnection.Close()

Accès en écriture
Ce qui reste pour établir une communication entre l’application VB.NET et le serveur
SQL Server, pour effectuer une écriture dans la base de données, est de créer un objet
SqlCommand qui servira pour exécuter la commande SQL désirée. Il faut libérer les
ressources occupées par cet objet une fois l’exécution terminée.

Exécuter la Commande
La classe fournie par ADO.NET qui permet d’exécuter une commande SQL ou une
procédure stockée sur la base de données est SqlCommand.

Cette classe possède cinq constructeurs différents. Intéressons-nous aux deux

suivants :

120
  SqlCommand()
Public Sub New
 SqlCommand(String, SqlConnection)
Public Sub New (
cmdText As String,
connection As SqlConnection
)

Comme on a vu avec les constructeurs de la classe SqlConnection, si on utilise le

constructeur sans paramètres, il va falloir les fournir par la suite par le biais de
propriétés de la classe.

Les deux paramètres nécessaires sont :

cmdText qui représente le texte de la commande, et connection qui est un objet de la

classe SqlConnection qui représente la connexion à une instance de SQL Server ; c’est
ce que nous avons vu dans le paragraphe précédent.

Par exemple :
Dim Requete As String = "requête SQL"
Dim Commande As New SqlCommand(Requete, objetConnexion)
Après avoir instancier la classe SqlCommand en lui fournissant la requête à exécuter,
il suffit maintenant d’exécuter cette commande. Pour ce faire on fait appel à la méthode
ExecuteNonQuery() de la classe SqlCommand.

Par exemple :
Commande.ExecuteNonQuery()
Cette méthode retourne le nombre de lignes affectées.

Libérer les ressources utilisées par la commande

La méthode utilisée pour cette fin est Dispose().

Par exemple :
Commande.Dispose()
Récapitulation de la démarche pour un accès en écriture
Supposons qu’on veut se connecter à partir d’une application VB.NET en mode
console à son serveur SQL Server local ayant comme instance SQLServerRed1 pour
ajouter un produit à la table Article de la base de données GestionCom.

La requête en SQL est :

INSERT INTO Article(DesArt, PUArt, QteEnStock, SeuilMinimum, SeuilMaximum)
VALUES('Jaouda Milk', 13, 150, 20, 800);
Le code complet est comme suit :

121
 Imports System.Data.SqlClient
Module Module1

Sub Main()

Console.WriteLine("Début du programme.")
Dim Connexion As New SqlConnection("Data Source=localhost\SQLServerRed1;
Initial Catalog=GestionCom; Integrated Security=true;")
Connexion.Open()
Dim Requete As String = "INSERT INTO Article(DesArt, PUArt, QteEnStock,
SeuilMinimum, SeuilMaximum) VALUES('Jaouda Milk', 13, 150, 20, 800);"
Dim Commande As New SqlCommand(Requete, Connexion)
Commande.ExecuteNonQuery()
Commande.Dispose()
Connexion.Close()
Console.WriteLine("Fin du programme... Tapez une touche pour quitter.")
Console.ReadLine()
End Sub

End Module

Accès en lecture avec DataReader

Ici, la commande Transact-SQL doit être SELECT.

La nouvelle classe dont on aura besoin est :

SqlDataReader
Après avoir créé l’objet de type SqlCommand (appelé par exemple Commande) en lui
attribuant la requête et l’objet de type SqlConnection, on exécute la commande. La
méthode à utiliser est ExecuteReader. Cette méthode retourne un objet de la classe
SqlDataReader ; donc, il faut qu’on stocke la valeur de retour de cette méthode dans
un objet de la classe SqlDataReader (appelé par exemple MonReader) comme suit :
Dim MonReader As SqlDataReader = Commande.ExecuteReader

Après, on fait appel à la méthode Read de cet objet (MonReader) pour pouvoir lire la
ligne suivante. Cette méthode retourne une valeur booléenne : true, s’il existe des
lignes supplémentaires, false, sinon. La ligne retournée est stockée dans notre objet
MonReader. L’appel à MonReader("nom_du_champ") permet de récupérer la valeur
de cette colonne pour la ligne en cours. On peut aussi utiliser les indices à la place des
noms des colonnes, la première colonne est d’indice 0.

122
Le code complet est comme suit :
Imports System.Data.SqlClient

Module Module1

Sub Main()
Console.WriteLine("Début du programme ..." & vbCrLf & vbCrLf)
Dim Connexion As New SqlConnection("Data Source=localhost\SQLServerRed1;
Initial Catalog=GestionCom; Integrated Security=true;")
Connexion.Open()

Dim Requete As String = "SELECT PUArt FROM Article;"

Dim Commande As New SqlCommand(Requete, Connexion)

Dim MonReader As SqlDataReader = Commande.ExecuteReader

'Console.WriteLine(MonReader(1))
'cette instruction génère une erreur car il n'y a qu'une seule colonne
retournée par Select

While (MonReader.Read)
Console.WriteLine(MonReader(0))
End While

Commande.Dispose()
Connexion.Close()

Console.WriteLine("Fin du progrmme." & vbCrLf & "Tapez Entrée pour quitter

...")
Console.ReadLine()
End Sub

End Module

Accès en lecture avec DataSet

Ici tout se passera comme avec l’accès en écriture ou l’accès en lecture avec DataReader
jusqu’à la création de l’objet SqlCommand, c.-à-d.
Dim Commande As New SqlCommand(Requete, Connexion)

Après cette instruction, il faut qu’on relie cet objet SqlCommand à un nouvel objet de
la classe SqlDataAdapter qui, comme son l’indique, permet d’adapter les données
reçues pour les communiquer au DataSet :
Dim Adaptateur As New SqlDataAdapter(Commande)
La classe SqlDataAdapter définit quatre constructeurs comme suit :
 SqlDataAdapter()
 SqlDataAdapter(SqlCommand)
 SqlDataAdapter(String, SqlConnection)
 SqlDataAdapter(String, String)

123
L’envoie des données reçues à l’objet DataSet se fait en appelant la méthode Fill de
l’objet SqlDataAdapter. Cette méthode, comme son l’indique, permet de remplir le
DataSet par les données issues de l’exécution de la commande SELECT.

Il y en a quatre surcharge de cette méthode :

Fill(DataSet) Adds or refreshes rows in the DataSet.

Adds or refreshes rows in a specified range in the DataSet to
Fill(DataSet, Int32, Int32, String) match those in the data source using the DataSet and
DataTable names.
Adds or refreshes rows in the DataSet to match those in the
Fill(DataSet, String)
data source using the DataSet and DataTable names.
Adds or refreshes rows in a specified range in the DataSet to
Fill(DataTable)
match those in the data source using the DataTable name.
Adds or refreshes rows in a DataTable to match those in the
Fill(Int32, Int32, DataTable()) data source starting at the specified record and retrieving
up to the specified maximum number of records.
Pour effectuer la liaison entre le DataSet et la base de données afin de répercuter les
modifications du DataSet à la base de données, il faut utiliser un binding entre le
DataSet et la base de données, comme suit :
Dim monComBuild As SqlCommandBuilder
monComBuild = New SqlCommandBuilder(Adaptateur)
Adaptateur.Update(MonDataSet, "lesLignesDeCommandes")

124
Le code complet est comme suit :
Imports System.Data.SqlClient
Module Module1
Sub Main()
Dim Connexion As New SqlConnection("Data Source=localhost\SQLServerRed1;
Initial Catalog = GestionCom; Integrated Security = True;")
Connexion.Open()
Dim Requete As String = "SELECT * from LigneCommande"
Dim Commande As New SqlCommand(Requete, Connexion)
Dim Adaptateur As New SqlDataAdapter(Commande)
Dim MonDataSet As New DataSet
Adaptateur.Fill(MonDataSet, "lesLignesDeCommandes")
Console.WriteLine("Nombre de colonnes : " &
MonDataSet.Tables(0).Columns.Count)
Console.WriteLine("Nombre de lignes : " & MonDataSet.Tables(0).Rows.Count)
Console.WriteLine("----------------------" & vbCrLf)
For j As Integer = 0 To MonDataSet.Tables(0).Columns.Count - 1
Console.Write(LSet(MonDataSet.Tables(0).Columns(j).ToString, 13))
Next
Console.WriteLine()
Dim counter As Integer
For counter = 0 To MonDataSet.Tables(0).Columns.Count - 2
Console.Write("-------------")
Next
For lettre = 1 To MonDataSet.Tables(0).Columns(counter).ToString.Length
Console.Write("-")
Next
Console.WriteLine()
For k As Integer = 0 To MonDataSet.Tables(0).Rows.Count - 1
For m As Integer = 0 To MonDataSet.Tables(0).Columns.Count - 1
Console.Write(LSet(MonDataSet.Tables(0).Rows(k)(m), 13))
Next
Console.WriteLine()
Next
Commande.Dispose()
Connexion.Close()
Dim nomTable As String
Dim numLigne, numColonne, valeur As UShort
Console.Write("Donnez le nom de la table où effectuer la modification: ")
nomTable = Console.ReadLine()
Console.Write("Donnez le numéro de la ligne à modifier: ")
numLigne = Console.ReadLine()
Console.Write("Donnez le numéro de la colonne à modifier: ")
numColonne = Console.ReadLine()
Console.Write("Donnez la nouvelle valeur: ")
valeur = Console.ReadLine()
MonDataSet.Tables(nomTable).Rows(numLigne).Item(numColonne) = valeur

Dim monComBuild As SqlCommandBuilder

monComBuild = New SqlCommandBuilder(Adaptateur)
Adaptateur.Update(MonDataSet, "lesLignesDeCommandes")

Console.WriteLine("Fin du programme. Tapez Entrée pour quitter ...")

Console.ReadLine()
End Sub
End Module

L’objet DataSet est une collection dobjets de type DataTable. Pour y accéder, on utilise
la propriété du DataSet appelée Tables qui est de type DataTableCollection :

125
 MonDataSet.Tables

Pour obtenir le nombre de tables dans le DataSet :

MonDataSet.Tables.Count

Pour accéder aux différentes tables, on le fait soit avec l’indice, soit avec le nom de la
table :
MonDataSet.Tables(0)

MonDataSet.Tables("lesLignesDeCommandes")

MonDataSet.Tables.Item(0)

MonDataSet.Tables.Item("lesLignesDeCommandes")

Pour ajouter une table au DataSet :

MonDataSet.Tables.Add()

MonDataSet.Tables.Add(unObjetDataTable)

MonDataSet.Tables.Add("leNomDeLaTable")

Pour supprimer une table du DataSet :

MonDataSet.Tables.RemoveAt(indiceDeLaTable)

MonDataSet.Tables.Remove(unObjetDataTable)

MonDataSet.Tables.Remove("leNomDeLaTable")

Pour vider la collection DataSet.Tables qui est de type DataTableCollection :

MonDataSet.Tables.Clear()

Chaque DataTable comporte une collection d’objet de type DataRow et une autre
collection de type DataColumn.

Pour les propriétés de DataRows :

Item(DataColumn)

Item(DataColumn, DataRowVersion)

Item(Int32)

Item(Int32, DataRowVersion)

Item(String)

Pour les propriétés de DataColumns :

ColumnName

DataType

DefaultValue

126
 MaxLength

Ordinal

Table

Unique

Exemple expliquant les différents composants de DataSet :

127
Exemple de code utilisant le composant DataGridView avec liaison
avec la base de données
Imports System.Data.SqlClient
Public Class Form1
Dim chaineDeConnexion As String
Dim connexion As SqlConnection
Dim commande As SqlCommand
Public adaptateur As SqlDataAdapter
Dim monDataSet As DataSet
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
chaineDeConnexion = "Data Source=localhost\SQLServerRed1; Initial Catalog =
GestionCom; Integrated Security=true;"
connexion = New SqlConnection(chaineDeConnexion)
connexion.Open()
Dim requete As String
requete = "SELECT * FROM Article;"
commande = New SqlCommand(requete, connexion)
'Dim adaptateur As SqlDataAdapter
adaptateur = New SqlDataAdapter(commande)
monDataSet = New DataSet
adaptateur.Fill(monDataSet, "lesArticles")
'---------------------------------------------------------------------------
---
DGV1.DataSource = monDataSet.Tables("lesArticles")
DGV1.AutoSize = True
End Sub

Private Sub DGV1_CellValueChanged(sender As Object.........) ..........

cmdSave.Enabled = True
End Sub

Private Sub DGV1_RowsAdded(sender As Object.........) ..........

cmdSave.Enabled = True
End Sub

Private Sub DGV1_RowsRemoved(sender As Object.........) ..........

cmdSave.Enabled = True
End Sub

Private Sub cmdSave_Click(sender As Object.........) ..........

Dim cmdBuild As SqlCommandBuilder
cmdBuild = New SqlCommandBuilder(adaptateur)
adaptateur.Update(monDataSet.Tables("lesArticles"))
End Sub
End Class

128
Chapitre 11

La programmation Orientée Objet

Public Class Point

Implements IComparable
Private x As Single
Private y As Single
Public Shared nbreDePoints As Integer = 0

Sub New(ByVal x, ByVal y)

Me.x = x
Me.y = y
nbreDePoints += 1
End Sub

Sub New()
Me.x = 0
Me.y = 0
nbreDePoints += 1
End Sub

Protected Overrides Sub Finalize()

MessageBox.Show("Bye Class Point !")
End Sub

Public Property xP() As Single

Get
Return x
End Get
Set(ByVal value As Single)
x = value
End Set
End Property

Public Property yP() As Single

Get
Return y
End Get
Set(ByVal value As Single)
y = value
End Set
End Property

Public Overloads Function compareTo(ByVal obj As Object) As Integer Implements

IComparable.CompareTo

End Function
End Class

129
Imports System.Collections

Public Class Temperature

Implements IComparable
' The temperature value
Protected temperatureF As Double

Public Overloads Function CompareTo(ByVal obj As Object) As Integer _

Implements IComparable.CompareTo

If obj Is Nothing Then Return 1

Dim otherTemperature As Temperature = TryCast(obj, Temperature)

If otherTemperature IsNot Nothing Then
Return Me.temperatureF.CompareTo(otherTemperature.temperatureF)
Else
Throw New ArgumentException("Object is not a Temperature")
End If
End Function

Public Property Fahrenheit() As Double

Get
Return temperatureF
End Get
Set(ByVal Value As Double)
Me.temperatureF = Value
End Set
End Property

Public Property Celsius() As Double

Get
Return (temperatureF - 32) * (5/9)
End Get
Set(ByVal Value As Double)
Me.temperatureF = (Value * 9/5) + 32
End Set
End Property
End Class

Public Module CompareTemperatures

Public Sub Main()
Dim temperatures As New ArrayList
' Initialize random number generator.
Dim rnd As New Random()

' Generate 10 temperatures between 0 and 100 randomly.

For ctr As Integer = 1 To 10
Dim degrees As Integer = rnd.Next(0, 100)
Dim temp As New Temperature
temp.Fahrenheit = degrees
temperatures.Add(temp)
Next

' Sort ArrayList.

temperatures.Sort()

For Each temp As Temperature In temperatures

Console.WriteLine(temp.Fahrenheit)
Next
End Sub
End Module

130
' The example displays the following output to the console (individual
' values may vary because they are randomly generated):
' 2
' 7
' 16
' 17
' 31
' 37
' 58
' 66
' 72
' 95

131
Public Class Form1
Dim chkTest As Boolean = False
Private Sub Button1_MouseClick(sender As Object, e As MouseEventArgs) Handles
Button1.MouseClick
MessageBox.Show("Mouse Click")
End Sub

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click

MessageBox.Show("Click")
End Sub

Private Sub Button1_DoubleClick(sender As Object, e As EventArgs) Handles

Button1.DoubleClick
'Dosn't work. No sense
MessageBox.Show("Double Click")
End Sub

Private Sub CheckBox1_CheckedChanged(sender As Object, e As EventArgs) Handles

CheckBox1.CheckedChanged
If chkTest Then
MessageBox.Show("Option non choisie")
chkTest = False
Else
MessageBox.Show("Option choisie")
chkTest = True
End If
End Sub

Private Sub CheckedListBox1_SelectedIndexChanged(sender As Object, e As EventArgs)

Handles CheckedListBox1.SelectedIndexChanged
MessageBox.Show(CheckedListBox1.SelectedIndex.ToString & vbCrLf _
& CheckedListBox1.SelectedItem.ToString)
End Sub

Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click

If True Then
Dim myPoint As Point
myPoint = New Point(5, 8)
MessageBox.Show(myPoint.Equals(New Point(5, 8)))

MessageBox.Show(myPoint.ToString)
MessageBox.Show(myPoint.xP & vbCrLf & myPoint.yP)

Dim p2 As Point
p2 = myPoint
MessageBox.Show(myPoint.Equals(p2))
MessageBox.Show(myPoint.compareto(p2))
End If
End Sub

Private Sub Button3_Click(sender As Object, e As EventArgs) Handles Button3.Click

MessageBox.Show(Point.nbreDePoints)
End Sub
End Class

132
Me, My, MyBase et MyClass en Visual Basic ont des noms semblables, mais des fonctions
différentes. Cette rubrique décrit chacune de ces entités de façon à les distinguer.

Me
Le mot clé Me permet de faire référence à l'instance spécifique d'une classe ou d'une structure
dans laquelle le code est en train de s'exécuter. Me se comporte comme une variable objet ou
comme une variable de structure faisant référence à l'instance actuelle. L'utilisation de Me est
particulièrement utile pour le passage des informations concernant l'instance d'une classe ou
d'une structure en cours d'exécution, à une procédure se trouvant dans une autre classe, une
autre structure ou un autre module.

Par exemple, supposons que vous ayez la procédure suivante dans un module.

Sub ChangeFormColor(FormName As Form)

Randomize()
FormName.BackColor = Color.FromArgb(Rnd() * 256, Rnd() * 256, Rnd() *
256)
End Sub

Vous pouvez appeler cette procédure et passer l'instance actuelle de la classe Form en tant
qu'argument à l'aide de l'instruction suivante.

ChangeFormColor(Me)

My
La fonction My offre un accès facile et intuitif à plusieurs classes du .NET Framework, ce qui
permet à l'utilisateur de Visual Basic d'interagir avec l'ordinateur, l'application, les
paramètres, les ressources, etc.

MyBase
Le mot clé MyBase se comporte comme une variable objet faisant référence à la classe de
base de l'instance actuelle d'une classe. MyBase est couramment utilisé pour accéder aux
membres de la classe de base qui sont substitués ou occultés dans une classe dérivée.
MyBase.New est utilisé pour appeler explicitement un constructeur de classe de base à partir
d'un constructeur de classe dérivée.

MyClass
Le mot clé MyClass se comporte comme une variable objet faisant référence à l'instance
actuelle d'une classe telle qu'elle a été implémentée initialement. MyClass est semblable à
Me, mais tous les appels de méthode effectués sur celui-ci sont traités comme si la méthode
était NotOverridable.

133