Cours VB.Net - Plus loin avec les objets

Une remarque pertinente ?
Une critique impertinente ?
Un lynchage en règle ?
Une invitation sous les tropiques ?

Conçu et enseigné tel qu'en lui même, avec pertes, fracas et humour de qualité supérieure
par Christophe Darmangeat dans le M2 PISE du Master SSAMECI (Université Paris 7)

Ne manquez surtout pas
mon groupe de rock, les fabuleux
Midnight Jokers !

Jouer du rock c'est bien,
jouer de la country,
c'est bien aussi !
Écoutez aussi les improbables
Moonlight Swampers !

Vous aimez les petites bêtes qui vivent sous l'eau ?
Faites donc un tour vers mes photos sous-marines

Partie 4

Les bases du langage

Maintenant que vous êtes brillamment venus à bout de vos premiers exercices en deux (ou peut-être trois) coups de cuiller à pot, nous pouvons à présent faire une petite halte afin d'accumuler quelques munitions en vue des combats futurs. Nous allons donc lister une série d'instructions de base de Visual Basic, de celles qui servent partout, tout le temps, en tout lieu et dans toutes les positions.

Remarque qui vaut son pesant de lignes de code :
Comme tout langage un tant soit peu récent, VB.Net offre une telle gamme d'instructions que nombre d'entre elles sont redondantes.
Rien que pour faire une boucle, par exemple, il y a au moins cinq écritures possibles. Le but de ce cours n'étant pas de remporter des concours d'érudition (surtout en Visual Basic, il y a tout de même des sujets d'étude plus affriolants), nous ferons ici dans l'utilitaire : pour chaque usage, une instruction, rarement deux, et jamais plus.
Quant aux autres instructions possibles, nous les ignorerons superbement.
Et voilà pour elles.

1. Les variables (déclaration, types et portées)

En VB.Net, à moins d'aller trifouiller l'option adéquate, par défaut, la déclaration de toutes les variables est obligatoire.

Ce qui nous conduit tout droit vers deux problèmes : celui du choix du type de la variable, et celui de sa portée (qu'on a parfois un peu tendance à oublier quand on débute).

1.1 Les types de variables

En ce qui concerne le type, voici le tableau récapitulatif des possibilités offertes par VB.Net :

Type	Plage des valeurs	Taille
Short	-32 768 à 32 767	2 octets
Integer	- 2 147 483 648 à 2 147 483 647	4 octets
Long	-9 223 372 036 854 775 808 à -9 223 372 036 854 775 807 à	8 octets
Single	-3,4028235E+38 à -1,401298E-45 pour les valeurs négatives 1,401298E-45 à 3,4028235E+38 pour les valeurs positives	4 octets
Double	-1,79769313486231570E+308 à -4,94065645841246544E-324 pour les valeurs négatives -4,94065645841246544E-324 à -1,79769313486231570E+308 pour les valeurs positives	8 octets
Decimal	+/- 79 228 162 514 264 337 593 543 950 335 sans chiffre décimal +/- 7,922 816 251 426 433 759 354 395 033 5 avec 28 positions à droite de la virgule	12 octets
Byte	0 à 255	1 octets
Boolean	True / False	2 octets
String	de 0 à environ 230 caractères
Char	1 caractère	2 octets
Date	01/01/1 à 31/12/9999	8 octets
Object	référence à un objet	4 octets + objet

Cela dit, nous verrons au fur et à mesure de ce cours qu'il existe en réalité une pléthore d'autres types, qui sont des déclinaisons du type objet. En fait, tout objet (donc, tout contrôle) peut être stocké dans une variable du type de cet objet (donc de ce contrôle). On y reviendra...

1.2 Portée des variables

En ce qui concerne la portée, voilà le topo : selon la "durée de vie" souhaitée pour une variable, on procèdera à la déclaration de cette variable à différents endroits du code. Il existe en théorie quatre, mais en pratique trois niveaux de portée pour les variables :

Niveau procédure : la variable est créée à chaque exécution de cette procédure, puis détruite à chaque fois que la procédure se termine. Elle ne conserve donc sa valeur qu'à l'intérieur de cette procédure, et pour une seule exécution de cette procédure. Dans ce cas, la déclaration doit être faite à l'intérieur de la procédure, par exemple juste après l'instruction Sub.
Sub Maprocedure()
Dim toto as Integer
End Sub
Niveau Form : la variable est créée dès que la Form est utilisée. Elle reste accessible par toutes les procédures contenues dans cette Form et conserve sa valeur tant que la Form est active en mémoire vive. Dans ce cas, il faut déclarer la variable n'importe où en-dehors d'une procédure de la Form (en pratique, mieux vaut déclarer l'ensemble de ces variables en tête de la Form : les choses étant déjà bien assez compliquées comme cela, inutile d'en rajouter en éparpillant le code un peu partout. A noter que ce qui précède vaut également pour les structures).

Dim toto as Integer

Sub MaProcedure()
...
End Sub

Sub MonAutreProcedure()
...
End Sub

Niveau projet : la variable est accessible à toutes les procédures du projet, quel que soit la Form, la classe ou la structure dans laquelle se trouvent lesdites procédures. Pour ce faire, la déclaration doit être faite dans un module, en employant le mot-clé Public. Un module est un élément de projet, qui comme la Form sera sauvegardé dans un fichier *.vb, mais qui ne peut contenir que du code (donc, pas de contrôles, rien qui soit visible à l'écran).
Public toto as Integer

Respectez les règles d'hygiène !
N'employez pas des variables de longue portée à tort et à travers. Cela gaspille des ressources ! Le principe qui doit vous guider est celui de l'économie de moyens : on ne doit déclarer les variables au niveau Form ou au niveau projet que lorsque c'est nécessaire, et pour tout dire indispensable.

En ce qui concerne les tableaux, rien de bien sorcier. Il suffira d'ajouter dans la déclaration, au nom de la variable, les traditionnelles parenthèses.

Dim MonTableau(15) As Integer

Attention, danger !
Pour les indices des tableaux, la numérotation commence à zéro. Ça, on a l'habitude.
Mais ce qui peut surprendre davantage, c'est que le nombre figurant entre les parenthèses indique la valeur maximale de l'indice, qui ne correspond donc pas au nombre de cases du tableau, mais à ce nombre moins un.
Ainsi, dans l'exemple ci-dessus, j'ai déclaré un tableau de 16 cases (numérotées donc de 0 à 15).
Suffit de le savoir.

Pour ce qui est des tableaux dynamiques, pas de souci particulier. VB.Net gère très bien des déclarations du genre :

Dim MonTableau() As Integer

...qui sera suivie à un moment ou à un autre dans l'application par un :

Redim MonTableau(N)

Là aussi, toutefois, attention ! L'instruction Redim, employée sans plus de précision, écrabouille sauvagement toute valeur qui se trouvait précédemment dans le tableau, chose qui peut s'avérer fort gênante. Si l'on veut pratiquer un redimensionnement sans perdre les données déjà présentes dans le tableau, il suffit de ne pas oublier l'instruction Preserve :

Redim Preserve MonTableau(N)

Et voilà le travail.

1.3 Déclaration, affectation et écritures étranges

VB.Net est un langage qui permet un certain nombre d'instructions très synthétiques, qui condensent en réalité en une seule ligne plusieurs instructions distinctes. L'avantage, c'est que cela permet d'écrire très vite. L'inconvénient, c'est qu'un esprit non averti peut s'y mélanger d'autant plus facilement les crayons.

Avertissons donc.

Traditionnellement, nous avons l'habitude de dissocier la déclaration d'une variable de son affectation (je parle ici des langages civilisés, et pas des trucs de pervers comme le C). Donc, spontanément, nous dirons :

Dim Toto as Integer
...
Toto = 12

Eh bien, VB.Net nous permet d'effectuer ces deux opérations d'un seul coup d'un seul, en écrivant :

Dim Toto as Integer = 12

Ce qui revient à procéder, dans la même instruction, à la déclaration et à l'affectation de la variable.

Encore plus fort : ce que nous avons vu au chapitre précédent, à propos de la propriété Size (mais qui est vrai de toute propriété correspondant non à un type simple, mais à une structure). Normalement, pour créer une nouvelle variable structurée Taille et l'affecter à la propriété Size du contrôle Bouton, nous serions censé écrire :

Dim Taille As New Size
Taille.Width = 200
Taille.Height = 100
Bouton.Size = Taille

Car Width et Height sont les deux champs de la structure Size. Cela dit, nous savons donc que nous pouvons affecter la variable Taille au moment même où nous la déclarons, ce qui donnerait une écriture plus ramassée :

Dim Taille As New Size(200, 100)
Bouton.Size = Taille

Mais là où c'est encore plus fort, c'est que nous pouvons encore raccourcir l'écriture, en affectant la propriété dans le même élan que nous déclarons et affectons la variable Taille (qui du coup, n'a plus besoin d'exister en tant que variable nommée). C'est ce qui donne l'écriture étrange vue au chapitre précédent :

Bouton.Size = New Size(200, 100)

Et voilà le travail. Cela dit, reculer devant ces écritures pour s'en tenir au découpage traditionnel ne doit certainement pas être considéré comme une faute, ni même comme une maladresse.

2. Les opérateurs

Côté opérateurs numériques, on a évidemment les tartes à la crème :

+ : addition
- : soustraction
* : multiplication
/ : division

Mais en plus de la "bande des quatre", on dispose de quelques opérateurs à peine plus exotiques, dont entre autres :

^ : puissance
Mod : modulo
\ : division entière

Les opérateurs booléens, pour leur part, ne brillent pas non plus par leur originalité (on ne s'en plaindra pas) :

And : et
Or : ou
Xor : ou exclusif
Not : non

Enfin, l'unique opérateur caractère est le traditionnel :

& : concaténation

Remarque hygiénique :
Pour des raisons évidentes de clarté du code, je déconseille très vivement l'emploi de l'opérateur d'addition + comme opérateur de concaténation, bien que celui-ci puisse jouer ce rôle (il suffit pour cela qu'il opère deux chaînes de caractères).

3. Les tests

Là, c'est du cake. La forme universelle du test est la suivante :

If expression_booléenne Then
instructions_si_vrai
[Else
instructions_si_faux]
Endif

Évidemment, la partie entre crochets peut être éventuellement omise. Et l'on rencontrera également la forme plus développée (mais tout aussi classique) :

If expression_booléenne Then
  instructions_si_vrai
Elseif expression_booléenne Then
  instructions_si_vrai
Elseif expression_booléenne Then
  instructions_si_vrai
Elseif expression_booléenne Then
  instructions_si_vrai
etc.
Endif

Et voilà : des tests, il n'y a pour ainsi dire rien de plus à dire.

4. Les boucles

Les grands classiques, il n'y a rien de tel. Aussi, après Smoke on the Water, Stairway to Heaven et Sultans of Swing, la maison vous propose la boucle conditionnelle :

While expression_booléenne
instructions
End While

Qui correspond au fameux Tantque... FinTantQue qui a bercé de sa douce mélopée vos longues soirées algorithmiques. Quant à la boucle à compteur, nous aurons sans surprise :

For variable = valeur_initiale to valeur_finale [step pas]
instructions
Next variable

Nous aurons l'occasion de découvrir plus tard d'autres instructions de boucles, particulières à VB.Net. Mais pour un bref moment, ces deux-là suffiront à notre bonheur.

5. Les fonctions prédéfinies

Relevez vos sièges, attachez vos ceintures, et saisissez à pleines mains votre sac en plastique. Nous entrons dans une zone de fortes turbulences.

En abordant les fonctions, nous en venons en effet à une considération qui risque de vous dérouter au premier abord. Mais ne pas faire l'impasse sur ce qui va suivre est une manière de continuer à se familiariser peu à peu avec les concepts propres à la programmation objet. Alors, c'est parti pour le grand frisson.

Une particularité de cette programmation objet, c'est que tout finit par devenir un objet, même quand au départ, ce n'était pas particulièrement le cas. Ainsi, mais ce n'est qu'un exemple parmi bien d'autres, les simples variables ordinaires sont-elles considérées par VB comme des instances des classes (assimilées aux types) qui ont servi à les fabriquer. Autrement dit, les simples variables sont elles aussi traitées comme des objets, avec leur propriétés et leurs méthodes. Une variable de type String est donc, pour VB, également une instance de la classe String. Une variable Integer est également une instance de la classe Integer. Etc.

Or, String, Integer, et toutes les autres classes formées à partir des types simples, sont dotées, comme toutes les autres classes, d'un certain nombre de méthodes. Et ces méthodes ont été forgées de manière à recouvrir les (anciennes) fonctions traditionnelles pour ces variables. De sorte que la plupart des fonctions qui permettaient de manipuler les variables ordinaires existent dorénavant également sous forme de méthodes qui s'appliquent à ces variables (considérées cette fois comme des instances des différentes classes-types).

Ce "doublon" permet au programmeur peu familier de la programmation objet de retrouver à peu près ses petits, et de continuer à utiliser les bonnes vieilles fonctions dont il avait l'habitude. Mais à côté de l'approche traditionnelle, existe donc maintenant une approche "tout objet", qui, sans nul doute, représente l'avenir de cette famille de langages.

Illustrons tout ceci par quelques exemples, car je sens bien que dans le fond, là, près du radiateur, il y en a qui ont décroché et qui roupillent dur.

5.1 Fonctions de chaînes

Mid(chaîne, nombre1, nombre2) : est une fonction bien connue qui renvoie l'extrait de chaîne qui commence au caractère numéro nombre1 et d'une longueur de nombre2 caractères. Cette fonction possède un équivalent sous forme de la méthode Substring. De sorte que pour extraire "boum" à partir de "Super, ça boume !", nous pouvons indifféremment écrire :

Resultat = Mid("Super, ça boume !", 11, 4)

Resultat = "Super, ça boume !".Substring(11, 4)

Naturellement, l'exemple ci-dessus marche aussi bien avec des variables qu'avec des chaînes libellées en clair.

De même, à la traditionnelle fonction Len(chaîne) qui nous renvoie le nombre de caractères de la chaîne, correspond la méthode Length
À la fonction Instr(chaîne1, chaîne2) qui renvoie la position de chaîne2 dans chaîne 1 (la fonction renvoyant 0 si chaîne2 ne se trouve pas dans chaîne1) correspond la méthode IndexOf
À la fonction LTrim(chaîne) qui supprime tous les espaces situés à gauche dans la chaîne, correspond la méthode TrimLeft
À la fonction RTrim(chaîne) qui supprime tous les espaces situés à droite dans la chaîne, correspond la méthode TrimRight
À la fonction Trim(chaîne) qui supprime tous les espaces situés à droite et à gauche dans la chaîne, correspond la méthode Trim.
À la fonction Ucase(chaîne) qui renvoie la chaîne en majuscules, correspond la méthode ToUpper
À la fonction Lcase(chaîne) qui renvoie la chaîne en minuscules, correspond la méthode ToLower
À la fonction Format(chaîne, chaîne de format) qui permet d'obliger la chaîne (ou un nombre) à respecter un certain format d'affichage, correspond la méthode du même nom, Format. Pour ce qui est des spécifications de la chaîne de format, je vous renvoie sur l'aide, parce que sinon, on y est encore au prochain réveillon, et ce soir-là, j'ai prévu autre chose.

Certaines fonctions, toutefois, et pour des raisons parfaitement obscures, n'ont pas été dotées d'équivalent sous forme de méthode. Il s'agit par exemple de :

Chr(nombre) qui renvoie le caractère ayant nombre comme code ASCII.
ChrW(nombre) qui renvoie le caractère ayant nombre comme code Unicode (rappel : le code Unicode, à la différence du code ASCII, est composé de deux octets)

Inversement, et de manière tout aussi incompréhensible pour les esprits rationnels, il existe certaines méthodes qui accomplissent des tâches qui ne sont assumées par aucune fonction, telles :

Remove, qui permet de supprimer des caractères dans une chaîne (en précisant à partir de quel caractère et combien on en supprime)
Insert, qui permet d'insérer une chaîne dans une autre à une position donnée.
Split(caractère) qui éclate la chaîne en un tableau (de chaînes), en fonction du séparateur indiqué par le paramètre caractère. Ceci peut s'avérer pratique pour "découper" un chemin menant à un fichier, par exemple, et récupérer dans un tableau la liste des répertoires et des sous-répertoires en un tournemain. C'est également indispensable pour gérer un fichier texte, VB.Net n'ayant jamais entendu parler d'une chaîne de longueur fixe. On en reparlera...
Join(caractère, tableau de chaînes) qui effectue l'opération inverse : elle constitue une chaîne à partir des chaînes contenues dans le tableau de chaînes passé en paramètre, et en insérant à chaque fois comme séparateur le caractère passé en paramètre. Même remarque pour son utilité pour les fichiers texte.

Il nous reste un dernier problème à traiter avec les chaînes : celui de leur comparaison. En effet, une pelote d'épines classique est de savoir si "bonjour" doit être considéré comme la même chaîne que "BonJour" ou que "BONjoUR". VB nous permet donc de définir une option de comparaison, afin de trancher nous-mêmes dans le lard, et de décider ce qui nous arrange. Nous pouvons donc, une bonne fois pour toutes, régler cette valeur dans les propriétés du projets, par la rubrique Option Compare :

Binary signifiera que les caractères seront évalués d'après leur codage binaire. Majuscules et minuscules seront dès lors traitées comme des caractères différents.
Text signifiera à l'inverse que les caractères seront évalués en tant que tels, et que majuscules et minuscules seront considérées comme représentant le même caractère.

Une autre possibilité consistera à utiliser au choix la fonction StrComp ou la méthode String.Compare, dont nous passerons les deux chaînes à comparer en paramètres, et dont nous fixerons le troisième argument à False (si nous voulons une comparaison "binary") ou à True (si nous voulons une comparaison "text").

StrComp et String.Compare renvoient toutes les deux -1 si la première chaîne est placée avant la seconde dans l'ordre alphabétique, 0 si les deux chaînes sont égales, et 1 si c'est la seconde chaîne qui précède alphabétiquement la première. Cette technique nous permettra de spécifier les options de comparaison non une fois pour toutes, mais à chaque fois, au gré de nos besoins qui peuvent varier au cours d'un même programme.

5.2 Fonctions et méthodes numériques

Là, cela va aller nettement plus vite (personne ne s'en plaindra, et surtout pas moi). Tout d'abord, parce que le nombre de fonctions disponibles et souvent utilisées et nettement moins grand. Mentionnons vite fait bien fait :

CInt : qui est la fonction qui renvoie la partie entière d'un nombre.
Rnd : qui génère un nombre aléatoire compris entre 0 (au sens large) et 1 (au sens strict).

Remarque surprenante :
Visual Basic a du mal à générer de vrais nombres aléatoires. En fait, si l'on ne fait rien, une suite de Rnd dans un programme produira invariablement à chaque exécution la même série de nombres aléatoires !
La parade consiste, avant chaque appel de la fonction Rnd, à passer l'instruction Randomize, toute seule sur une ligne. Cette instruction revient en quelque sorte à donner l'ordre au croupier de battre les cartes avant une distribution...

Je re-signale au passage, et pour en finir avec les fonctions numériques, que la fonction Format, déjà vue à propos des chaînes, s'applique également aux nombres.

5.3 Fonctions de conversion

Visual Basic .Net est globalement très arrangeant sur les types de variables, et le compilateur procèdera de lui-même aux conversions nécessaires chaque fois que le problème se posera. Toutefois, il existe des situations dans lesquelles le programmeur doit effectuer cette conversion, sous peine de voir le compilateur prendre à sa place la mauvaise décision. Citons donc en particulier :

Val(chaîne) : qui convertit les caractères d'une chaîne en nombre. Ainsi, Val("547") deviendra 547. Dans le cas d'une chaîne ne correspondant à aucun nombre, Val renverra zéro. Problème, dès que Val tombe sur un point, un virgule, ou quoi que ce soit du genre, il s'arrête et ne prend que la partie entière. D'où l'intérêt des autres fonctions de conversions, du genre :
CDbl(chaîne) qui convertit une chaîne en réel double. Cette famille de fonctions "C quelque chose" existe pour tous les types de données (il y en a toute une série dont CDbl, CBool, CByte, etc.)

5.4 Fonctions d'interface

La fonction InputBox

Nous allons à présent découvrir deux nouvelles fonctions, qui n'ont aucun équivalent dans les langages traditionnels (procéduraux), car elles sont directement liées au fait que VB soit un langage basé sur l'interface Windows.

La première de ces deux fonctions est celle qui nous permet de faire apparaître une petite boîte de saisie tout ce qu'il y a de plus ordinaire, comportant une zone dans laquelle l'utilisateur pourra entrer une valeur :

Je le répète, il s'agit là d'une fonction, dont les deux arguments de type String correspondent respectivement à l'invite ("Quelle entreprise...") et au titre ("Question pour un champion") de la boîte de saisie. Cette fonction renverra toujours une valeur de type String. Pour obtenir le résultat ci-dessus, on aura donc écrit un code du genre :

a = "Quelle entreprise a conçu Microsoft Word ?"
b = "Question pour un champion"
Rep = Inputbox(a, b)

Ce code attendra que le bouton OK (ou Annuler) soit cliqué, et stockera alors le contenu de la zone de saisie dans la variable Rep.

Remarque triviale, mais on n'est jamais trop prudent
Il serait donc aberrant d'entrer sur une ligne, toute seule, InputBox(a, b).
Cela reviendrait à traiter InputBox comme s'il s'agissait d'une instruction, alors qu'elle est, je le répète, une fonction, c'est-à-dire une valeur.

La fonction MsgBox

La fonction jumelle d'Inputbox, vouée à un usage un peu différent, est la fonction MsgBox. Elle déclenche l'apparition d'une boîte dépourvue de zone de saisie, mais dotée d'un jeu de boutons, et éventuellement d'une illustration standard, du genre :

Là, on retrouve comme arguments l'invite ("Missile thermonucléaire...") et le titre ("Dernière vérification"). Mais entre ces deux paramètres, on doit fournir un argument d'un genre un peu spécial, sur lequel je vais m'arrêter à présent.

Le rôle de cet argument est double : il doit indiquer d'une part quel est le jeu de boutons souhaité, parmi les six disponibles ("Abandonner, Réessayer, Ignorer", "OK", "OK, Annuler", "Réessayer, Annuler", "Oui, Non", "Oui, Non, Annuler"). Il doit également stipuler quelle illustration viendra éventuellement égayer votre boîte à messages, parmi les quatre possibles (Critical, Exclamation, Information, Question). Il est possible d'activer de surcroît quelques autres options, mais nous les laisserons de côté provisoirement. Ce qui compte, c'est de comprendre comment ça marche.

En fait, l'argument attendu est de type Integer. Et chacune des possibilités de boutons et d'illustrations énumérées ci-dessus est associée par VB à une valeur entière. Dès lors, pour choisir tel jeu de bouton, il suffit d'entrer comme argument l'entier correspondant. Et pour associer tel jeu de bouton à telle illustration, il suffira d'additionner les deux valeurs correspondantes. Miracle de l'intelligence petitmollienne, les valeurs ont précisément été choisies pour que toutes les additions donnent des résultats différents, et que la machine puisse s'y retrouver sans ambiguïté possible.

Là où ça devient intéressant, c'est qu'on n'est pas obligé de spécifier l'argument sous la forme d'un nombre entier, laborieux à aller chercher pour celui qui écrit le programme, et encore plus laborieux à comprendre pour celui qui le relit. Cet entier peut donc être écrit sous une forme, celle d'une constante VB.

Définition simple :
Une constante VB est un mot-clé du langage, qui pour le compilateur, équivaut à un entier donné.

Définition savante :
Une constante VB est en réalité le membre d'une énumération.
Vous ne comprenez rien à cette définition ? C'est normal. Je l'ai mise là juste pour pouvoir vous dire dans quelques chapitres que je vous en avais déjà parlé.
Oui, je ne suis qu'un ignoble manipulateur.

Toujours est-il que la boîte de message figurant plus haut peut ainsi être programmée comme :

a = "Missile thermonucléaire activé. Voulez-vous continuer ?"
b = "Dernière vérification"
rep = MsgBox(a, 3 + 32, b)

Ce qui n'est pas très explicite. Mais on peut tout aussi bien - et même mieux - écrire :

a = "Missile thermonucléaire activé. Voulez-vous continuer ?"
b = "Dernière vérification"
rep = MsgBox(a, MsgBoxStyle.YesNoCancel + MsgBoxStyle.Question, b)

Histoire de faire simple, les types de chez Bill ont en fait donné deux séries de noms différents aux mêmes constantes. En fait, pour désigner exactement les mêmes valeurs Integer, on dispose :

d'une part des noms généraux du Framework .NET (ce sont les membres des énumérations)
d'autre part des noms propres à VB (ce sont les constantes VB).

Résultat des courses, on peut tout aussi bien employer les les uns que les autres, et écrire :

a = "Missile thermonucléaire activé. Voulez-vous continuer ?"
b = "Dernière vérification"
rep = MsgBox(a, vbYesNoCancel + vbQuestion, b)

Passons maintenant au résultat de la fonction Msgbox. Quelle valeur celle-ci renvoie-t-elle ? Le résultat d'une fonction Msgbox, c'est le bouton sur lequel l'utilisateur a appuyé pour la faire disparaître. Et c'est ce résultat qui sera stocké dans la variable Rep de mes exemples.

Sous quelle forme ce résultat s'exprime-t-il ? Eh bien toujours pareil, sous la triple forme d'un entier correspondant au bouton en question, d'une constante VB correspondant à cet entier, ou du membre de l'énumération .NET correspondant tout à la fois à l'integer et à la constante VB.

Un petit coup d'oeil sur l'aide nous apprend ainsi que le clic sur le bouton OK correspond au renvoi par MsgBox de la valeur 1, autrement dit du membre MsgBoxResult.OK ou de la constante VB vbOK. De même, le clic sur le bouton Annuler correspond au renvoi par MsgBox de la valeur 2, autrement dit du membre MsgboxResult.Cancel ou de la constante VB vbCancel. Et voilà le travail.

Nous retrouverons en plusieurs occasions le principe des constantes vb et des membres des énumérations. Mais en attendant, amusons-nous un peu :

Exercice	Exécutable	Sources
Compteur
Choix cornélien
Usine à messages

5.5 Les espaces de noms

Nom de nom. Qu'est-ce que c'est encore que ce truc ?

On vient de voir qu'en VB.Net, la plupart des fonctions existent également sous forme de méthodes des classes présentes dans le Framework .Net. Pire, un certain nombre de fonctions (qui n'en sont plus, du coup) n'existent que sous cette forme. C'est un premier point.

Deuxième point, les classes du Framework .Net ne se situent pas toutes au même niveau. Ces classes sont hiérarchisées, un peu comme dans une arborescence (pensez aux répertoires et aux sous-répertoires). Ainsi, il y a quelques classes très générales (avec leur méthodes). Puis il y a des sous-classes de ces classes (avec leur méthodes à elles). Puis il y a des sous-classes de ces sous-classes de ces classes, avec leurs propres méthodes. Et ainsi de suite.

Dans ces conditions, si l'on veut utiliser une méthode d'une sous-classe d'une sous-classe d'une classe, on est censé écrire de la manière suivante :

classe.sous-classe.sous-classe.méthode

Et encore, là, je ne vous le fais qu'avec trois étages de classes. Mais il peut hélas y en avoir davantage. Alors, il existe un moyen d'abréger (et d'alléger) un peu l'écriture : ce sont les fameux espaces de noms.

L'astuce va consister à s'adresser au programme de cette manière : "voilà, au cours des instructions qui vont suivre, j'ai eu la flemme de te donner à chaque fois la série complète des classes et des sous-classes qui mènent aux méthodes que j'ai utilisées. Alors, je te donne une petite liste des classes et sous-classes dont je vais me servir. Chaque fois que tu trouveras un nom de classe et une méthode que tu ne connais pas, fouille donc dans cette liste pour voir si elles ne s'y trouvent pas. Et dis à ton compilateur de me foutre la paix."

Prenons un exemple que nous retrouverons par la suite. Pour connaître la liste des sous-répertoires d'un répertoire donné, l'aide nous apprend que nous pouvons avoir recours à la méthode GetDirectories, qui s'applique à la classe Directory, elle-même dérivée de la classe IO, elle-même membre de la classe System. Du coup, on est censé se cogner l'écriture :

toto = System.IO.Directory.GetDirectories("C:\")

Alors, autre solution : on indique, en tout début de programme, avant même toute procédure, que l'on entend aller chercher des choses dans l'espace de noms (c'est-à-dire dans la classe) System.IO :

Imports System.IO

Ce qui nous permet ensuite, à chaque fois que nous en aurons besoin, d'écrire simplement :

toto = Directory.GetDirectories("C:\")

Savoir manier les espaces de noms peut donc se révéler diantrement utile pour s'épargner de longues recherches. Cette technique n'est donc pas à proprement parler indispensable, mais mieux vaut la connaître.