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

Ecrivez-moi !
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 MECI (Université Paris 7)            

 
 
 
  
 
 
 
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 effet, tout objet (donc, tout contrôle) peut être stocké dans une variable du type de cet objet (donc de ce contrôle). Plus exactement, Tout objet peut être pointé, et donc manipulé, par une variable du type adéquat. 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, avant qu'on utilise la varaible (oeuf corse). Traditionnellement, le plus lisible est de placer cette déclaration tout au début de la procédure, 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 est 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. Là aussi, un peu de sens pratique ne saurait nuire. Mieux vaut donc 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.
  • 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 plutôt que faire l'impasse sur ce qui va suivre, meux vaut saisir à pleines mains cette occasion de 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. 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 celles-ci ont été conçues de manière à recouvrir à peu près 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 ne pas être trop dépaysé, 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
5.1.1 Les couples Fonctions / Méthodes
  • 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)
    ou
    Resultat = "Super, ça boume !".Substring(10, 4)
    Naturellement, l'exemple ci-dessus marche aussi bien avec des variables qu'avec des chaînes libellées en clair. Cependan, vous n'aurez pas manqué de remarquer le proverbial sens de l'humour des gagmen de Redmond, puisque dans un Mid, les caractères sont comptés à partir de 1, tandis que dans un Substring ils le sont à partir de zéro. Sacré Bilou, va !
  • 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. Si Phrase est une chaîne et qu'on a besoin de récupérer sa longueur pour la balayer par une boucle, on poura donc indifféremment utiliser le mode d'écriture traditionnel et faire appel à une fonction :
  • For i = 1 to Len(Phrase)
    ...ou opter pour une écriture plus « objet » et employer une méthode :
    For i = 1 to Phrase.Length
    Ayé, vous avez pigé le truc ? Ben ensuite, c'est toujours sur le même principe.
  • À la fonction Instr(chaîne1, chaîne2) qui renvoie la position de chaîne2 dans chaîne1 (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.
5.1.2 Fonctions sans méthodes équivalentes
Certaines fonctions, toutefois, pour des raisons parfaitement obscures appartement à M. Petitmou et à lui seul, 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)
5.1.2 Méthodes sans fonctions équivalentes
Inversement, et de manière tout aussi incompréhensible pour les esprits rationnels, quelques méthodes 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  : cette méthode assemble 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 en ce qui concerne son utilité pour les fichiers texte.
5.1.4 Comparer des chaînes de caractère
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 projet, 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 à ne pas décider du type de comparaison à utiliser une fois pour toutes, au niveau du projet, mais le faire au coup par coup, à chaque fois qu'on devra comparer des chaînes. Pour cela, on utilisera au choix la fonction StrComp ou la méthode String.Compare. Dans un cas comme dans l'autre, on passera les deux chaînes à comparer en paramètres, et on fixera le troisième argument à False (si l'on souhaite une comparaison « binary ») ou à True (si l'on souhaite 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.
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
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.
5.4.1 La fonction InputBox
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, correspondant bien sûr au texte qui aura été entré par l'utilisateur dans la zone de saisie. 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 :
  1. 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").
  2. d'autre part, 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. Chacune des possibilités de boutons et d'illustrations énumérées ci-dessus est associée par VB à une valeur entière (qu'on ne peut connaître qu'en allant fouiller l'aide dans la rurique idoine). Dès lors, pour choisir tel jeu de bouton, il suffit d'entrer comme argument l'entier correspondant. De même pour choisir une des quatre illustrations disponibles. Et pour associer tel jeu de bouton à telle illustration, il suffira d'additionner les deux valeurs correspondantes. Miracle de l'intelligence petitmollienne, ces 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 vraiment intéressant, c'est qu'on n'est pas obligé de spécifier l'argument sous la forme d'un nombre entier, une forme d'écriture laborieuse et sybilline aussi bien pour celui qui écrit le programme que pour celui qui le relit. Le deuxième argument (et le résultat) d'une fonction MsgBox existent en effet sous la forme d'une énumération, et on peut donc les écrire (ou les récupérer) en tant que membres de cette énumération.
Traduisons.
Définition utile :
Une énumération est une association entre des mots-clés du langage et des nombres entiers. Lors de la compilation, ces mots-clés sont donc remplacés par les enties dont ils sont considérés par la machine comme des équivalents.
Le membre d'une énumération est l'un de ces mots-clés, équivalent donc à un entier déterminé.
Pour entrer le deuxième argument de la MsgBox, point besoin donc d'aller se perdre dans l'aide pour trouver le ou les entiers qui nous faut. En lieu et place, nous allons pouvoir entrer au clavier le nom de notre énumération, à savoir MsgBoxStyle, suivi d'un point. Et là, ô (faux) miracle, s'ouvrira une liste déroulante avec, sous forme de mots-clés, toutes les options possibles. Et si l'on veut à la fois des boutons et une icône ? Eh bien, rappelons-nous que les membres de l'énumération sont en réalité des nombres entiers : on peut donc les additionner sans que le compilateur y trouve quoi que ce soit à redire.
Ainsi, la boîte de message figurant plus haut, qui pouvait ê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 pouvait 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)
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.
Ce résultat, lui aussi, s'exprime sous deux formes.
  • la première, pas très pratique à manipuler, est celle d'un nombre entier correspondant au bouton en question (là encore, consultation de l'aide obligatoire pour savoir quel bouton est associé à quel entier.
  • la seconde, beaucoup plus commode, celle d'un membre de l'énumération des résultats de MsgBx, à savoir l'énumération MsgBoxResult.
Si vous avez compris ce qui précède, vous ne devriez avor aucun mal à vous orienter. Un petit tour dans l'aide nous montre par exemple que le bouton « Oui » est ainsi associé à la fois au nombre 6 et au membre Yes de l'énumération MsgBoxResult. Dès lors, pour tester par exemple si lors de l'affectation via la fonction MsgBox de la variable rep de tout à l'heure, l'utilisateur a cliqué sur le bouton Oui, on pourra indifférement écrire :
If rep = 6 Then
...Ce qui n'est pas d'une limpidité absolue, soit préférer :
If rep = MsgBoxResult.Yes Then
Ce qui va nettement mieux (et qui est à peine plus long à taper, l'éditeur de code de VB complétant au fur et à mesure à partir des premières lettres.
Assez ri. Il est grand temps de vous dégourdir les neurones avec quelques petits exercices.

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