Tutoriel avancé du langage Visual Basic .NET


Télécharger Tutoriel avancé du langage Visual Basic .NET

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


4

Le langage Visual

4.  Le langage Visual

La conception d’une application Visual Basic se fait initialement en construisant l’interface utilisateur en dessinant les fenêtres et en déposant les composants nécessaires au fonctionnement de l’application à l’aide de l’environnement visuel de Visual Basic. Une fois l’interface utilisateur conçue, le temps vient de spécifier les instructions que l’application doit exécuter à l’aide de code en langage Basic.

Déclaration et utilisation des variables

Un programme est constitué d’événements exécutant des fonctions. Les données et informations traitées par ce programme peuvent être stockées dans la mémoire vive de l’ordinateur afin d’être ultérieurement récupérées pour être traitées ou comparées. Ces différents espaces mémoires utilisables par le programmeur sont appelés variables puisqu’elles stockent des valeurs qui peuvent varier selon le cours d’exécution du programme.

Le programmeur donne des noms aux différentes variables qu’il désire utiliser au sein de son programme afin de pouvoir les distinguer entre elles.  De plus, le programmeur doit spécifier un type de données pour cette variable. Un type de données spécifie au compilateur le type d’informations qui sera tenu au sein de cette variable et les dimensions de l’espace mémoire nécessaires pour contenir ces informations. Le programmeur doit préalablement spécifier au compilateur l’existence d’une variable avant de pouvoir lui assigner une valeur ou en lire la valeur. Le programmeur doit donc procéder à la déclaration de la variable avant de pouvoir l’utiliser. La déclaration de variables s’effectue comme suit :

Dim X As Integer    Dim Nom As String       

Dim a, b, c As System.Int64

 La variable X est un nombre entier.

 La variable Nom est une chaîne de caractères.

 Les variables a, b et c sont des entiers longs.

Le contenu d’une variable peut changer au cours de l’exécution du code. Cependant, une variable ne peut contenir qu’une seule donnée à la fois. On peut parfois nommer ces variables « scalaires » en oppositions aux variables « vectorielles » pouvant contenir plusieurs valeurs que la programmation informatique nomme « tableaux ». Il sera question des tableaux plus loin.

Le nom d’une variable déclarée en Visual Basic doit respecter les critères suivants afin d’être reconnue par le compilateur :

•  Le premier caractère est obligatoirement une   • Aucune distinction n’est appliquée entre les

lettre.    lettres majuscules et minuscules, les deux étant              considérées équivalentes.

•  Le nom peut être constitué de lettres, chiffres    

et du caractère de soulignement  "_".                   • Les accents sont tolérés par Visual Basic

                                                                                mais non conseillés par les bonnes techniques

•  Le nom ne peut excéder 1024 caractères…      de programmation.

mais était-ce vraiment nécessaire de le                            

préciser ?                                                           • Les mots réservés du langage Visual Basic ne

peuvent être utilisés comme noms de variables

( For, If, Select, Next, Function … )

Quoique aucune autre règle formelle autre que celles énumérées précédemment ne soit prévue par Visual Basic au sujet de la nomination des variables, certaines conventions établies par la maturité de la programmation informatique proposent certaines pratiques permettant d’augmenter la lisibilité du code. Une de ces conventions stipule qu’il peut être bon de réserver certains des premiers caractères composants le nom d’une variable afin d’identifier le type de données qu’y sera stocké. Le tableau présente certains exemples mettant en œuvre cette convention :

Type de variable

Exemple

n

Valeur numérique (tous types confondus)

Dim nCompteur As Integer

b

Valeur booléenne

Dim bReponse As Boolean

d

Date

Dim dAujourdhui As Date

obj

Variable-objet

Dim objNet As Object

str     Chaîne de caractères                                     Dim strAdresse As String

La déclaration d’une variable désigne le procédé par lequel le programmeur donne un nom à une espace mémoire dont l’endroit est choisie par le système d’exploitation mais dont la dimension est choisie par le programmeur à l’aide des types de données. Les types de données définissent le type d’information qui sera contenu au sein de la variable ainsi que la manière dont ces informations doivent être traitées et interprétées.

Les variables peuvent manipuler des données de différents types.

•    Les variables numériques peuvent contenir des valeurs numériques entières ou réelles sur lesquelles diverses opérations mathématiques peuvent être effectuées.

nChiffreA = 5 nChiffreB = 10

nChiffreC = (nChiffreA * 2) + nChiffreB

•    Les variables chaînes de caractères peuvent contenir une suite de caractères qui, mis ensembles, forment un mot, une phrase ou une expression. Certaines opérations typiques aux chaînes de caractères peuvent être effectuées sur ces variables. Une nouvelle valeur est attribuée à ce type de variables en incluant les caractères entre deux guillemets ( " " ) :

