Variables, procédures, arguments et structures de contrôle

1. - 1 -
PARTIE II
ELEMENTS DU LANGAGE VISUAL BASIC .NET
1 VARIABLES, PROCEDURES, ARGUMENTS ET STRUCTURES DE CONTROLE
1.1 POINTS ABORDES
 L'organisation du code en Modules
 La notion de procédure (procédures et fonctions)
 Variables, constantes, types de données et conversions
 Opérateurs et expressions
 Les structures de contrôle (tests, boucles et instruction Select)
 Parcourir une collection avec une boucle For Each
 Travailler avec les objets (instanciation, variables de type valeur et variables de type référence)
 Le contrôle ListBox
1.2 TRAVAILLER AVEC LES MODULES
Lorsqu'une série d'instructions apparaît à des endroits différents dans le code, il est d'usage de la placer dans
une procédure. Le découpage d'un traitement en procédures allège non seulement l'application en évitant de
dupliquer du code, mais aide surtout à la maintenance de l'application. La mise au point d'une procédure
spécialisée dans l'accomplissement d'une tâche est toujours beaucoup plus facile à effectuer que celle d'un
long bloc d'instructions réalisant plusieurs tâches.
Pour cela, on écrit des procédures dites "générales", c'est à dire qui ne sont associées ni à un événement, ni à
un objet particulier. Ce type de procédure se stocke dans un module standard.
1.2.1 CREER UN MODULE STANDARD
Un programme en VB .NET est toujours composé en un ou plusieurs modules. Chaque module contient des
procédures et correspond physiquement à un fichier ayant l’extension '.vb'.
Il existe trois types de modules:
 Les modules de formulaire
 Les modules standards
 Les modules de 'Classe'

2. - 2 -
Nous allons, maintenant, décourir comment créer un module standard :
 Créez un nouveau projet de type Application Windows en le nommant LangageVB
 Renommez le formulaire Form1 en frmLangageVB.
 Sélectionnez la commande Projet/Ajouter un module.
 Sélectionnez le modèle Module et cliquez sur le bouton Ouvrir pour créer un module standard en
acceptant le nom Module1.vb proposé par défaut.

3. - 3 -
1.2.2 CREER UNE PROCEDURE GENERALE
Le nom d'une procédure générale peut être choisi librement à condition:
 qu'il commence par une lettre
 qu'il ne comporte pas d'espace ni de signe de ponctuation
 qu'il soit différent des mots réservés de Visual Basic et des noms d'objets qui font apparaître la liste de
leurs membres lorsqu'ils sont suivis d'un point.
 Une procédure générale est aussi appelée "procédure" tout court
EXERCICE: CREATION DE LA PROCEDURE AFFICHERDATE
 Tapez Sub AfficherDate et appuyez sur Entrée pour créer la définition de la procédure (Visual Basic
ajoute automatiquement l'instruction End Sub)
 Tapez l'instruction suivante :
MsgBox("Nous sommes le : " & DateTime.Now)
1.2.3 CREER UNE FONCTION
Une fonction est une procédure qui retourne un résultat. Il suffit de remplacer le mot Sub par Function pour
obtenir une fonction.
Le résultat calculé par une function se récupère par l'instruction Return.
EXERCICE: CREATION DE LA FONCTION SURFACECERCLE QUI CALCULE LA SURFACE D'UN
CERCLE
 Tapez Function SurfaceCercle et appuyez sur Entrée pour créer la définition de la fonction (Visual
Basic ajoute automatiquement l'instruction End Function).
 Tapez l'instruction suivante :
Return 3.14 * 5 ^ 2
Note: Le rayon a été fixé à la valeur 5.

4. - 4 -
 On peut remplacer 3.14 par une valeur plus précise de PI grâce à System.Math.PI
1.2.4 L'INSTRUCTION EXIT
Permet de terminer une procédure prématurément avant d'atteindre l'instruction End.
Exemple: Exit Sub ou Exit Function
1.2.5 APPELER UNE METHODE
On a vu trois types de procédures:
 Les procédures associées aux gestionnaires d'événements
 Les procédures générales (appelées "procédures" tout court)
 Les fonctions
L'appel de chaqu’un de ces types de procédures est différent. Contrairement aux procédures associées aux
gestionnaires d'événements, une procédure générale, ou une fonction ne s'exécutera jamais
automatiquement. Elle devra être appelée explicitement.
EXERCICE: APPEL DE LA PROCEDURE AFFICHERDATE
 Ajoutez un bouton de commande de nom de btnAfficherDate sur le formulaire Form1, et entrez
"&Afficher la date" dans la propriété Text de ce bouton.
 Tapez AfficherDate() dans le gestionnaire de l'événement Click de ce bouton
Private Sub btnAfficherDate_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs)
Handles btnAfficherDate.Click
AfficherDate()
End Sub
 Tapez "Le langage Visual Basic" dans la propriété Text du formulaire
 Lancez le projet et cliquez sur le bouton Afficher la date
1.2.6 APPELER UNE FONCTION
EXERCICE: APPEL DE LA FONCTION SURFACECERCLE
 Ajoutez un bouton de commande de nom de btnSurfaceCercle sur le formulaire Form1, et entrez
"&Surface d'un cercle" dans la propriété Text de ce bouton.
 Tapez l'instruction suivante dans le gestionnaire de l'événement Click de ce bouton

5. - 5 -
MsgBox(SurfaceCercle())
 Tapez "Le langage Visual Basic" dans la propriété Text du formulaire
 Lancez le projet et cliquez sur le bouton Surface d'un cercle
1.3 LES VARIABLES
Une variable est un emplacement réservé en mémoire, dont la valeur peut changer au cours de l’exécution
d’un programme. Elles peuvent contenir des mots, des nombres, des dates, des propriétés ou d’autres valeurs
grâce auxquelles vous donnez un nom court et facile à mémoriser à chaque donnée avec laquelle vous
souhaitez travailler.
L’utilisation des variables dans un programme Visual Basic .NET demande une certaine planification. Avant de
pouvoir utiliser une variable, il vous faut réserver de l’espace pour son utilisation. Ce procéssus s’appelle
« Déclaration de variable »
1.3.1 DECLARER UNE VARIABLE
Les noms de variables peuvent être choisis librement, à condition :
 qu'ils soient onstitués de lettres et de chiffres sans signe de ponctuation (excepté "_")
 qu'ils commencent par une lettre
 qu'ils soient différents des mots réservés et des noms d'objets
Une variable se déclare avec l'instruction Dim et
La déclaration devrait se situer avant sa première utilisation grâce à l’instruction Dim.
Attention :
La déclaration de variables est obligatoire dans ce cours
1.3.1.1 OPTION EXPLICIT
L'option Explicit force la déclaration des variables. Cette option est activée par défaut dans Visual Basic .NET
(inactive par défaut dans VB6, ce qui crée des problèmes de performances et des bugs).
L'option Explicit peut être modifé à partir de l'onglet Compiler dans la boite de dialogue des propriétés
colmmunes du projet.

6. - 6 -
1.3.1.2 EXEMPLE PRECEDENT AVEC UNE DECLARATION DE VARIABLE
Function SurfaceCercle()
Dim Resultat
Resultat = 3.14 * 5 ^ 2
Return Resultat
End Function
1.3.2 LA FENETRE LISTE D'ERREURS
Cette fenêtre nous permet de voir la liste des erreurs détectées par Visual Studio .NET.
Exemple:
 Mettez la déclaration de la variable résultat en commentaire
 Notez ce qui se passe
Note :
Vous pouvez accéder à l'emplacement de l'erreur en double-cliquant dessus.

7. - 7 -
1.4 LES TYPES DE DONNEES
Le typage sert à préciser la nature de l'information qu’on pourra stocker dans une variable. Le type d'une
variable se définit avec le mot réservé As, suivis du nom du type souhaité.
Exemple:
Dim Resultat As Single
Plusieurs variables peuvent être déclarées sur une seule ligne:
Dim i, j As Integer
Attention :
Il faut toujours donner un type aux variables.
1.4.1 DECOUVRIR LES DIFFERENTS TYPES DE DONNEES
Tous les langages disponibles dans l'environnement .NET ont les mêmes types de données. Et ils sont tous
implémentés dans l'espace de noms System.
Le tableau suivant illustre les types de données Visual Basic, leurs types Common Language Runtime pris en
charge, leur allocation de stockage nominal et leur plage de valeurs.
Visual
Basic type
.NET Runtime type structure
Storage
size
Value range
Boolean System.Boolean 4 bytes True or False
Byte System.Byte 1 byte 0 to 255 (unsigned)
Char System.Char 2 bytes 0 to 65535 (unsigned)
Date System.DateTime 8 bytes January 1, 1 CE to December 31,
9999

8. - 8 -
Decimal System.Decimal 12 bytes +/-
79,228,162,514,264,337,593,543,950,
335 with no decimal point; +/-
7.9228162514264337593543950335 with
28 places to the right of the
decimal; smallest non-zero number
is +/-
0.0000000000000000000000000001
Double System.Double 8 bytes -1.79769313486231E308 to -
4.94065645841247E-324 for negative
values; 4.94065645841247E-324 to
1.79769313486232E308 for positive
values
Integer System.Int32 4 bytes -2,147,483,648 to 2,147,483,647
Long System.Int64 8 bytes -9,223,372,036,854,775,808 to
9,223,372,036,854,775,807
Object System.Object(class) 4 bytes Any type can be stored in a
variable of type Object
Short System.Int16 2 bytes -32,768 to 32,767
Single System.Single 4 bytes -3.402823E38 to -1.401298E-45 for
negative values; 1.401298E-45 to
3.402823E38 for positive values
String System.String(class) 10 bytes +
(2 *
string
length)
0 to approximately two billion
Unicode characters
User-
Defined
Type
(structure
)
(inherits
fromSystem.ValueType
)
Sum of the
sizes of
its
members
Each member of the structure has a
range determined by its data type
and independent of the ranges of
the other members

9. - 9 -
1.4.2 L'INITIALISATION DES VARIABLES
L'initialiation des variables peut se faire dès leur déclaration.
Exemple:
Dim i As Integer = 7
Dim s As String = "Bonjour !"
Petite question :
Que comportent les variables non initialisées des types suivants:
 Boolean
 Numérique (integer, decimal, double ...)
 String
1.4.3 LE TYPE BOOLEAN
Le type Boolean accepte l'un des deux mots réservés: True ou False. True a la valeur 1 et False a la valeur 0.
Note importante :
L'emploi des valeurs à la place des mots réservés est à proscrire pour développer des applications évolutives.
Elles rendent en effet le code dépendant de cette codification, qui peut changer d'une version à l'autre.
1.4.4 LES TYPES STRING ET CHAR
Les variables String sont de longueur variable. Les types Char, quant à eux, stockent un seul caractère Unicode.
Si un seul caractère doit être traité, le type char est plus performant que le type String.
La codification Unicode des caractères
Cette codification a été définie et normalisée dans le but de codifier l'ensemble des caractères des différents
alphabets utilisés dans le monde. Un caractère Unicode occupe deux octets de mémoire.
1.4.5 LES TYPES SHORT, INTEGER ET LONG
Visual Basic .NET introduit la notion de codage sur 64 bits pour les variables numériques. Voici les nouveautés
comparé à VB6 :
 Short 16 bits remplace le type Integer 16 bits
 Integer 16 bits devient le type Integer 32 bits
 Long de 32 bits passe à 64 bits
1.4.6 LES TYPES SINGLE, DOUBLE ET DECIMAL
Single:
Signifie "simple précision". C’est une valeur exprimée en virgule flottante, dont 7 chiffres seulement sont
significatifs. Elle convient pour des valeurs comportant une partie décimale qui ne demande pas une grande
précision.

10. - 10 -
Double:
Signifie "double précision". Double est adaptée au stockage de valeurs qui demandent une très grande
précision.
A éviter dans la mesure du possible, car ce type est très gourmand en mémoire.
Decimal:
Prend en charge jusqu'à 29 chiffres significatifs et peut représenter des valeurs allant jusqu'à 7.9228 x 10^28.
Adapté aux calculs financiers qui ne peuvent tolérer d'erreurs d'arrondi.
Decimal remplace le type Currency de VB6.
1.5 LES CONSTANTES
Ce sont les valeurs qui ne changent pas lors de l'exécution d'un programme. Elles peuvent être déclarées à
l'aide du mot réservé Const et leur initialisation se fait lors de cette déclaration.
Les constantes peuvent être de type booléen, numérique, chaîne de caractères et date
Exemples:
Const Pi = 3.14
Const NomFichier = "MODELE.DOC"
Const Reveillon = #12/31/2010#
Intérêt des constantes:
Elles améliorent la lisibilité du code (nom plus significatifs pour les valeurs). En changeant la valeur d'une
constante, on change cette valeur dans tout notre programme. Au lieu de le faire pour chaque occurrence de la
valeur dans notre code.
1.5.1 EXEMPLE
Nous allons remplacer la valeur 3.14 dans la fonction SurfaceCercle de notre exemple précédent par une
constante:
Function SurfaceCercle()
Dim Resultat As Single
Const PI = 3.14
Resultat = PI * 5 ^ 2
Return Resultat
End Function

11. - 11 -
1.5.2 LES CONSTANTES PREDEFINIES
Visual Basic .NET Equivalent en
VB6
Description
ControlChars.CrLf vbCrLf Combinaison de retour chariot et de saut de ligne
ControlChars.Cr vbCr Caractère de retour chariot
ControlChars.Lf vbLf Caractère de saut de ligne
ControlChars.NewLine vbNewLine Caractère de saut de ligne
ControlChars.NullChar vbNullChar Caractère Null.
Nothing vbNullString Différent d'une chaîne de longueur nulle ("") ; utilisé pour l'appel
de procédures externes
ControlChars.Tab vbTab Caractère de tabulation
ControlChars.Cr vbCr Caractère de retour chariot
ControlChars.FormFeed vbFormFeed Non utilisé dans Microsoft Windows
EXEMPLE
Voici comment afficher un message par l'instruction MsgBox sur deux lignes:
MessageBox.Show("Première ligne" & vbCr & "Deuxième ligne")
Ou
MessageBox.Show("Première ligne" & ControlChars.Cr & "Deuxième ligne")
1.5.3 L'OPTION STRICT
L'option Strict empêche toute conversion restrictive involontaire. Elle empêche aussi les conversions implicites
effectuées entre les types numériques et String
Exemple:
Sub ConversionRestrictive()
Dim d As Double
Dim s As Single
d = 0.123456789
s = d
'Affiche 0.1234568
MessageBox.Show(s)
End Sub
Résultat: 0.1234568 (tronqué)

12. - 12 -
L'option Strict peut être modifiée dans l'onglet Compiler de la boîte de dialogue des propriétés communes du
projet.
Si on met l'option Strict à On, seules les conversions effectuées explicitement seront autorisées.
s = d est souligné dans le code pour signaler une conversion interdite. (Par contre d=s est acceptée car on passe
d'une variable à une variable plus précise)
Il faudra maintenant, pour notre exemple, écrire :
s = CType(d, Single)
1.6 LES VARIABLES OBJETS
1.6.1 LE MOT RESERVE NEW
Rappel:
l'opération qui consiste à créer un objet à partir de sa classe s'appelle une "instanciation"
L'instanciation se réalise à l'aide du mot réservé New.

13. - 13 -
1.6.1.1 EXEMPLE
Dim Rayon As Integer
Dim Carre As Rectangle
Dim Cercle As Graphics
Rayon = 50
'Utilisation du mot réservé New pour l'instancier un objet
Carre = New Rectangle(Me.ClientSize.Width - 100,
Me.ClientSize.Height - 100, 100,
100)
Cercle = Me.CreateGraphics
'La classe Pens n'a pas besoin d'être instanciée du fait que ses membres
'sont statiques
Cercle.DrawEllipse(Pens.Black, Carre)
Carre et Cercle ne sont plus des types de données, mais des types d'objets issus de la classe Rectangle et Graphics.
1.6.2 LES VARIABLES DE TYPE VALEUR OU REFERENCE
Une variable de type valeur contient réellement une valeur en mémoire. Par contre, une variable de type
référence s'emploie pour un objet et elle ne contient pas l'objet lui même, mais son adresse en mémoire.
Note :
L'adresse d'un objet occupe 4 octets quel que soit l'objet.
Dans l'exemple précédent, chacune des classes Rectangle et Graphics est instanciée, puis référencée par
les variables Carre et Cercle en une seule instruction.
Carre = New Rectangle(Me.ClientSize.Width - 100,
Me.ClientSize.Height - 100, 100,
100)
Cercle = Me.CreateGraphics
Note :
Tant qu'une variable déclarée avec le type d'un objet n'est pas initialisée, elle contient la valeur spéciale
Nothing.
Nothing indique qu'elle ne référence aucun objet et peut être testée avec l'une des syntaxes suivantes:
If IsNothing(Resultat) Then MessageBox.Show("Nothing")
If Resultat Is Nothing Then MessageBox.Show("Nothing")

14. - 14 -
Les opérations de comparaison et d'affectation ne fonctionnent pas de la même manière pour ces deux types
de variables (Valeur et Référence) :
 L'opérateur de comparaison pour des variables de type valeur est "="
 L'opérateur de comparaison pour des variables de type référence est "Is"
1.6.3 LA NOTION DE MEMBRES STATIQUES
Dans l'exemple précédent, on voit que le classe Pens est utilisée directement sans instanciation. C'est au fait
une caractéristique du membre Black de cette classe :
Cercle.DrawEllipse(Pens.Black, Carre)
Les membres qui peuvent être invoqués directement sans instanciation sont dits "statiques" et se définissent à
l'aide du mot réservé Shared.
1.7 LE TYPE OBJECT
Lorsque le type d'une variable n'est pas précisé, elle possède le type Object. Les deux déclarations suivantes
sont équivalentes:
Dim Resultat
Dim Resultat As Object
Note :
Object remplace le type Variant de VB6.
Une variable de type Object accepte tous les types d'objets existant dans l'environnement .NET. Les écritures
suivantes sont tout à fait correctes:
Dim Resultat As Object
Resultat = "Visual Basic .NET"
Resultat = 12
Resultat = 12.6
Le type Objet correspond à une classe très importante dans l'environnement .NET. Tous les objets accessibles
dérivent indirectement d'elle, y compris les types les plus simples. La syntaxe orientée objet peut donc leur être
appliquée.
Exemple:
Resultat = "Visual Basic .NET"
'Affiche 17
MessageBox.Show(Resultat.length)

15. - 15 -
Attention:
Le type Object ne devrait en aucun cas être utilisé lorsqu'un type spécifique peut être précisé, à cause des
raisons suivantes:
 L'intellisense n'affichera pas les membres du type spécifique dans l'éditeur de code
 L'existence d'un membre qui est invoqué avec une variable de type object ne peut être vérifiée en
mode Design ou à la compilation, mais en mode Run seulement.
 Une dégradation des performances qui découle du fait que la recherche de l'existence du membre
doit se faire à l'exécution
1.7.1 LA FONCTION TYPENAME ET L'OPERATEUR TYPEOF IS
TypeName et TypeOF sont réspectivement une fonction et un opérateur qui permettent de connaître le type
de l'objet référencé par une variable. Sauf que:
TypeName
Retourne le type sous forme de chaîne de caractère.
TypeOf
Permet de comparer le type de la variable avec un type tel qu'il se définit à la suite du mot réservé As dans une
déclaration de variable.
Note :
TypeOf est plus rapid à l'exécution puisqu’il traîte des types naturels de l’environnement .NET.
Exemple:
Dim o As Object
o = "VB .NET"
'Affiche "String"
MessageBox.Show(TypeName(o))
If TypeOf o Is String Then
MsgBox("o est de type String")
End If
1.7.2 LE TYPE DE LA VALEUR RETOURNEE PAR UNE FONCTION
Le type de la valeur retournée par une fonction peut être n'importe quel type d'objet valide, y compris un
tableau. Nous allons, dans l’exemple ci-dessous, donner un type au résultat de notre fonction
SurfaceCercle:

16. - 16 -
Function SurfaceCercle() As Single
Dim Resultat As Single
Const PI = 3.14
Resultat = PI * 5 ^ 2
Return Resultat
End Function
1.8 LES OPERATION DE CONVERSION
1.8.1 CONVERTIR VERS LE TYPE STRING
Tous les types de données héritent la méthode ToString de la classe Object. ToString permet de
convertir une variable en type String.
Exemple :
Dim s As String
Dim I As Integer = 5
s = i.ToString
1.8.2 CONVERTIR DU TYPE STRING VERS UN TYPE NUMERIQUE
Tous les types numériques possèdent une méthode statique nommée Parse. Elle permet d'analyser et de
convertir une chaîne de caractère en un type numérique.
Dim s As String
Dim I As Integer = 5
'Convertir une chaîne vers le type Integer
s = "12"
i = Integer.Parse(s)
1.8.3 CONVERTIR DEUX TYPES QUELCONQUES
La fonction CType permet de convertir le type d'une variable, quel que soit son type:
Dim s As String
Dim I As Integer= 5
'Convertir une chaîne vers le type Integer
s = "12"
i = CType(s, Integer)

17. - 17 -
1.9 LES ARGUMENTS DE PROCEDURES
Les arguments d’une procédure permettent de la paramétrer. Nous allons illustrer ce mécanisme dans les
points qui suivent.
1.9.1 DEFINIR LES ARGUMENTS D'UNE PROCEDURE
Revenons à notre fonction SurfaceCercle de tout à l'heure. Nous allons, maintenant, la modifier pour
qu'elle puisse accepter n'importe quel rayon comme argument:
Function SurfaceCercle(ByVal Rayon As Single) As Single
Dim Resultat As Single
Const PI = 3.14
Resultat = PI * Rayon ^ 2
Return Resultat
End Function
A retenir :
Le mot réservé ByVal, indiqué en jaune, permet de transmettre l'argument par valeur.
1.9.2 TRANSMETTRE UN ARGUMENT A UNE PROCEDURE
Nous pouvons maintenant donner à l'utilisateur la possibilité d'entrer une valeur pour le rayon ensuite la
transmettre à la fonction SurfaceCercle.
Nous allons donc réécrire la procédure btnSurfaceCercle_Click de la manière suivante:
Private Sub btnSurfaceCercle_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs)
Handles btnSurfaceCercle.Click
Dim RayonSaisi As String
RayonSaisi = InputBox("Entrez la valeur du rayon")
MsgBox(SurfaceCercle(RayonSaisi))
End Sub
1.9.3 DEFINIR UN ARGUMENT OPTIONNEL
Un paramètre ou argument peut être optionnel, c'est à dire facultatif.
Le mot réservé Optional Indique que cet argument n'est pas requis lorsque la procédure est appelée. Si ce
mot clé est utilisé, tous les arguments suivants doivent aussi être facultatifs et déclarés à l'aide du mot clé
Optional.

18. - 18 -
Chaque déclaration d'argument facultative doit indiquer une valeur par défaut qui sera utilisée dans la routine
s'il n'y a pas de paramètre.
Sub MaRoutine (Optional X As Integer = 0)
Exemple:
Function Puissance(ByVal N As Integer,
Optional ByVal Exposant As Integer = 0)
If Exposant = 0 Then
Puissance = N ^ 2
Else
Puissance = N ^ Exposant
End If
End Function
1.9.4 LES ARGUMENTS NOMMES
La fonction InputBox possède quatre paramètres optionnels. Le premier sert à personnaliser le titre de la boîte
de dialogue. Le deuxième à proposer une valeur par défaut et Les deux derniers servent à préciser la position
en X et Y de la boite.
Si nous devons, par exemple, proposer le caractère 5 comme valeur par défaut, sans nous soucier du titre
affiché, nous devons écrire ceci:
RayonSaisi = InputBox("Entrez la valeur du rayon", , "5")
Les deux virgules sont nécessaires car il faut respecter l'ordre des arguments.
Alternative:
On peut utiliser les arguments nommés et ainsi réecrire notre code, selon la signature de InputBox, comme
ceci :
RayonSaisi = InputBox(DefaultResponse:="5", Prompt:="Entrez la valeur du rayon")

19. - 19 -
1.10 LES OPERATEURS
1.10.1 LES DIFFERENTS TYPES D'EXPRESSIONS
Visual Basic .NET est capable de calculer toutes sortes de types d'expressions: Expressions numériques, chaînes
de caractères, Date, ou Boolean. Une expression peut être une combinaison de constantes, de variables, de
fonctions et d'opérateurs.
Les opérateurs sont évalués dans l'ordre de priorité suivant:
Opérateurs arithmétiques et de concaténation
Exponentiation (^)
Négation unaire (-)
La multiplication et la division (*, /)
La division entière ()
Module arithmétique (Mod)
Addition et soustraction (+, -), la concaténation de chaînes (+)
Concaténation (&)
Décalage de bits arithmétique (<<,>>)
Opérateurs de comparaison
Tous les opérateurs de comparaison (=, <>, <, <=,>,> =, Like, Est, Est TypeOf ...)
Opérateurs logiques bit à bit et
Négation (Non)
Conjonction (Et, AndAlso)
Disjonction (ou, Orelse, XOR)
L'opérateur de concaténation (&) n'est pas un opérateur arithmétique, mais en priorité, il est groupé avec les
opérateurs arithmétiques.
EXEMPLE:
2 + 3 * 5 = 17
(2 + 3) * 5 = 25
1.10.2 LES OPERATEURS DE COMPARAISON
Permettent de comparer deux valeurs numériques ou deux chaînes de caractères. Le résultat d'une
comparaison est toujours de type Boolean: True (Vrai) ou False (Faux).

20. - 20 -
Exemple :
Dim A As Integer = 2
Dim B As Integer = 3
If A = B then
..
End If
Liste des opérateur de comparaison:
= égal
> supérieur à
< inférieur à
>= supérieur ou égal
<= inférieur ou égal
<> Différent de
1.10.3 LES OPERATEURS LOGIQUES
Les opérateurs logiques permettent de comparer des expressions booléennes et retournent un résultat
booléen. En bref, les opérateurs logiques sont des opérateurs qui retournent un résultat vrai ou faux sur une
expression conditionnelle. Le tableau ci-dessous les résume:
Opérateur Utilisation
Not Négation
And Conjonction
AndAlso Conjonction
Or Disjonction
Orelse Disjonction
Xor Disjonction
1.10.4 LES OPERATEURS D'AFFECTATION
Visual Basic .NET introduit de nouveau opérateurs d'affectation:
Exemple Expression équivalente Résultat pour x = 4
x += 1 x = x + 1 x = 5
x -= 1 x = x - 1 x = 3
x *= 2 x = x * 2 x = 8
x /= 2 x = x / 2 x = 2

21. - 21 -
x = 3 x = x 3 x = 1
x ^= 2 x = x ^ 2 x = 16
1.11 LES STRUCTURES DE CONTROLE
Elles permettent de gérer le déroulement et l'enchaînement des instructions exécutées.
1.11.1 L'INSTRUCTION IF
C'est l'instruction la plus célèbre de l'informatique. Elle permet de créer une structure décisionnelle:
If Condition Then
...
End if
Ceci se traduit par: Si la Condition est vraie alors...
Une instruction (ou un bloc d'instructions) ne peut être s’exécutée que si condition est vraie.
Exemple:
If A = B then
MsgBox("A = B")
End If
Si A = B alors on exécute le bloc de code entre Then et End If, qui affiche dans une fenêtre MessageBox «
A=B »
L'écriture suivante est aussi possible sans le End If:
If A = B Then MsgBox("A = B")
On peut tester une condition fausse grâce à l'opérateur de négation Not.
Exemple:
If Not A = B Then MsgBox("A différent de B")
Si A et B sont différents (Not A=B signifie NON égaux) afficher "A différent de B".

22. - 22 -
La structure IF THEN ELSE
On peut aussi utiliser la structure 'Si..Alors..Sinon' :
If condition then
.. 'effectué si condition vraie
..
Else
..'effectué si condition fausse
..
End if
Exemple:
If A = B then
MsgBox("A = B")
Else
MsgBox("A différent de B")
End If
Ceci se traduit par: Si A = B afficher le message 'A = B' sinon Afficher le message 'A différent de B'.
EXEMPLE
Changeons le code de notre fonction SurfaceCercle pour qu'elle vérifie si la valeur entrée par l'utilisateur
est numérique:
Private Sub btnSurfaceCercle_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles btnSurfaceCercle.Click
Dim RayonSaisi As String
RayonSaisi = InputBox(DefaultResponse:="5",
Prompt:="Entrez la valeur du rayon")
If IsNumeric(RayonSaisi) Then
MsgBox(SurfaceCercle(RayonSaisi))
Exit Sub
End If
End Sub

23. - 23 -
1.11.2 L'INSTRUCTION SELECT CASE
C'est une structure décisionnelle permettant d'exécuter un grand nombre de blocs de code différents en
fonction de la valeur d'une expression :
Select Case expression
Case valeur1
'code effectué si expression = valeur1
Case valeur2
'code effectué si expression = valeur2
Case valeur3
'code effectué si expression = valeur3
..
Case Else
'code effectué dans tous les autres cas
End Select
Attention:
Si expression = valeur1 le code entre Case Valeur1 et Case valeur2 (et uniquement celui là) est
effectué, puis l'exécution saute après à End Select.
EXEMPLE
Nous allons créer un nouveau bouton qui permet d'afficher le nom du jour de la semaine équivalent au numéro
introduit par l'utilisateur:
 Ajoutez un bouton du nom de btnJourSemaine sur le formulaire avec "&Jour semaine" dans la
propriété Text
 Entrez la procédure btnJourSemaine_Click de la manière suivante :
Dim NumJour As String
NumJour = InputBox("Saisir un N° compris entre 1 et 7")
If NumJour = "" Then Exit Sub
Select Case CType(NumJour, Integer)
Case 1
MsgBox("Lundi")
Case 2
MsgBox("Mardi")
Case 3
MsgBox("Mercredi")
Case 4

24. - 24 -
MsgBox("Jeudi")
Case 5
MsgBox("Vendredi")
Case 6
MsgBox("Samedi")
Case 7
MsgBox("Dimanche")
Case Else
MsgBox("Numéro invalide")
End Select
1.11.2.1 EXERCICE
Réécrivez le même programme qui est dans l'exemple mais en n'utilisant que des structures IF THEN Else.
1.11.3 LA BOUCLE FOR
La boucle For Permet de faire des boucles et ainsi relancer l'exécution d'un bloc de code plusieurs fois. Le
nombre de boucle est déterminé par une variable, qui sert de compteur, initialisée au départ par une valeur de
départ et une valeur d'arrêt.
Pour une variable allant de 'début' à 'fin'
For variable = début To fin
..
Next variable
L'évolution de la variable peut être personnalisée grâce au mot réservé Step.
Exemple :
Dim i as Integer
For i=1 to 10 Step 2
MsgBox i.toString
Next i
'Affiche 1 puis 3 puis 5 puis 7 puis 9

25. - 25 -
EXEMPLE
Nous allons créer un bouton qui permet d'ajouter des valeurs de 1 à 10 dans une liste :
Note :
Le contrôle ListBox ressemple beaucoup au ComboBox sauf que ses éléments sont affichés dès le départ.
ETAPES A SUIVRE:
 Ajoutez un bouton du nom de "btnBoucleFor" et un contrôle ListBox en conservant son nom
ListBox1 dans le formulaire
 Insérez le code suivant dans le gestionnaire d'événement Click de ce bouton:
Dim i As Integer
'Effacer la liste au départ
ListBox1.Items.Clear()
For i = 1 To 10
ListBox1.Items.Add("Valeur " & i.ToString)
Next
1.11.3.1 EXERCICE
Refaites le même exercice, mais cette fois, en affichant les valeurs de la liste dans le sens descendant (Voir
image ci-dessous).

26. - 26 -
1.11.4 LA BOUCLE DO LOOP
Cette structure permet aussi de faire des boucles mais sans que le nombre de boucle (d'itération) ne soit
déterminé au départ.
Cette boucle suivante tourne sans fin:
Do
..
Loop
Il faut une condition d'arrêt qui détermine la sortie de la boucle. Until (Jusqu'à ce que) et While (Tant que)
nous permettent d’introduire cette condition pour terminer la boucle.
Do Until condition
Code
Loop
'Boucler jusqu'à ce que condition soit vraie.
Ou
Do While condition
Code
Loop
'Boucler tant que la condition est vraie.
La condition d’arrêt peut être mise en fin de boucle, cela garantit l’exécution du bloc de code au moins une fois
avant la vérification de la condition.
Do
Code
Loop Until condition
'Boucler jusqu'à ce que condition soit vraie.

27. - 27 -
Ou
Do
Code
Loop While condition
'Boucler tant que la condition est vraie.
EXEMPLE
Nous allons utiliser la boucle Do Loop de manière à proposer automatiquement la saisie d'une nouvelle valeur
en cas de saisie d'un rayon invalide dans la procédure btnSurfaceCercle_Click:
 Ajoutez l'instruction Do avant la ligne de fonction InputBox en début de procédure.
 Ajoutez l'instruction suivante avant MsgBox en fin de procédure:
Loop While Not IsNumeric(RayonSaisi)
Code:
Dim RayonSaisi As String
Do
RayonSaisi = InputBox(DefaultResponse:="5",
Prompt:="Entrez la valeur du rayon")
If IsNumeric(RayonSaisi) Then
MsgBox(SurfaceCercle(RayonSaisi))
Exit Sub
End If
Loop While Not IsNumeric(RayonSaisi)
1.12 LES NIVEAUX DE VISIBILITE
1.12.1 LA PORTEE DES PROCEDURES
Avant le mot Sub ou Function on peut ajouter :
 Private indiquant que la procédure est accessible uniquement dans le module. C'est donc une
procédure privée.
Les procédures liées aux événements d'une feuille sont privées par défaut.
 Public indiquant que la procédure est accessible à partir de toute l'application.
S'il n'y a rien devant Sub, la procédure est publique.

28. - 28 -
Exemple:
Private Function SurfaceCercle(Rayon As Single)
Return 3.14 * Rayon * Rayon
End Function
1.12.2 LA PORTEE DES VARIABLES
Une variable dîtes 'globales' est une variable visible dans la totalité du programme.
Exemple: Créer une variable globale nommée Index.
Module MonModule
'Accéssible dans toute l'application
Public Index As Integer
..
End Module
A l'inverse, une variable 'locale' est visible uniquement dans une procédure ou une classe:
Sub MaProcedure (ByRef X As Integer)
Dim Y As Integer
...
End sub
1.12.2.1 LA SECTION DECLARATION
Elle correspond à la zone de code située dans le module, mais en dehors de toute procédure.

29. - 29 -
Une variable déclarée dans la section Déclaration d'un module est accessible uniquement dans ce module si
elle est privée, ou dans toute l'application si elle est publique.
EXEMPLE
Nous allons compter le nombre de tentatives de saisie invalides effectuées dans la boucle Do Loop chargée de
la saisie du rayon:
 Ajoutez les lignes suivantes après l'instruction Do
Dim NbrTentatives As Integer
NbrTentatives += 1
 Modifiez l'appel de la fonction MsgBox ainsi:
MsgBox("Rayon invalide", MsgBoxStyle.Exclamation,
"Erreur N° " & NbrTentatives)

30. - 30 -
La procédure d'appel de la fonction SurfaceCercle doit ressembler à ceci:
Private Sub btnSurfaceCercle_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs)
Handles btnSurfaceCercle.Click
Dim RayonSaisi As String
Do
Dim NbrTentatives As Integer
NbrTentatives += 1
RayonSaisi = InputBox(DefaultResponse:="5",
Prompt:="Entrez la valeur du rayon")
If Not IsNumeric(RayonSaisi) Then
MsgBox("Rayon invalide", MsgBoxStyle.Exclamation,
"Erreur N° " & NbrTentatives)
End If
Loop While Not IsNumeric(RayonSaisi)
MsgBox(SurfaceCercle(RayonSaisi))
End Sub
1.12.2.2 QUATRE NIVEAUX DE VISIBILITE
Nous disposons maintenant de quatre niveaux de visibilité pour une variable:
1 Si elle est déclarée dans une procédure, à l'intérieur d'un bloc d'instructions, sa visibilité est limitéé à ce
bloc
2 Si elle est déclarée en dehors d'un bloc d'instructions dans une procédure, elle est dite locale et n'est pas
accessible en dehors de cette procédure
3 Si elle est déclarée dans la section déclaration d'un module avec le mot Private, elle est dite privée et
est accessible par toutes les procédures de ce module, mais pas en dehors
4 Si elle est déclarée dans la section déclaration d'un module avec le mot Public, elle est dite publique et
est accessible par toutes les procédures de l'application
1.12.3 LA DUREE DE VIE DES VARIABLES
La portée d'une variable détermine sa durée de vie (le temps pendant lequel elle existe en mémoire). Voici les
règles qui déterminent la durée de vie des variables:
 Les variables, privées ou publiques, déclarées dans la section Déclaration d'un module restent
disponibles tout au long de l'exécution de l'application.
 Les variables locales et de niveau bloc possèdent une durée de vie correspondant au temps
d'exécution de la procédure dans laquelle elles sont déclarées.

31. - 31 -
Remarque:
Les règles de visibilité et de durée de vie des constantes sont les mêmes que celles des variables.
1.12.4 LES VARIABLES STATIQUES
Si à la place de Dim on utilise Static, la variable est dite 'Statique': A la sortie de la procédure, la variable et
sa valeur continue d'exister et on garde sa valeur en mémoire; lors des appels suivants de la procédure, on
retrouve la valeur de la variable.
EXEMPLE
Sub compteur
Dim A as integer
Static B as integer
A += 1
B += 1
End sub
A chaque appel de cette procédure, A prend la valeur 0, puis 1, puis disparaît.
B prend les valeurs 0, puis 1, puis 2... (Incrémentation à chaque appel)
1.13 LA BOUCLE FOR EACH
C'est une variante de la boucle For, mais elle permet de parcourir les objets d'une collection. Sans utiliser
d’indice.
EXEMPLE
Prenons un contrôle ListBox, il a une collection Items qui contient tous les éléments de la ListBox.
 ListBox.item(0) contient la première ligne
 ListBox.item(1) contient la seconde ligne
 ListBox.item(2)…contient la troisième.
 Etc.
Parcourir tous les éléments de la ListBox et les mettre dans une variable V peut se faire facilement grâce à la
structure FOR EACH suivante :
Dim mystring As String
Dim item as Object
For Each item in ListBox.Items
mystring = mystring + item
Next

32. - 32 -
Alternative : La variable de boucle peut être déclarée après For:
Dim mystring As String
For Each item As Objet in ListBox.items
mystring = mystring + item
Next
Attention:
Dans une boucle For Each, lorsqu’on parcourt une collection, on ne peut pas modifier ses éléments.
1.13.1 EXERCICE SUR LE PARCOURS DES COLLECTIONS GRACE A LA BOUCLE FOR EACH
Nous allons illustrer le fonctionnement de la boucle For Each grâce à un petit exercice. Nous allons remplir
un ListBox avec la liste des polices installées dans le système:
 Créez un nouveau projet de type Application Windows en le nommant ListePolices
 Changez le nom de Form1 par frmListePolices
 Saisissez "Boucle For Each et Ctrl ListBox" dans la propriété Text du formulaire
 Ajoutez les contrôles suivants d'après l'image ci-après:
Contrôle Propriété Valeur
ListBox Name ListBox1
Sorted True
ListBox Name ListBox2
Sorted True
Label Name lblListe1
Label Name lblListe2
Button Name btnAjouter
Text "->"
Button Name btnRetirer
Text "<-"
Button Name btnTout
Text ">>"
Button Name btnRien
Text "<<"

33. - 33 -
 Entrez le code suivant dans le gestionnaire d'événement Load du formulaire:
Dim PolicesSysteme As New System.Drawing.Text.InstalledFontCollection
Dim NomsPolice() As FontFamily = PolicesSysteme.Families
With ListBox1.Items
.Clear()
Dim police As FontFamily
For Each police In NomsPolice
.Add(police.Name)
Next
lblListe1.Text = .Count.ToString & " élément(s)"
lblListe2.Text = "0 élément(s)"
End With
 Exécutez le projet et vous aurez la liste de toutes les polices installées sur votre système

34. - 34 -
1.13.2 LE CONTRÔLE LISTBOX
Nous allons maintenant voir comment récupérer l'élément sélectionné par l'utilisateur grâce à l'événement
SelectedIndexChanged.
 Double-cliquez sur le contrôle ListBox1 pour atteindre l'événement SelectedIndexChanged et
entrez le code suivant:
Private Sub ListBox1_SelectedIndexChanged(ByVal sender As System.Object,
ByVal e As System.EventArgs)
Handles ListBox1.SelectedIndexChanged
Dim s As String
Dim Item As Object
'Afficher l'élément sélectionné et son index
s = "SelectedItem : " & ListBox1.SelectedItem.ToString
s = s & vbCr & "SelectedIndex : " & ListBox1.SelectedIndex
MsgBox(s)
End Sub
 Exécutez le projet et cliquez sur un des éléments de la liste.

35. - 35 -
À retenir:
L'élément sélectionné dans un ListBox et son index s'obtiennent respectivement grâce aux propriétés
SelectedItem et SelectedIndex.
1.13.3 LE GLISSER-DEPLACER
Nous allons maintenant autoriser le déplacement des éléments de la liste 1 vers la liste 2 grâce au glisser-
déplacer (Drag and Drop en anglais).
 Activez la propriété AllowDrop du contrôle ListeBox2
 Ouvrez le gestionnaire d'événement MouseDown du contrôle ListBox1 et entrez le code suivant:
Private Sub ListBox1_MouseDown(ByVal sender As System.Object,
ByVal e As System.Windows.Forms.MouseEventArgs)
Handles ListBox1.MouseDown
Dim IndexItem As Integer
'Récupérer l'index de l'élément sélectionné
IndexItem = ListBox1.IndexFromPoint(e.X, e.Y)
'Démarrer le glisser après avoir vérifié la valeur de l'index <> -1
If IndexItem <> ListBox.NoMatches Then
ListBox1.DoDragDrop(ListBox1.Items(IndexItem),DragDropEffects.Move)
End If
End Sub

36. - 36 -
Remarque:
Remarquez la nouvelle manière de récupérer l'élément sélectionné dans un contrôle ListBox. En effet, le type
MouseEventArgs de l'argument e de cette procédure associée à l'événement MouseDown, fournit les
coordonnées du point où le clic a été effectué dans le contrôle, avec les membres e.X et e.Y.
Le membre IndexFromPoint nous donne l'index de l'élément cliqué grâce à ses coordonnées X et Y.
Nous allons maintenant contrôler les éléments avant de les accepter dans le contrôle ListBox2 :
 Ouvrez le gestionnaire d'événement DragEnter du contrôle ListBox2 et entrez ce code suivant:
Private Sub ListBox2_DragEnter(ByVal sender As System.Object,
ByVal e As System.Windows.Forms.DragEventArgs)
Handles ListBox2.DragEnter
If e.Data.GetDataPresent(DataFormats.Text) Then
e.Effect = DragDropEffects.Move
Else
e.Effect = DragDropEffects.None
End If
End Sub
L'instruction If va soit affecter Move soit None à la propriété Effect de l'argument e.
La propriété Data nous donne une référence sur la donnée transmise. Elle procède une méthode,
GetDataPresent, qui vérifie si le format spécifié (un des formats acceptés par la classe Clipboard)
en argument et bien le bon.
La Dérnière étape est de déplacer l'élément de la liste 1 à la liste 2.
 Commencez par mettre en commentaire le code de l'événement
ListBox1_SelectedIndexChanged
 Entrez le code suivant associé au gestionnaire de l'événement DragDrop du contrôle ListBox2 :
Private Sub ListBox2_DragDrop(ByVal sender As System.Object,
ByVal e As System.Windows.Forms.DragEventArgs)
Handles ListBox2.DragDrop
Dim Element As String
Dim i As Integer
Element = e.Data.GetData(DataFormats.Text)
ListBox2.Items.Add(Element)
i = ListBox1.FindStringExact(Element)
ListBox1.Items.RemoveAt(i)
End Sub

37. - 37 -
Data nous fournit une référence sur l'objet à déplacer, qu'on récupère grâce à la méthode GetData. On
ajoute l'élément à la deuxième liste grâce à la méthode Add de la collection Items de la liste 2.
La méthode FindStringExact nous retourne l'index de l'élément qui a la même chaîne de caractère que
celle fournie en paramètre (Element), puis on supprime cet élément grâce à son index, en utilisant la méthode
RemoveAt avec ListBox1.
1.13.4 GERER LES SELECTIONS MULTIPLES
Nous allons maintenant autoriser le déplacement de plusieurs éléments à la fois à l'aide des quatre boutons
que nous avons déposé sur le formulaire.
 Mettez en commentaire la procédure ListBox1_MouseDown
 Sélectionnez MultiExtended dans la propriété SelectionMode des contrôles ListeBox1 et
ListeBox2
 Nous allons maintenant écrire la procédure qui s'occupe de l'affichage du nombre d'éléments sur les
deux listes:
Private Sub AfficherNbrElements(ByVal L1 As ListBox,
ByVal L2 As ListBox)
Dim ctlLabel1, ctlLabel2 As Label
If L1 Is ListBox1 Then
ctlLabel1 = lblListe1
ctlLabel2 = lblListe2
Else
ctlLabel1 = lblListe2
ctlLabel2 = lblListe1
End If

38. - 38 -
ctlLabel1.Text = L1.Items.Count.ToString &" élément(s)"
ctlLabel2.Text = L2.Items.Count.ToString &" élément(s)"
End Sub
 Ajoutez la procédure ToutRien qui s'occupe de transférer tous les éléments de la liste :
Private Sub ToutRien(ByVal L1 As ListBox, ByVal L2 As ListBox)
Dim Item As Object
'Ajouter tous les éléments de L1 à L2
For Each Item In L1.Items
L2.Items.Add(Item)
Next
'Supprimer tous les éléments de L1
L1.Items.Clear()
AfficherNbrElements(L1, L2)
End Sub
 Ajoutons la procédure TransfertListe qui fait la même chose mais, en se limitant aux éléments
sélectionnés :
Private Sub TransfertListe(ByVal L1 As ListBox, ByVal L2 As ListBox)
Dim Item As Object
Dim I As Integer
'Ajouter les éléments sélectionnés de L1 à L2
For Each Item In L1.SelectedItems
L2.Items.Add(Item)
Next
'Supprimer les éléments sélectionnés de L1 en commençant par le
'dernier élément.
For I = L1.SelectedIndices.Count – 1 To 0 Step -1
L1.Items.RemoveAt(L1.SelectedIndices(I))
Next
AfficherNbrElements(L1, L2)
End Sub

39. - 39 -
Note :
SelectedIndeces référence une collection qui contient les index de base zéro de tous les éléments
actuellement sélectionnés dans un contrôle ListBox.
 C'est au tour des gestionnaires d'événements des boutons:
Private Sub Button_Click(ByVal sender As System.Object,
ByVal e As System.EventArgs) Handles btnAjouter.Click,
btnRetirer.Click, btnTout.Click, btnRien.Click,
ListBox1.DoubleClick, ListBox2.DoubleClick
Select Case sender.name
Case "btnAjouter"
TransfertListe(ListBox1, ListBox2)
Case "btnRetirer"
TransfertListe(ListBox2, ListBox1)
Case "btnTout"
ToutRien(ListBox1, ListBox2)
Case "btnRien"
ToutRien(ListBox2, ListBox1)
Case "ListBox1"
TransfertListe(ListBox1, ListBox2)
Case "ListBox2"
TransfertListe(ListBox2, ListBox1)
End Select
End Sub
1.14 EN BREF
1. Les types de données sont implémentés dans l'espace de noms System. Ils sont ainsi communs à tous
les langages compatibles avec l'environnement .NET.
2. Une variable peut être initialisée lors de sa déclaration.
3. La déclaration des variables est obligatoire par défaut (Option Explicit).
4. Visual Basic .NET introduit un nouveau niveau de visibilité qui limite la disponibilité d'une variable à un
bloc d'instructions.
5. L'Option Strict, si elle est activée, permet d'améliorer la fiabilité du code en éliminant les
conversions implicites.
6. Les arguments transmis à une procédure sont transmis par valeur par défaut.

40. - 40 -
1.15 ANNEXES
1.15.1 LES MOTS RÉSERVES DU LANGAGE VISUAL BASIC .NET
Les mots clés suivants sont réservés, ce qui signifie que vous ne pouvez pas les utiliser en tant que noms pour
vos éléments de programmation, notamment pour vos variables ou vos procédures. Vous pouvez contourner
cette restriction en plaçant le nom entre parenthèses ([ ]).
LES MOTS RÉSERVÉS DU LANGAGE VISUAL BASIC .NET
AddHandler AddressOf Alias And
AndAlso As Boolean ByRef
Byte ByVal Call Case
Catch CBool CByte CChar
CDate CDec CDbl Char
CInt Class CLng CObj
Const Continue CSByte CShort
CSng CStr CType CUInt
CULng CUShort Date Decimal
Declare Default Delegate Dim
DirectCast Do Double Each
Else ElseIf End EndIf
Enum Erase Error Event
Exit FALSE Finally For
Friend Function Get GetType
GetXMLNamespace Global GoSub GoTo
Handles If If() Implements
Imports (espace de
noms et type .NET)
Imports (espace
de noms XML)
In Inherits
Integer Interface Is IsNot
Let Lib Like Long
Loop Me Mod Module

41. - 41 -
MustInherit MustOverride MyBase MyClass
Namespace Narrowing New Next
Not Nothing NotInheritable NotOverridable
Object Of On Operator
Option Optional Or OrElse
Overloads Overridable Overrides ParamArray
Partial Private Propriété Protected
Public RaiseEvent ReadOnly ReDim
REM RemoveHandler Resume Return
SByte Select Set Shadows
Shared Short Single Static
Step Stop String Structure
Sub SyncLock Then Throw
To TRUE Try TryCast
TypeOf Variant Wend UInteger
ULong UShort Using When
While Widening With WithEvents
WriteOnly Xor #Const #Else
#ElseIf #End #If =
& &= * *=
/ /= =
^ ^= + +=
- -= >>, opérateur
(Visual Basic)
>>=, opérateur
(Visual Basic)
<< <<=