strNom = "Pinchaud" strVoiture = "Ford Mustang"

MsgBox (strNom & " conduit une voiture " & strVoiture)

•    Les variables dates peuvent contenir des dates. Certaines opérations typiques aux dates peuvent être effectuées sur ces variables. Une nouvelle valeur est attribuée à ce type de variables en incluant la date entre deux dièses ( #  # ):

dNaissance = #15-03-2002#

Notez que deux désignations des types de données sont possibles en Visual . La première utilise les types de données spécifiques à Visual Basic tandis que la seconde, équivalente, utilise les types de données natifs à la plate-forme .NET et reconnus par l’ensemble des langages .NET. 

Type de données VB

Type de données .NET

Taille

Plage de valeurs

Boolean

System.Boolean

1 octet

True ou False

Byte

1 octet

Entiers non-signés de 0 à 255

Char

2 octets

Entiers non-signés de 0 à 65535

Date

System.DateTime

8 octets

Dates du 1er janvier 1 au 31 décembre 9999

Decimal

System.Decimal

12 octets

+/- 79 228 162 514 264 337 593 543 950 335 sans séparateur décimal ; 

+/-7,9228162514264337593543950335 avec 28 chiffres à droite du séparateur décimal ; 

le plus petit nombre différent de zéro est +/0.0000000000000000000000000001.

Single

System.Single

4 octets

Réels -3,402823E38 à -1,401298E-45 pour les valeurs négatives ; 1,401298E-45 à 3,402823E38 pour les valeurs positives

Double

System.Double

8 octets

Réels de -1.79769313486231E308 à  -4.94065645841247E-324 pour les valeurs négatives ; 

Réels de 4.94065645841247E-324 à

1.79769313486232E308 pour les valeurs positives.

Short

System.Int16

2 octets

Entiers de -32 768  à  32 767

Integer

System.Int32

4 octets

Entiers de –2 147 483 648  à  2 147 483 647

Long

System.Int64

8 octets

Entiers de -9 223 372 036 854 775 808  à 9 223 372 036 854 775 807

String

System.String

10 octets + (2 x nbr. de caractères dans la chaîne)

0 à environ 2 milliards de caractères Unicode.

Object

System.Object

4 octets

N'importe quel type peut être stocké dans une variable de type Object.

Même si deux désignations des types de données sont possibles en Visual . celle native à la plate-forme .NET prévoit d’avantage de types de données que celle native à Visual Basic. Ainsi, vous possédez la liberté d’utiliser les types de données de votre choix mais ceux de la plate-forme .NET exploitent mieux ce nouveau système. Par contre, les programmeurs des versions antérieures de Visual Basic seront certainement contents que leurs types de données aient été conservés pour fins de compatibilité antérieure.

Type de données VB

Type de données .NET

Taille

Plage de valeurs

N/a

System.IntPtr

Pointeur sur une variable ou sur une structure.

N/a

System.UIntPtr

Pointeur sur une variable ou sur une structure.

N/a

System.SByte

1 octet

Entiers signés de –128 à 127

N/a

16 octets

Globally Unique Identifier sur 128 bits.

N/a

System.UInt16

2 octets

Entier non-signé de 0 à 65535.

N/a

System.UInt32

4 octets

Entier non-signé de 0 à 4 294 967 295.

N/a

System.UInt64

8 octets

Entier non-signé de 0 à 

184 467 440 737 095 551 615.

N/a

System.TimeSpan

Intervalle de temps.

N/a

N/a

Rien.

Une fois la variable déclarée, le programmeur peut lui assigner une valeur de départ avant de l’utiliser. Le programmeur procède alors à l’initialisation de la variable :

Dim X As Integer

X = 1                                       

Dim Age As System.Int16 = 1

Dim Prix As Single = 10.0

Dim Chaine As String = "Un"

 La variable X est un entier initialisé à 1.

 La variable Age est un entier initialisé à 1.

 La variable Prix est un nombre à virgules initialisé 

à 10.0. 

Si le programmeur n’initialise pas la variable déclarée, celle-ci se voit attribuer la valeur 0 par défaut ou chaîne vide  "" dans le cas des variables de type String .

Pour ceux et celles qui auraient travaillé à l’aide des versions antérieures de Visual Basic, notez qu’il est désormais possible d’initialiser les variables au sein d’une seule et même instruction un peu comme le permet

              depuis longtemps le C. Cependant, notez que la déclaration de variables à la création de trois variables de type Long et non à la création de deux variables de type Dim a, b, c As Long Variant et d’une  procède

dernière variable de type Long comme l’auraient faits les versions antérieures de Visual Basic. De plus, notez que le programmeur est désormais obligé de spécifier un type de données lors de la déclaration des variables.

Déclaration de constantes

Une constante est, comme la variable, un espace-mémoire au sein duquel il est possible d’y stocker une valeur. La constante diffère cependant de la variable du fait que sa valeur est attribuée à la compilation du programme et qu’elle, à partir de ce moment, ne peut plus jamais changer de valeur. La constante ne doit en aucun cas être perçue comme un sous-produit de la variable mais plutôt comme un aide-mémoire ayant pour objectif de faciliter la vie du programmeur. Par exemple, le code suivant utilise certains calculs mathématiques pour résoudre des problèmes de géométrie :

Notez que la valeur 3.14159265 de PI revient régulièrement au sein du code et que, de plus, elle est fastidieuse à mémoriser et à taper. Nous préférerons avantageusement déclarer une constante afin d’y stocker la valeur de PI qui n’a, de toutes façons, pas besoin de changer de valeur pendant la durée du programme. Une constante est déclarée à l’aide du mot-clé Const et est suivi de la valeur que doit prendre la constante :

      Const PI = 3.14159265

Il est conseillé de précéder la déclaration de la constante de l’identificateur de portée. Ce sujet sera cependant abordé un peu plus loin au cours du présent chapitre.

      Public Const PI = 3.14159265

Ainsi, il sera aisément possible d’accéder à la valeur de PI au sein du code à l’aide de la constante :

Sachez que le compilateur ne compilera pas les constantes mais procédera à une séance de rechercher/remplacer au sein du code afin de compiler afin de modifier toutes les occurrences de la constante par sa valeur réelle. Ainsi, les constantes ne sont véritablement que des outils permettant de faciliter et d’agrémenter la programmation. Servons-nous-en alors !

La valeur PI est également accessible en tant que constante intrinsèque à la plate-forme .NET sous l’appellation mais nécessite l’importation de

Les opérateurs

Les opérateurs sont des symboles réservés par le langage Visual Basic permettant une pluralité d’opérations arithmétiques, logiques, comparatives et autres. Ainsi, vous ne pouvez vous servir de ces symboles pour d’autres fins que celles prescrites par le langage. 

Opérateurs arithmétiques

Les opérateurs arithmétiques permettent d’effectuer des opérations arithmétiques telles l’addition, la soustraction, la multiplication, etc.

Opérateur

Description

Exemple

^

Soulève un nombre à la puissance spécifiée.

Z = 4 ^ 2    ' donne 16.

-

Précise l’inverse arithmétique d’un nombre ou d’une expression.

Z = -(3 * 4) ' donne –12.

*

Multiplie deux nombres.

Z = 3 * 4

/

Divise deux nombres en conservant les décimales le cas échéant.

Z = 9 / 4 ' donne 2,25.

\

Divise deux nombres en tronquant les décimales le cas échéant.

Z = 9 \ 4 ' donne 2.

Mod

Retourne le reste d’une division entière (modulo).

Z = 9 mod 4   ' donne 1.

+

Additionne deux nombres.

Z = 4 + 3

-

Soustrait deux nombres.

Z = 4 – 3

Tâchez de bien distinguer les deux opérateurs de division dont l’un deux ne considère pas les décimales le cas échéant et qui peut produire des résultats inattendus s’il est incorrectement utilisé.

Opérateur de concaténation

La concaténation est une opération qui s’applique sur des chaînes de caractères seulement.

Cette opération permet d’embouter deux chaînes de caractères afin de n’en former qu’une seule.

      Dim strPrnom As String = "Joe"

      Dim strNom As String = "Castagnette"

      MsgBox (strPrnom & " " & strNom)                     ‘ Affiche "Joe Castagnette"

L’opérateur de concaténation ne s’appliquant que sur des chaînes de caractères, il procèdera à une conversion explicite en chaînes de caractères si des valeurs numériques lui sont fournies.

      Dim X As Integer = 2

      Dim Y As Integer = 6

      MsgBox (X & Y)                                                      ‘ Affiche "26"

Opérateur

Description

Exemple

            &           Concatène deux chaînes de caractères.               strA = strPrnom & strNom

Opérateurs de comparaison

Ces opérateurs permettent de comparer deux valeurs. Le résultat de la comparaison s’évalue toujours par True ou False. L’utilité des opérateurs de comparaison prendra tout son sens lorsque nous aborderons les structures de contrôle plus loin dans ce chapitre.

Opérateur

Description



Exemple

=

Retourne True si les deux valeurs sont égales.

bResultat = x = 5

<>

Retourne True si les deux valeurs sont différentes.

bResultat = x <> 5

>

Retourne True si la valeur de gauche est plus grande que la valeur de droite.

bResultat = x > 5

<

Retourne True si la valeur de gauche est plus petite que la valeur de droite.

bResultat = x < 5

>=

Retourne True si la valeur de gauche est plus grande ou égale à la valeur de droite.

bResultat = x >= 5

<=

Retourne True si la valeur de gauche est plus petite ou égale à la valeur de droite.

bResultat = x <= 5

            Is    Retourne mêmes. True si les deux objets sont les       bResultat = objX Is objY

Opérateurs logiques

Tout comme les opérateurs de comparaison, le résultat généré par l’utilisation des opérateurs logiques s’évalue toujours par True ou False. L’utilité des opérateurs logiques prendra tout son sens lorsque nous aborderons les structures de contrôle plus loin dans ce chapitre.

Opérateur

Description

Exemple

Not

Retourne la négation logique de l’expression.

bR = Not (X < 1)

And

Retourne la conjonction logique de deux expressions.

bR = (X > 2) And (Y =1)

AndAlso

Retourne la conjonction logique de deux expressions sans évaluer la seconde si cela ne s’avère pas nécessaire.

bR = (X > 2) AndAlso (Y =1)

Or

Retourne la disjonction logique de deux expressions.

bR = (X > 2) Or (Y =1)

OrElse

Retourne la disjonction logique de deux expressions sans évaluer la seconde si cela ne s’avère pas nécessaire.

bR = (X > 2) OrElse (Y =1)

XOr

Retourne la disjonction logique exclusive de deux expressions.

bR = (X > 2) XOr (Y =1)

Eqv

Retourne l’équivalence logique de deux expressions.

bR = 2 Eqv (6 / 3)

Imp

Retourne l’implication logique de deux expressions.

bR = 2 Imp objNull

Not

Expr

=

Faux      

Vrai

Vrai

Faux

Or

Expr1

Expr2

=

Faux        Faux

Faux

Faux

Vrai

Vrai

Vrai          Faux

Vrai

Vrai

Vrai

Vrai

Voici les tables de vérité des opérateurs logiques. Les expressions Expr1 et Expr2 combinées à l’aide de l’opérateur concerné donnent le résultat spécifié dans la colonne =.



                                                       Faux     Vrai      Faux

                                                       Vrai      Faux    Faux

                                                      Vrai      Vrai       Vrai

                                                                   XOr       

                                                       Expr1 Expr2         =

Faux Faux Faux Faux Vrai Vrai

                                                       Vrai      Faux      Vrai

Vrai                                             Vrai      Faux

AndAlso

Expr1

Expr2

=

Faux     N\Eval

Faux

Faux

N\Eval

Vrai

Vrai      Faux

Faux

Vrai

Vrai

Vrai

                                                                   OrElse


            And      

Expr1 Expr2         =

Faux     Faux    Faux


                                                        Expr1 Expr2          =

Faux Faux Faux Faux Vrai Vrai

                                                       Vrai          N\Eval Vrai

Vrai                                                 N\Eval Vrai

Eqv

Expr1

Expr2

=

Faux        Faux

Vrai

Faux

Vrai

Faux

Vrai         Faux

Faux

Vrai

Vrai

Vrai

                                                                   Imp       

                                                       Expr1 Expr2      =

Faux Faux Vrai Vrai Faux Faux

                                                       Vrai      Null      Null

 Faux Vrai Vrai Vrai Vrai Vrai Faux Null Vrai



Null      Vrai      Vrai

Null        Faux     Null  Null           Null      Null


Les opérateurs AndAlso et OrElse sont particuliers du fait qu’ils peuvent outrepasser l’évaluation de la seconde expression si celle-ci s’avérerait inutile. Par exemple :

Dim X As Integer = 2

If (x > 4 AndAlso MsgBox("Certain ?", vbYesNo ) <> vbYes) Then

      End If

La seconde expression ne sera pas évaluée puisque la première est fausse et que, conséquemment, il est assuré que l’expression entière sera évaluée négativement par un opérateur AND. Ainsi, la boîte de message ne serait jamais affichée ce qui n’est pas le cas si nous avions utilisé un opérateur AND. 

Ces opérateurs rejoignent, vous l’aurez remarqué, des techniques avancées de programmation.

Priorité des opérateurs

L’ensemble des opérateurs sont reliés selon un ordre de priorité très précise régissant l’ordre dans laquelle les différentes expressions doivent être évaluées afin d’en calculer le résultat. Ainsi, Visual Basic évaluera l’expression suivante :

      X = 4 + 2 * 6

et obtiendra le résultat 16 et non le résultat 36. Le secret réside dans la priorité des opérateurs qui stipule entres autres que la multiplication est prioritaire à l’addition. Voyez comment Visual Basic évalue l’expression précédente :

      X = 4 + 2 *  6

 

      X =   16

Afin de s’assurer d’obtenir les résultats escomptés sans trop se soucier de la priorité des opérateurs, il suffit d’insérer explicitement des parenthèses qui demeurent les opérateurs possédant la plus forte priorité :

      X = 4 + (2 * 6)                  ‘ Donne 16 et le code est clair !        X = (4 + 2) * 6                    ‘ Donne 36 et le code est clair !

Voici le tableau complet des opérateurs présentés en ordre décroissant de priorité.

Priorité

Opérateur(s)

Description(s)

14

( )

Parenthèses explicites.

13

^

Exposant.

12

-

Inverse arithmétique.

11

* /  \

Multiplication, division réelle et division entière.

10

Mod

Modulo.

9

+ - 

Addition et soustraction.

8

&

Concaténation de chaînes de caractères.

7

=, <>, >, <, >=, <=, Is

Comparaisons.

6

Not

Inverse logique.

5

And, AndAlso

Conjonction logique.

4

Or, OrElse

Disjonction logique.

3

XOr

Disjonction logique exclusive.

2

Eqv

Équivalence logique.

1

Imp

Implication logique.

Structures de contrôle

L’exécution du code de votre code peut être contrôlé par diverses expressions appelées structures de contrôles. Les structures de contrôles sont réunies en deux groupes :

•    Les structures de branchement, ou tests alternatifs, permettent d’exécuter un bloc de code lorsqu’une condition est rencontrée et d’exécuter un bloc de code différent lorsque la même condition n’est pas respectée.

•    Les structures répétitives, ou itérations, permettent de répéter l’exécution d’un bloc de code tant qu’une condition est rencontrée ou qu’elle n’est pas respectée. 

La structure de branchement If…Else…End If

Cette structure de branchement permet d’exécuter un bloc de code si une condition spécifiée est remplie. 

Le code s’exécute seulement lorsque la condition peut positivement être évaluée par True. Dans tous les autres cas, aucun code supplémentaire n’est exécuté.

La syntaxe de cette structure de branchement est la suivante :

                                                                                                 If <condition> Then

                                                                                                 <Code à exécuter>

                                                                                                 End If

L’exemple suivant tire un nombre aléatoire entre 0 et 100 et en affiche la valeur. Lorsque X est un nombre pair, une boîte de dialogue le précise à l’utilisateur :

Randomize()

X = CInt(Rnd * 100)

MsgBox("X vaut " & X) If (X Mod 2 = 0) Then

       MsgBox("X est un nombre pair." )       

End If

Il est possible d’écrire un branchement If sur une seule ligne lorsque le code à exécuter est constitué d’une seule instruction au lieu d’un bloc d’instructions :

      If (X Mod 2 = 0) Then MsgBox("X est un nombre pair.")

Cependant, cette syntaxe diminue la lisibilité du code et ne permet l’exécution d’une seule instruction au sein du bloc If. Notez que cette syntaxe ne nécessite pas l’insertion de l’instruction End If à la fin de la structure de branchement.  

La structure peut être étendue afin d’intégrer un branchement alternatif  Else dont le code ne s’exécutera que lorsque la condition ne sera pas rencontrée.

Le premier code s’exécute seulement lorsque la condition peut positivement être évaluée par True. Dans tous les autres cas, le second code est exécuté. Un des deux codes est nécessairement exécuté dans tous les cas et seulement un des deux codes est exécuté.

La syntaxe de cette structure de branchement est la suivante :

                                                                                                     If <condition> Then

                                                                                                     <Code à exécuter>

                                                                                                     Else

 <Code à exécuter>  End If

Voici le même exemple présenté précédemment à lequel un branchement Else a été ajouté : 

        Randomize

        X = CInt(Rnd * 100)

        MsgBox ("X vaut " & X)

        If (X Mod 2 = 0) Then

                MsgBox ("X est un nombre pair.")       

        Else

                MsgBox ("X est un nombre impair.")             

        End If

La structure de branchement Select Case…End Select

Cette structure de branchement permet d’exécuter un bloc de code selon la valeur d’une expression spécifiée.

Un seul des blocs de code s’exécute selon la valeur de l’expression soumise à l’évaluation. 

La syntaxe de cette structure de branchement est la suivante :

                                                                                        Select Case <expression>

                                                                                          Case <valeur1>

                                                                                        <Code à exécuter>

                                                                                          Case <valeur2>

                                                                                        <Code à exécuter>

                                                                                          Case Else

                                                                                        <Code à exécuter>

                                                                                        End Select 



Si aucun des branchements ne correspond à

                                                                            l’expression spécifiée, le bloc facultatif exécuté s’il a été spécifié.    Case Else est

L’exemple simple suivant montre l’utilisation de la structure Select Case. Notez que vous pouvez toujours insérer le nombre de blocs Case que désiré et que le bloc Case Else est facultatif.

      Select Case X

         Case 0

            MsgBox("X vaut 0")

         Case 1

            MsgBox("X vaut 1")

         Case 2

            MsgBox("X vaut 2")

         Case Else       

            MsgBox("Désolé, la valeur est invalide!")

      End Select

Voici un autre exemple de l’application de cette structure de branchement :

      Select Case X

         Case 0 To 9

            MsgBox("X est entre 0 et 9.")

         Case 10 To 99

            MsgBox("X est entre 10 et 99.")

         Case Is > 99

            MsgBox("X est plus grand que 99.")

      End Select

Structures répétitives Do While/Until … Loop

Ces structures répétitives sont utilisées afin de répéter une instruction ou un certain bloc de code. 

Le code est exécuté tant que la condition est vraie (boucle while) ou jusqu’à ce que la condition soit vraie (boucle Until). Lorsque la condition n’est plus remplie (boucle while) ou lorsqu’elle est remplie (boucle Until), l’exécution quitte la boucle afin de poursuivre normalement le code suivant.

Les syntaxes de ces structures répétitives sont les suivantes :

                                                                    Do While <condition>

                                                                    <Code à exécuter>

                                                                    Loop

                                                                    Do Until <condition>

                                                                    <Code à exécuter>

                                                                    Loop

Voici un exemple simple de la mise en œuvre de ces structures répétitives. La boîte de message est affichée 10 fois en affichant chacune des valeurs entre 0 et 9 inclusivement :

Dim nNbr As Integer = 0

Do While nNbr < 10

      MsgBox("nNbr vaut " & nNbr)  nNbr += 1

Loop

Le même résultat peut être obtenu à l’aide de la boucle Do Until à la condition de modifier la condition :

Dim nNbr As Integer = 0

Do Until nNbr = 10

      MsgBox("nNbr vaut " & nNbr)  nNbr += 1

Loop

Il est possible de quitter prématurément une boucle à l’aide de l’instruction Exit Do. Lorsque cette instruction est rencontrée, la structure répétitive est quittée peu importe l’état de la condition gérant la boucle.

L’exemple suivant génère le même résultat que les deux boucles présentées précédemment :

Dim nNbr As Integer = 0

      Do

      MsgBox("nNbr vaut " & nNbr)        nNbr += 1

            If nNbr >= 10 Then Exit Do

      Loop

Structures répétitives Do … Loop While/Until

Comme les structures présentées précédemment, ces structures répétitives sont utilisées afin de répéter une instruction ou un certain bloc de code. 

Le code est exécuté tant que la condition est vraie (boucle while) ou jusqu’à ce que la condition soit vraie (boucle Until). Lorsque la condition n’est plus remplie (boucle while) ou lorsqu’elle est remplie (boucle Until), l’exécution quitte la boucle afin de poursuivre normalement le code suivant. Notez que, contrairement aux précédentes boucles Do, les présentes boucles exécutent le bloc de code au moins une fois puisque la condition est évaluée après que celui-ci ne soit exécuté.

Les syntaxes de ces structures répétitives sont les suivantes :

                                                                    Do  

                                                                    <Code à exécuter>

                                                                    Loop While <condition>

                                                                    Do

                                                            Loop Until<Code à exécuter> <condition>

Voici un exemple simple de la mise en œuvre de ces structures répétitives. La boîte de message est affichée 10 fois en affichant chacune des valeurs entre 0 et 9 inclusivement :

Dim nNbr As Integer = 0

Do  

      MsgBox("nNbr vaut " & nNbr)

      nNbr += 1

Loop While nNbr < 10

Le même résultat peut être obtenu à l’aide de la boucle Do Until à la condition de modifier la condition :

Dim nNbr As Integer = 0

Do

      MsgBox("nNbr vaut " & nNbr)

      nNbr += 1

Loop Until nNbr = 10

Ces structures répétitives acceptent également l’utilisation de l’instruction Exit Do.

Structure répétitive For… Next

Comme les structures présentées précédemment, cette structure répétitive est utilisée afin de répéter une instruction ou un certain bloc de code. La boucle For… Next présente cependant l’avantage d’inclure un compteur permettant d’initialiser le nombre d’itérations à exécuter. 

Le compteur est d’abord initialisé ainsi que la valeur maximale ou minimale qu’il doit atteindre. Le code est ensuite répété tant et aussi longtemps que le compteur n’a pas atteint ou dépassé la valeur prescrite lors de l’initialisation de la boucle. Le compteur est automatiquement incrémenté ou décrémenté après l’exécution du code.

La syntaxe de cette structure répétitive est la suivante :

                                                            For <compteur> = <Valeur1> To <Valeur2>

                                                            <Code à exécuter>

                                                            Next

La variable servant de compteur doit préalablement être déclarée.

Voici un exemple simple de la mise en œuvre de cette structure répétitive. La boîte de message est affichée 10 fois en affichant chacune des valeurs entre 0 et 9 inclusivement :

For nCpt = 0 To 9

      MsgBox("nCpt vaut " & nCpt)

Next

Il est possible de créer des boucles inversées au sein desquelles la valeur du compteur est automatiquement décrémentée au lieu d’être incrémentée (par défaut) en spécifiant une valeur négative à l’instruction facultative Step. L’exemple suivant affiche les valeurs entre 0 et 9 inclusivement mais débute en affichant 9 avant de terminer par 0.

      For nCpt = 9 To 0 Step –1

            MsgBox("nCpt vaut " & nCpt)

      Next

De la même manière il est possible de créer des boucles dont l’incrémentation ou la décrémentation du compteur s’effectue par multiple de 2, de 3 ou de toute autre valeur. L’exemple suivant affiche les nombres pairs compris entre 0 et 20 inclusivement :

      For nCpt = 0 To 20 Step 2

            MsgBox(nCpt & " est un nombre pair")

      Next 

Il est possible de quitter prématurément la boucle For… Next en introduisant l’instruction Exit For au sein du code à exécuter.

Structure répétitive For Each… Next

Comme les structures présentées précédemment, cette structure répétitive est utilisée afin de répéter une instruction ou un certain bloc de code mais utilise le nombre d’objets membres d’une collection afin d’initialiser le nombre le nombre d’itérations à effectuer. Ces concepts orientés objets vous seront exposés plus tard.

      For Each File in objFiles

MsgBox()

      Next

Structure répétitive While… Wend

Comme les structures présentées précédemment, cette structure répétitive est utilisée afin de répéter une instruction ou un certain bloc de code. Cependant, cette structure existe depuis les débuts du langage Basic et est supplantée par les autres formes de boucles. La boucle While…Wend a été conservée pour des fins de compatibilité antérieure mais il est conseillé d’utiliser les autres structures répétitives mieux structurées et plus flexibles.

Le code est exécuté tant que la condition est vraie. Lorsque la condition n’est plus remplie, l’exécution quitte la boucle afin de poursuivre normalement le code suivant.

La syntaxe de cette structure répétitive est la suivante :

 While <condition>  <Code à exécuter>

                                                                    Wend

Voici un exemple simple de la mise en œuvre de cette structure répétitive. La boîte de message est affichée 10 fois en affichant chacune des valeurs entre 0 et 9 inclusivement :

Dim nNbr As Integer = 0

While nNbr < 10

      MsgBox("nNbr vaut " & nNbr)  nNbr += 1

Wend

Focus sur la condition

La condition qui régi l’exécution ou non d’un bloc de code au sein d’une structure de contrôle est toujours évaluée par une valeur booléenne True ou False. Visual Basic réduira toujours à ce niveau la valeur de la condition que votre code lui soumet. Dans l’exemple suivant, la condition est simplement composée d’une valeur numérique :

      Dim nVar As Integer = 14

      Do While nVar

            MsgBox ("nVar vaut " & nVar)          nVar -= 1   Loop

Or, ce code affiche les différentes valeurs de la variable nVar de 14 à 1 puis le code cesse de s’exécuter. Pourquoi ? Ce comportement s’explique aisément par la façon qu’ont les langages de programmation d’évaluer les conditions selon l’algorithme booléen qui stipule que :

•    Une valeur nulle (0) s’évalue négativement et prend la valeur False.

•    Toute autre valeur s’évalue positivement et prend la valeur True.

Ainsi, l’exemple précédent évalue positivement la condition de la boucle tant que la variable nVar possède une valeur différente de zéro.

Il existe également quelques pièges qu’il faut faire attention d’éviter lors de la construction de boucles et de conditions. Un d’eux provient souvent de la méprise du programmeur à l’égard des opérateurs logiques AND et OR. Dans l’exemple suivant, le code attend une réponse de l’utilisateur avant de poursuivre l’exécution. À l’aide d’une boucle, le code s’assure que l’utilisateur ne puisse entrer que deux réponses possibles… ou, du moins, il croit le faire :

‘*********  Ce code est erroné… ne l’essayez-pas ****************’

      Do

            Reponse = InputBox("Désirez-vous continuer ? (Oui, Non)")         Loop While LCase(Reponse) <> "oui" OR LCase(Reponse) <> "non"  

Cependant, la table de vérité de l’opérateur OR stipule que l’une des deux parties de l’expression évaluée doit être vraie pour que l’expression s’évalue positivement. Ainsi, si l’utilisateur entre la réponse "non", le script évalue d’abord Reponse <> "oui" et conclu, en effet que cette affirmation est vraie et, concluant avec raison que la condition est vraie, procède à une nouvelle itération de la boucle. Le code aurait donc dû se lire comme suit :

      Do

            Reponse = InputBox("Désirez-vous continuer ? (Oui, Non)")         Loop While LCase(Reponse) <> "oui" AND LCase(Reponse) <> "non"

Un autre piège provient des conditions mal construites provoquant des boucles infinies. Examinez l’exemple suivant et notez que la condition de cette boucle ne pourra jamais être rencontrée. 

‘*********  Ce code est erroné… ne l’essayez-pas ****************’

      Dim nVar As Integer = 0

      Do Until nVar > 10

            Y = nVar * X      Loop

Cet exemple illustre bien le phénomène des boucles infinies. La condition ne pouvant jamais être rencontrée, le code s’exécute éternellement et fait rapidement grimper à 100% le niveau d’utilisation du processeur. 

Imbrication de structures de contrôles

Visual Basic permet au programmeur d’imbriquer les différentes structures de contrôles afin de donner plus de latitude à son code. L’imbrication de structures de contrôles emploie le principe dit LIFO (Last-In, First-Out) stipulant que la dernière structure de contrôle imbriquée doit être la première à se terminer. Voici l’exemple d’un code permettant de connaître tous les nombres premiers compris entre 1 et 100 :

For X = 1 To 100

      Premier = True

For Y = 2 To X

If (X Mod Y = 0) AND (X <> Y) Then

      Premier = False

      Exit For

End If       

Next 

      If Premier Then MsgBox(X & " est un nombre premier.") Next

Notez que chacune des structures de contrôle se termine avant que ne se termine la structure de contrôle parent.

Utilisation des fonctions

Visual hérite de ses ancêtres Basic et Visual Basic d’une multitude de fonctions procurant une grande flexibilité à ce langage. Ces fonctions sont intrinsèques au langage et ne nécessite donc pas que le script référence un modèle d’objets externe tel que vous apprendrez à les utiliser dans les prochains chapitres. Lorsque votre code invoque une fonction, votre code demande au code qui y est contenu de s’exécuter. 

Il est possible d’invoquer une fonction ou une procédure simplement en la nommant :

      NomFonction()

Cet appel d’une fonction met en oeuvre la syntaxe la plus simple puisque la fonction ne nécessite pas que des paramètres d’entrée ne lui soient spécifiés. Les paramètres représentent des informations supplémentaires que la fonction pourrait attendre afin de préciser certains aspects de l’appel. Ainsi, lorsque vous demandez l’exécution de la commande Format afin de formater un disque, vous devez spécifiez la lettre du lecteur qui doit être formaté. Il s’agit là d’un paramètre, d’une information supplémentaire nécessaire pour l’exécution de la commande. Voici la syntaxe permettant d’invoquer une fonction ou une procédure et de préciser les paramètres attendus par celle-ci :

      NomFonction  (Param1, Param2, ParamN)

Remarquez que chacun des paramètres sont séparés les uns des autres par une virgule (,). Notez également que certaines fonctions attendent des paramètres optionnels. Ainsi, si vous spécifiez une valeur pour ces paramètres, la fonction utilisera cette valeur mais utilisera une valeur définie par défaut à l’interne si aucune valeur n’est spécifiée pour ces paramètres.

Finalement, une fonction peut renvoyer une valeur de retour. Une valeur de retour peut être le fruit d’un calcul ou d’une opération quelconque. Une valeur de retour peut également être une information indiquant si la fonction s’est exécutée correctement ou si elle a échouée. Vous retrouverez au sein du présent chapitre la signification des valeurs de retour des fonctions intrinsèques à Visual . Voici la syntaxe permettant d’invoquer une fonction et d’en récupérer la valeur de retour :

            MaVariable = NomFonction()

ou, dans le cas de méthodes paramétrables :     

      MaVariable = NomFonction(Param1, Param2, ParamN)

Dans laquelle syntaxe la valeur de retour de la méthode a été stockée au sein de la variable MaVariable. Votre code n’est pas obligé de récupérer les valeurs de retour des fonctions. 

Création de fonctions et procédures

Lorsque vous écrirez vos codes, vous rencontrerez certainement des situations dans lesquelles vous êtes forcé de répéter intégralement ou à quelques différences près un code précédemment tapé. La première fois que cette situation se présente, c’est comique… la seconde fois, c’est sympathique mais, ensuite, la situation devient rapidement lassante de par sa redondance. De plus, le fait de copier un même code à plusieurs endroits peu provoquer des ennuis plus sérieux. Si pour une raison ou une autre un code déjà copié à maints autres endroits devait être



2664