Cours VB.NET

Date de mise à jour : 05/12/2010

V-O. Les constantes, les énumérations
V-O-1. Constantes
V-O-1-a. Intérêts des constantes ?
V-O-1-b. Constantes prédéfinies de VB
V-O-1-c. True False
V-O-2. Énumération
V-O-3. Les énumérations VB.NET
V-O-3-a. ControlChars
V-O-3-b. Couleurs
V-O-3-c. Math
V-O-3-d. Touche du clavier dans le Framework
V-O-3-e. Autre exemple
V-P. Les opérateurs
V-P-1. Addition : +
V-P-2. Soustraction : -
V-P-3. Multiplication : *
V-P-4. Division : /
V-P-5. Division entière: \
V-P-6. Puissance : ^
V-P-7. Modulo : Mod
V-P-8. Concaténation : &
V-P-9. Priorités
V-P-10. Comparaison
V-P-11. Logique : Not And Or ElseOr Xor
V-P-11-a. Si A et B sont des expressions booléennes
V-P-11-b. Si A et B sont des nombres (Integer par exemple)
V-P-11-c. Les opérateurs And, Or et Xor sont évalués en fonction du type des opérandes
V-P-11-c-i. Pour le type Boolean
V-P-11-c-ii. Pour les types Byte, Short, Integer, Long et tous les types énumérés
V-P-12. Déplacement de bits
V-P-13. Remarque 1 : Allons plus loin avec / et \
V-P-14. Remarque 2 : Division par zéro
V-Q. Les structures de contrôle : Choix et boucles
V-Q-1. If Then
V-Q-2. Select Case
V-Q-3. For Next
V-Q-4. Do Loop
V-Q-5. While End While
V-Q-6. For Each
V-Q-7. Switch
V-Q-8. IIF
V-R. Les procédures et leurs paramètres
V-R-1. Les parenthèses
V-R-2. Par Valeur, Par Référence
V-R-3. Par Défaut, que se passe-t-il ?
V-R-4. Optional
V-R-5. Tableau de paramètres
V-R-6. ParamArray
V-R-7. Portée des procédures
V-R-8. Nommage
V-S. Portée des variables
V-S-1. Dans les procédures
V-S-2. Dans un bloc d'instructions
V-S-3. Dans la section déclaration d'un Module
V-S-4. Dans la section déclaration d'une fenêtre, d'un formulaire
V-S-5. En pratique
V-S-6. En général

V-O. Les constantes, les énumérations

V-O-1. Constantes

Comme les variables, elles ont un nom et un type, mais leurs valeurs sont 'constantes'.

On les déclare par le mot Const, on peut les initialiser en même temps avec =

Exemple :


Const NOMDUPROGRAMME= "LDF"   'constante chaîne de caractères.

Const NOMBREDECASE As Integer = 12             'constante Integer

Ensuite on peut utiliser la constante:


For k= 0 To NOMBREDECASE

...

Next k

Si on utilise: For k=0 To 12, à la lecture c'est moins clair.

Si on écrit: NOMBREDECASE=13 cela déclenche une erreur!!

Habituellement, les constantes sont créées en début de programme.

Il est conseillé par convention d'écrire le nom des constantes en majuscules.

V-O-1-a. Intérêts des constantes ?

Améliore la lisibilité et évite d'utiliser des constantes littérales:

Il faut éviter:


For i=0 To 100    'A quoi correspond 100?

..

Next i

Il faut écrire


Const NBMAXPATIENT As Integer= 100

For i=0 To NBMAXPATIENT

..

Next i

Modifications du code facilitées:
Si une constante doit être modifiée ultérieurement, il suffit en mode conception, de modifier sa valeur ce qui modifie sa valeur dans l'ensemble du code de l'application.

Const NBMAXPATIENT As Integer= 200 'Si j'introduis une modification de valeur
For i=0 To NBMAXPATIENT 'Toutes les boucles utilisant NBMAXPATIENT seront à jour Next i

Amélioration la vitesse.


Const NBMAXPATIENT As Integer= 100 

Dim nombre= NBMAXPATIENT

est plus rapide que:


Dim nbpatient As Integer= 100 

Dim nombre= nbpatient

Car le compilateur code directement nombre=20 dans le premier cas.

On rappelle que seuls les types primitifs peuvent avoir des constantes ( Byte, Boolean, Short, Integer, Long, Single, Double, Decimal, Date, Char, String).

V-O-1-b. Constantes prédéfinies de VB

Les constantes de Visual Basic sont toujours là:


vbOk    'retourné par une MessageBox quand l'utilisateur a cliqué sur Ok.

vbBack

vbCancel

vbCrLf     'caractère numéro 13  puis numéro 10 = saut à la ligne.

V-O-1-c. True False

On rappelle que True et False sont des valeurs Booléennes faisant partie intégrante de VB.

Pour les anciens de VB6 ne plus utiliser -1 et 0 (D'ailleurs c'est maintenant 1 et 0).

Mais, en plus, dans Visual Basic .NET, la plupart des constantes sont remplacées par des énumérations dans le .NET Framework.

(Voir plus bas )

Utiliser largement ces constantes fournies par VB, cela améliore la lisibilité et la maintenance.

V-O-2. Énumération

Les énumérations sont utilisées lorsque l'on a un jeu de constantes liées logiquement.

Un bloc Enum permet de créer une liste (une énumération) de constantes:


Enum TypeFichier

    DOC

    RTF

    TEXTE

End Enum

Les constantes ainsi créées sont :

TypeFichier.DOC
TypeFichier.RTF
TypeFichier.TEXTE

Le bloc Enum doit être dans l'en-tête du module (en haut).

C'est bien pratique car en écrivant le code, dès que je tape 'TypeFichier.' la liste (DOC RTF TEXTE) apparaît.

Ensuite, on peut utiliser dans le programme les constantes créées comme par exemple :

fichierEnCours= TypeFichier.DOC

On peut ensuite tester par exemple :

If fichierEnCours= TypeFichier.RTF then

Il est conseillé, par convention, d'écrire le nom des énumérations en minuscules avec la première lettre en majuscules.

Ce qui suit concernant les énumérations est un peu plus complexe:

Chaque constante littérale de l'énumération a une valeur par défaut.

Par défaut


TypeFichier.Doc =0  

TypeFichier.RTF =1 

TypeFichier.TEXTE=2

..

La première valeur est 0.

Si on ne spécifie rien, les valeurs sont des Integers

Parfois le nom utilisé dans l'énumération (la constante littérale) est suffisant en soi et on n'utilise pas la valeur : Dans un programme gérant des fichiers, une variable prendra la valeur TypeFichier.Doc pour indiquer qu'on travaille sur les fichiers .DOC. Peu importe la valeur de la constante.

Mais d'autres fois il faut que chaque constante de l'énumération possède une valeur particulière.

Je peux imposer une valeur à chaque constante de l'énumération :


Enum TypeFichier

    DOC=2

    RTF=4

    TEXTE=8

End Enum

Cela évite d'écrire fichierEnCours= 15 (en retenant que 15=fichier doc, 30= fichier rtf...)

Je peux même donner plusieurs valeurs avec And et Or à condition d'utiliser l'attribut Flags.


<Flags()> Enum TypeFichier

    DOC=2

    RTF=4

    TEXTE=8

    TOUS= DOC AND RTF AND TEXTE

End Enum

L'attribut Flags() indique que les valeurs sont codées en bits, ce qui permet les combinaisons de valeurs. (pour 2 le second bit est à 1, pour 4 le troisième bit est à 1, pour 8, le quatrième bit est à 1...) (voir chapitre sur l'algèbre de Boole).

Voici un exemple avec une Enumération 'Repas' ou chaque bit indique la présence d'un plat.
La propriété HasFlag permet de tester si un bit est égal à 1.


<Flags()> Public Enum Repas As Integer
    None = 0
    Entree = 1
    Poisson = 2
    Viande = 4
    Dessert = 8
    Boisson = 16
    Digestif = 32
End Enum


  Dim myRepas As Repas = Repas.Entree Or Repas.Dessert Or
                                     Repas.Boisson

        'Affiche myRepas
        Console.WriteLine(myRepas.ToString)
        'Teste si myRepas contient Dessert
        Console.WriteLine(myRepas.HasFlag(Repas.Dessert))

        'Sortie
        'Entree, Dessert, Boisson
        'True

Les énumérations sont des types qui héritent de System.Enum et qui représentent symboliquement un ensemble de valeurs. Par défaut ses valeurs sont des 'Integer' mais on peut spécifier d'autres types: Byte, Short, Integer ou Long. L'exemple suivant déclare une énumération dont le type sous-jacent est Long :


Enum Color As Long
 Red
 Green
 Blue
End Enum

Habituellement, on utilise les énumérations dans le code, comme des constantes.

Exemple:


Enum TypeFichier

    DOC=2

    RTF=4

    TEXTE=8

End Enum

' affecter à une variable:

Dim monFichier As TypeFichier = TypeFichier.RTF

On remarque qu'on crée une variable de type énumération dans laquelle on ne peut mettre qu'une énumération (en fait un Integer).


' affichage d'une valeur

Console.Out.WriteLine("Numéro type du fichier=" & monFichier)

'monFichier' affiche: 4


Console.Out.WriteLine("Type du fichier=" & monFichier.ToString)

On utilise 'monFichier.ToString' qui affiche: RTF


' test avec la constante de l'énumération

If (monFichier = TypeFichier.RTF) Then

    Console.Out.WriteLine("C'est du RTF")

End If

Affiche:"C'est du RTF"

Mais parfois on a besoin de récupérer la liste des éléments d'une énumération.

Comment relire la liste des énumérations?

Il faut utiliser une méthode statique (ne nécessitant pas d'instanciation) GetValues pour obtenir toutes les constantes littérales ou valeurs d'un type énuméré que l'on passe en paramètre.


' liste des mentions littérales (Constantes)

For Each t As TypeFichier In [Enum].GetValues(monFichier.GetType)

    Console.Out.WriteLine(t.ToString)

Next

' liste des mentions entières (Valeurs)

For Each t As Integer In [Enum].GetValues(monFichier.GetType)

    Console.Out.WriteLine(t)

Next

Affiche:


DOC

RTF

TEXTE

2

4

8

GetValues, quand on lui donne le type de l'énumération retourne la liste des éléments de l'énumération; c'est pratique pour remplir une ListBox avec une énumération:


 ListBox1.DataSource = [Enum].GetValues(GetType(TypeFichier))

Si on affecte un élément d'une énumération à une variable Integer, on récupère la valeur, si on utilise ToString on récupère la constante littérale.


Dim n As Integer

n = TypeFichier.RTF

Console.Out.WriteLine(n.ToString)

Dim st As String

st = TypeFichier.RTF.ToString

Console.Out.WriteLine(st)

Affiche


2

RTF

Comment récupérer dans une énumération une constante à partir de sa valeur ou une valeur à partir de la constante?

Ici il faut instancier:


Dim s As Type = GetType(TypeFichier)

Console.Out.WriteLine(CType([Enum].GetName(s, 15), String))

Console.Out.WriteLine(CType([Enum].Parse(s, "DOC"), String))

Affiche:


DOC

2

V-O-3. Les énumérations VB.NET

Noter que VB.Net contient, comme on l'a vu, un tas de constantes classées à l'aide d' Enum.

V-O-3-a. ControlChars

Cette énumération contient les caractères de contrôle.

ControlChars.CrLf égale à Chr$(13)+Chr$(10) qui sert à sauter à la ligne dans une chaîne de caractères :

Si on affiche "VISUAL" & ControlChars.CrLf & "BASIC"

On obtient à l'écran :


VISUAL

BASIC

ControlChars.Tab Chr$(9) = caractère de tabulation

ControlChars.NullChar Aucun caractère

ControlChars.Nothing Chaîne vide

ControlChars.Back

Taper ControlChars. Et comme d'habitude vous obtiendrez la liste des constantes.

V-O-3-b. Couleurs

On peut aussi utiliser l'énumération des couleurs définies par le Framework


System.Drawing.Color.Blue    'Pour le bleu

ou en simplifiant (si Imports System.Drawing a été écrit)


Color.Chocolate

Color.Black

..

V-O-3-c. Math

Si Import System.Math est présent en haut du module,

PI contient 3,14…

E contient la base log naturel

V-O-3-d. Touche du clavier dans le Framework

Il est parfois nécessaire de savoir si une touche précise a été tapée par l'utilisateur au clavier, pour cela il faut connaître les touches, mais pas besoin de se souvenir du code des touches, il suffit de taper Keys. et la liste des touches s'affiche. Cliquer sur le nom de la touche recherchée et vous obtenez la constante correspondant à la touche:


Keys.Right    'Désigne le code de la touche '->'

Keys.D8       'Désigne le code de la touche '8'

Keys.Delete   'Désigne le code de la touche 'Suppr'

Keys.D   'Désigne le code de la touche 'D'

Keys.Shift   'Désigne le code de la touche 'Majuscule'

Keys.SnapShot   'Désigne le code de la touche 'Impression écran'

V-O-3-e. Autre exemple

Quand on ferme une MessageBox. (une fenêtre qui affiche un message), cela retourne une valeur qui contient:


MsgBoxResult.Yes

MsgBoxResult.No    ou

MsgBoxResult.Cancel

En fonction du bouton qu'a utilisé l'utilisateur pour sortir de la fenêtre MessageBox (appuie sur les boutons Oui, Non, Cancel) .

V-P. Les opérateurs

+-*/And OrMod&

Pour travailler sur les variables on utilise des opérateurs (addition, soustraction...).

V-P-1. Addition : +

Dans le cas de variables numériques.


	Dim A,B, C As Integer
					B=2
					C=3
					A=B+C

si B=2 et C=3 => A=5

On peut écrire:

A=A+1

Dans ce cas, on affecte à la variable A son ancienne valeur +1, si A=2 au départ, A=3 ensuite.

A+=1 est équivalent à A=A+1

Cela incrémente la variable A.

On peut utiliser '+' pour ajouter une string à une autre, il est préférable d'utiliser '&'.

V-P-2. Soustraction : -

B=C-D

A-=1 est équivalent à A=A-1

V-P-3. Multiplication : *

C'est une étoile: *

B= C*D

V-P-4. Division : /

On remarque que « : » n'est pas l'opérateur de division.(Ce signe sert de séparateur quand plusieurs instructions sont sur la même ligne.)

Retourne le quotient complet qui conserve le reste dans la partie fractionnaire.

B=C/D

Si C=10 et D=3 B=3.33333333333333

La division de 2 Singles retourne un Single.
La division de 2 Doubles retourne un Double.
La division de 2 Decimals retourne un Decimal.
Voir en bas de page, des informations complémentaires car
La division de 2 entiers (Integer..) retourne un Double.

V-P-5. Division entière: \

Si A=10\3 => A=3 'on perd le reste

Voir en bas de page, des informations complémentaires car "\"sur 2 Integer retourne un Integer.

V-P-6. Puissance : ^


A=B^3        'A=B*B*B

V-P-7. Modulo : Mod

C'est le reste de la division par un nombre :

10 Mod 3 donne 1

Exemple A est-il multiple de 3 ?

Si A Mod 3 = 0 , A est un multiple de 3


If A Mod 3 = 0 then...

V-P-8. Concaténation : &

C'est une mise bout à bout des chaînes de caractères.

A= "VISUAL"

B= " "

C= "BASIC"

D=A & B & C donne D="VISUAL BASIC"

Le signe + peut aussi être utilisé mais il est plutôt réservé aux additions de variables numériques.

&= permet aussi la concaténation A&=B est équivalent à A= A&B

V-P-9. Priorités

L'ordre des calculs se fait en fonction de la priorité des opérateurs.

S'il y a plusieurs opérateurs, '^' a la priorité la plus forte puis * et / puis + et -

Cela veut dire que VB effectue les élévations à puissance puis les multiplications et divisions puis les additions et soustractions.

Pour être complet, voyons les priorités par ordre décroissant:


^ élévation à la puissance

- négation unaire 

/ et * multiplication et division

\ division entière

mod  modulo

+ et -  addition et soustraction.

Exemple 2+3^3 donne 29 car VB effectue (3^3)+2 et non pas 125 (2+3)^3

S'il y a plusieurs opérateurs de même priorité, l'ordre des calculs se fait de gauche à droite.

Pour éviter toute faute d'interprétation utiliser des parenthèses :

2+(3^3) lève toute ambiguïté.

V-P-10. Comparaison


 = égal

 > supérieur à

 < inférieur à

>= supérieur ou égal

<= inférieur ou égal

<> Différent de

Le résultat d'une comparaison est True (Vrai) ou False (Faux)

Exemple :


      Dim A As Integer=2

      Dim B As Integer=3  

      If A=B then

        ..

      End If

A étant différent de B, A=B prend la valeur False et le programme passe à la ligne en dessous de End If (pas après then).

Ici le signe = n'indique pas une affectation mais une expression à évaluer.

Ici aussi on peut combiner les opérateurs et mettre des parenthèses:


R= (C<>D)AND (D=2)   'Si C différent de D  et si D égal 2

Comparaison de chaînes de caractères:

Les chaînes de caractères sont comparées en fonction du tri alphabétique.

Par défaut, 'Option Compare Binary' est activé, ce qui fait que l'ordre des caractères est en relation avec leur code Unicode (voir chapitre sur les Options).


 ' A<B<C……<Y<Z<a<b<c……y<z<à<é.. 

      Dim A As String="A"

      Dim B As String="Z"  

      If A<B then..

A est bien inférieur à B, donc A<B prend la valeur True et le programme saute après Then.

La casse (majuscules ou minuscule) est différenciée.

Si on veut comparer sans tenir compte du fait que c'est en majuscule ou minuscule, il faut d'abord transformer les 2 chaînes en minuscule par exemple.

On veut comparer A= "aaa" et B= "AAA"

Normalement A est différent de B :

A=B retourne False

Par contre A.ToLower=B.ToLower retourne True (Vraie)

En utilisant 'Option Compare Text' en début de module, on ne différencie plus la casse: "A" devient égal à "a".

V-P-11. Logique : Not And Or ElseOr Xor

V-P-11-a. Si A et B sont des expressions booléennes

A And B retourne True si A et B sont vrais

A Or B retourne True si une des 2 est vrai

A Xor B retourne True si une et une seule est vrai

Not A retourne True si A était faux et vice versa

On entend par expression booléenne le résultat de l'évaluation d'une condition:

A=B retourne True si A=B et False si A différent de B.

Exemple

Si A différent de B.. peut s'écrire IF Not(A=B)..

Si A compris entre 2 et 5 peut s'écrire If A>=2 And A<=5..

Comment faire une bascule:

Il faut écrire A= Not A

A chaque fois que l'on effectue cette instruction A bascule à True s'il était à False et vice versa.

V-P-11-b. Si A et B sont des nombres (Integer par exemple)

L'opération est effectuée sur chaque bit.

A = 7 'en décimal ( 0111 en binaire)

B = 12 'en décimal( 1100 en binaire)

Que donne A And B?

On effectue l'opération bit à bit:

Pour le premier bit de chaque nombre 0 And 1 = 0

Pour le second bit de chaque nombre 1 And 1 = 1...

Cela donne 0100.

A And B = 4 'en décimal( 0100 en binaire)

Autre exemple:

A And 1 indique si le bit le moins significatif (le plus à droite) est a 1

Exemple: si A = 7 'en décimal ( 0111 en binaire) A And 1 retourne 1

V-P-11-c. Les opérateurs And, Or et Xor sont évalués en fonction du type des opérandes

V-P-11-c-i. Pour le type Boolean

Une opération And logique est effectuée sur les deux opérandes.

Une opération Or logique est effectuée sur les deux opérandes.

Une opération Or exclusif logique est effectuée sur les deux opérandes.

V-P-11-c-ii. Pour les types Byte, Short, Integer, Long et tous les types énumérés

L'opération spécifiée est réalisée sur chaque bit de la représentation binaire des deux opérandes

And : Le bit de résultat est 1 si les deux bits sont 1. Sinon, le résultat est 0.

Or : Le bit de résultat est 1 si l'un des deux bits est 1. Sinon, le résultat est 0.

Xor : Le bit de résultat est 1 si l'un des deux bits est 1 mais pas les deux. Sinon, le bit de résultat est 0 (c'est-à-dire 1 Xor 0 = 1, 1 Xor 1 = 0).

Les opérateurs AndAlso et OrElse sont uniquement définis sur le type Booléen, ils sont plus rapides car ils n'évaluent pas la seconde expression si ce n'est pas nécessaire.

Il n'est pas judicieux d'effectuer des opérations logiques sur des Single, Decimal, Double (nombre avec vigule).

V-P-12. Déplacement de bits

Les opérateurs binaires << et >> effectuent des opérations de déplacement de bits. Ces opérateurs sont définis pour les types Byte, Short, Integer et Long.

L'opérateur << décale à gauche les bits du premier opérande du nombre de positions spécifié. Les bits de poids fort situés en dehors de la plage du type de résultat sont éliminés, et les positions libérées par les bits de poids faible sont remplies par des zéros.

L'opérateur >> décale à droite les bits du premier opérande du nombre de positions spécifié. Les bits de poids faible sont éliminés et, si l'opérande de gauche est positif, les positions libérées par les bits de poids fort sont mises à zéro ; s'il est négatif, elles sont mises à un. Si l'opérande de gauche est de type Byte, les bits de poids fort disponibles sont remplis par des zéros.

A quoi cela sert?

Exemple décaler à gauche un Byte revient à faire une multiplication par 2.

3 en décimal= 11

Je décale à gauche, j'obtiens 110 , c'est 6 en décimal.

V-P-13. Remarque 1 : Allons plus loin avec / et \

La division de 2 Singles avec "/" retourne un Single.
La division de 2 Decimals avec "/" retourne un décimal.
mais
La division de 2 entiers avec "/" retourne un double:

Avec Option Strict=Off


Dim i As Integer = 4

Dim j As Integer = 2

Dim k As Integer = i / j 'est accepté
'car i/j donne un double transformé en Integer 'automatiquement'.

Avec Option Strict=On, il faut écrire:


Dim i As Integer = 4

Dim j As Integer = 2

Dim k As Integer = CType(i / j, Integer) 'on est obligé de caster le double en Integer.

Mais "\" retourne un Integer si on divise 2 entiers.
Pour diviser 2 entiers utiliser donc "\".


Dim i As Integer = 4

Dim j As Integer = 2

Dim k As Integer = i \ j 'est accepté
'même si  Option Strict=On

V-P-14. Remarque 2 : Division par zéro

La division par zéro est impossible mathématiquement.

Si on divise un double (ou un Single ) par zéro, on obtient NaN :nombre non défini ou PositiveInfinity ou NegativeInfitiny selon le dividende.
Pour les entiers, Integer , Byte.. une division par zéro déclenche une erreur ( on dit une exception) DivideByZeroException ou OverflowException en vb 2010.

En pratique les choses ne sont pas si évidentes; voyons des exemples:


Dim i As Integer = 4

Dim j As Integer = 0

TextBox1.Text = (i/j).ToString 'Affiche " +Infini"

Le résultat de l'opération (i/j) qui est un Double prend la valeur infini et est directement affiché.

Par contre:


Dim i As Integer = 4

Dim j As Integer = 0

Dim k As Integer = CType(i / j, Integer) 'Erreur

Retourne une exception (une erreur) Overflow.Exception car le résultat de l'opération est l'infini donc plus grand que MaxValue des Integers.

Il faut donc, si on risque d'avoir la valeur zéro, faire un contrôle avant la division:


If j<>0 Then

    k=i/j

End If

V-Q. Les structures de contrôle : Choix et boucles

Elles permettent de gérer le déroulement du code.

V-Q-1. If Then

Permet de créer une structure décisionnelle:

If Condition Then

End if

Si la Condition est vraie alors...

Une instruction (ou un bloc d'instructions) peut être exécutée si une condition est vraie.

Exemple:


If A=B then 

    MsgBox("A=B")

End If

Si A = B alors on exécute le bloc de code entre Then et End If, il affiche dans une fenêtre MessageBox « A=B »

Noter que, si on le désire, on peut écrire sur la même ligne après Then (Pas besoin de End If).


If A=B Then MsgBox("A=B")

On peut tester une condition fausse et dans ce cas utiliser Not.


If Not A=B Then MsgBox("A différent de B")

Si A et B sont différent (Not A=B signifie NON égaux) afficher "A différent de B".

(On aurait pu écrire If A<>B Then...)

Il peut y avoir des opérateurs logiques dans la condition:


If A=B And C=D then..    'Si A égal B et si C égal D

Autre exemple :


Dim n As String ="33" ' on crée une String , on y met les caractères "33"

If Not IsNumeric(n) then

            MsgBox ("n n'est pas un nombre")

            Exit Sub

End if

Si n n'est pas numérique alors afficher dans une boite de dialogue: « n n'est pas un nombre » puis quitter la procédure (Exit Sub)

Noter bien que comme il y a plusieurs instructions après Then on crée un bloc d'instruction de plusieurs lignes entre Then et End If.

Simplification d'écriture:

Au lieu de


If Condition = True Then

End if

On peut écrire:


If Condition Then   

End if

Condition étant de toute manière évaluée pour voir si elle est égale à True.

On peut aussi utiliser la structure'Si..Alors..Sinon' :

 
If condition then

.. 'effectué si condition vraie

..

Else

      ..'effectué si condition fausse

      ..

End if

Exemple:


If A=B then 

    MsgBox("A=B")

Else

    MsgBox("A différend de B")

End If

Des structures If Then peuvent être imbriquées :


If..

      If..

      ..

      Else

            If..

     ..

End if

      End if

End If

Pour bien repérer les différents niveaux, utiliser les tabulations et décaler le 'If then' et son code au même niveau.

Pour vérifier s'il n'y a pas d'erreur, compter les 'If', il doit y en avoir autant que des 'End If'. VB souligne le 'If' si il n'y a pas de 'End if'.

Dernière syntaxe avec 'ElseIf':


If Condition1 Then

    ..

ElseIf condition2 Then

    ..

ElseIf condition3 Then

    ..

end if

Si condition1...

Sinon si condition2

Sinon si condition3

Fin Si

V-Q-2. Select Case

Créer une structure décisionnelle permettant d'exécuter un grand nombre de blocs de code différents en fonction de la valeur d'une expression :


Select Case expression

Case valeur1

      'code effectué si expression=valeur1


Case valeur2

      'code effectué si expression=valeur2


Case valeur3

      'code effectué si expression=valeur3

..

Case Else

      'code effectué dans tous les autres cas


End Select

Attention si expression=valeur1 le code entre Case Valeur1 et Case valeur2 (et uniquement celui là) est effectué, puis l'exécution saute après End Select.

Exemple d'un code affichant le jour de la semaine :

J est un entier contenant le numéro d'ordre du jour



Select Case N

Case 1                        'Si N=1

      MsgBox "Lundi"          'Afficher 'Lundi'  

 

Case 2

      MsgBox "Mardi"

 

Case 3

      MsgBox "Mercredi"

..

..

Case Else

      MsgBox "Nombre pas entre 1 et 7"

End select

Nous venons d'utiliser une expression simple après chaque Case mais on peut utiliser des expressions plus complexes :

Plusieurs clauses d'expression peuvent être séparées par des virgules.


Select Case N

Case 8,9,10

      'Effectuer le code  si N=8 ou N=9 ou N=10

Le mot clé To permet de définir les limites d'une plage de valeurs correspondantes pour N.


Select Case N

Case 8 To 20
      'Effectuer le code  si N est dans la plage 8 à 20
End Select

Le mot clé Is associé à un opérateur de comparaison (=, <>, <, <=, > ou >=) permet de spécifier une restriction sur les valeurs correspondantes de l'expression. Si le mot clé Is n'est pas indiqué, il est automatiquement inséré.


Select Case N

Case Is >= 5

      'Effectuer le code  si N supérieur ou égal à 5.

End Select

Vous pouvez utiliser plusieurs expressions ou plages dans chaque clause Case (séparées par des virgules). Par exemple, la ligne suivante est valide :


Case 1 To 4, 7 To 9, 11, 13, Is > MaxNumber

Vous pouvez aussi indiquer des plages et des expressions multiples pour des chaînes de caractères. Dans l'exemple suivant, Case correspond aux chaînes qui sont absolument identiques à « aaa », aux chaînes comprises entre «ccc» et «ddd» dans l'ordre alphabétique, ainsi qu'à la valeur de Var :


Case "aaa", "ccc" To "ddd", Var

Pour les 'Pro':

Les "Case" peuvent contenir n'importe quelle expression. Aussi il est possible de tester dans les conditions, non pas les valeurs d'une même variable, mais divers fonctions totalement indépendantes ou comme ici des fonctions travaillant toutes sur une même variable. C'est un usage méconnu du Select Case qui clarifie l'écriture et qui évite de multiples If Then ou Goto.

Ici une routine reçoit une String contenant un nom de fichier, elle teste si le nom n'est pas vide puis si le fichier existe..


Sub TestFichier (File As String)

Select Case true

        Case len(File) = 0 

            msgbox "Pas de nom de fichier"    

        Case Not Exit(File)

            errorState=File.NotExist

        Case Not Open(File)

            errorState=File.NotOpen

        Case Not Overwrite(File) 

            errorState=File.NotOverwrite

        Case else

        'placer les exceptions ici

End Select

End Sub

V-Q-3. For Next

Permet de faire des boucles.

Les boucles sont très utilisées pour parcourir une plage de valeur qui permet par exemple de parcourir tous les éléments d'un tableau ou pour effectuer de manière itérative un calcul.

Le nombre de boucle va être déterminé par une variable qui sert de compteur: la variable de boucle.

Le nombre d'exécution est déterminé au départ de la boucle car le compteur a une valeur de départ, une valeur d'arrêt.

Pour variable allant de 'début' à 'fin'

Boucler

donne en VB


For variable=début To fin

..

Next variable

Exemple:


Dim i as Integer

For i=1 to 10

MsgBox (i.toString)

Next i

En langage courant : Pour i allant de 1 à 10, afficher la valeur de i dans une MessageBox.

La variable compteur va prendre successivement les valeurs 1 puis 2 puis 3…… jusqu'à 10 et effectuer à chaque fois le code qui est entre For et Next.

Si on décompose :

i=1 Affiche « 1 », arrivé à Next, remonte à For, i =2 , affiche « 2 »……

... i=10 , affiche « 10 » poursuit après Next.

En effet i augmente d'une unité à chaque 'tour'.

Il peut y avoir un pas (Step), le compteur s'incrémente de la valeur du pas à chaque boucle.


Dim i as Integer

For i=1 to 10 Step 2

MsgBox i.toString

 Next i

Affiche 1 puis 3 puis 5 puis 7 puis 9

Attention si la valeur de sortie de boucle est inférieure à celle d'entrée il faut indiquer un pas négatif.


Dim i as integer

For i=10 to 1 Step -2

MsgBox (i.toString)

 Next i

Affiche 10 puis 8 puis 6 puis 4 puis 2

Bien sur on peut utiliser des expressions calculées :


For i=A to B*10 Step X-2

	MsgBox i.toString

Next i

La variable boucle peut être déclarée après For, dans ce cas cette variable n'existe que dans la boucle:


For K As Integer = 1 To 10
    ...
Next K

On peut quitter prématurément la boucle avec Exit For.


For K As Integer = 1 To 10
    ...
    If A=2 Then Exit For

Next K

Dans ce cas la boucle s'arrête de tourner si A=2, on poursuit après Next.

Remarque:

Le nom de la variable de boucle est facultatif après Next:


For K As Integer = 1 To 10
    ...
Next

Est correct.

Depuis la version 2005 il existe aussi Continue For qui permet de sauter au prochain Next et de poursuivre la boucle.

V-Q-4. Do Loop

Permet aussi de faire des boucles mais sans que le nombre de boucle (d'itération) soit déterminé au départ.

La boucle suivante tourne sans fin:


Do
Loop

Il faut une condition d'arrêt qui détermine la sortie de la boucle :

On doit mettre Until (Jusqu'à ce que) ou While (Tant que) avant la condition d'arrêt pour sortir de la boucle.

On peut mettre la condition après Do:


Do Until condition    

      Code

Loop

 'Boucler jusqu'à ce que condition soit vraie.

Si condition est fausse, effectuer le code, boucler et recommencer le code jusqu'à ce que condition soit égale à True.

Attention, avant de débuter la boucle, la condition doit être fausse sinon la boucle ne sera jamais exécutée..

A chaque boucle la condition est évaluée.

Exemple pour chercher un mot dans une liste :


Lire Premier Mot
Do Until MotCherché=MotPointé

      Pointer Mot suivant

Loop

On peut aussi utiliser While (Tant que)


Lire Premier mot
Do While MotCherché<>MotPointé

      Pointer Mot suivant

Loop

Tant que le mot cherché est différent du mot pointé, boucler.

La condition peut être mise en fin de boucle, cela permet d'effectuer au moins une fois le code. Cela évite aussi d'avoir à démarrer le processus avant la boucle, dans notre exemple cela permet d'éviter de lire le premier mot avant la boucle :

Les mots sont dans un tableau Mot(); premier élément Mot(0).


IndexMot=-1 

Do 

     IndexMot=IndexMot+1

Loop While MotCherché<>Mot(IndexMot)

Il faudrait en plus boucler jusqu'à la fin du tableau et pas plus.

Il y a Exit Do pour sortir de la boucle; il existe aussi Continue Do qui permet de sauter au prochain Loop et de poursuivre la boucle.

Exemple complet : Imposer la saisie d'un nombre négatif à l'utilisateur:

On utilise InPutBox qui ouvre une fenêtre et attend une réponse.


Dim Reponse as Single

Do

      Reponse=InPutBox(« Entrer un nombre négatif. »)

Loop  While Reponse>=0

Si le nombre n'est pas négatif, la boucle fonctionne et la boite InPutBox s'ouvre de nouveau. Si le nombre est négatif, on sort de la boucle.

Comment créer une boucle qui tourne sans fin?


Do

   ...   

Loop  While True

Autre exemple:

Créer une boucle affichant successivement dans une MessageBox les chiffres de 1 à 10.


Dim i As Integer = 0    

Do   

    i = i + 1          'incrémente i de 1    

   MsgBox(i.ToString)  'affiche la valeur de i dans une messageBox   

Loop Until i = 10      'sort de la boucle quand i=10

V-Q-5. While End While

Permet une boucle qui tourne tant qu'une condition est vraie.

Principe:


Tant que Condition
...
Fin Tant que

En VB:


While Condition

...

End While

Exemple: on incrémente un compteur, on sort quand il est égal à 20.


Dim Counter As Integer = 0
While Counter < 20 ' Test la valeur du compteur.
   Counter += 1 ' Incrémente le compteur.
End While

Il y a Exit While pour sortir de la boucle; il existe aussi Continue While qui permet de sauter au prochain End While et de poursuivre la boucle.

V-Q-6. For Each

C'est une variante de la boucle For mais elle permet de parcourir les objets d'une collection. Elle n'utilise pas l'indice.

Prenons un contrôle ListBox il a une collection Items qui contient tous les éléments de la ListBox

ListBox.item(0) contient la première ligne

ListBox.item(1) contient la seconde ligne

ListBox.item(2)…contient la troisième.

Parcourir tous les éléments de la ListBox et les mettre dans une variable V s'écrirait :


Dim mystring As String

Dim item as Object

For Each item in ListBox.Items

      mystring=mystring+item

Next

La variable de boucle peut être déclarée après For:


Dim mystring As String

For Each item As Objet in ListBox.items

      mystring=mystring+item

Next

Au lieu de déclarer Item comme un objet, on aurait pu le déclarer comme un ListBox.Item

Cette notion de collection est beaucoup plus large que je le pensais:

Ici pour tester chaque caractère dans une String, et voir s'il est égal à "i", on peut utiliser For Each:


Dim chaine As String = "aeiou"

Dim c As String

For Each car As String In chaine

    If car= "i" Then..

Next

Attention, dans une boucle For Each, on peut parcourir la collection mais on ne peut pas modifier un élément de la collection.

V-Q-7. Switch

Switch est utilisé avec des couples d'arguments, si le premier est vrai, le second est retourné.

Réponse=Switch( Expression1, Reponse1, Expression2, Reponse2)

Si Expression2 est vrai Reponse2 est retourné.


Monnaie= Microsoft.VisualBasic.Switch(Pays = "USA", "Dollar", _
Pays = "FRANCE", "Euro", Pays = "Angleterre", "Livre")

Si Pays="FRANCE", cette expression est vrai, le second objet du couple est retourné.

Retourne Euro

V-Q-8. IIF

IIf est utilisé avec 3 arguments.

Si le premier argument est vrai, le second est retourné.

Si le premier argument est faux c'est le troisième qui est retourné.


Reponse = IIf( Nombre > 0, "Positif", "Négatif ou 0")

Comme dans Switch on peut utiliser des procédures comme argument.

V-R. Les procédures et leurs paramètres

On se souvient qu'en programmation procédurale on découpe les problèmes en fonctions: les Sub et les Function.

Quand on appelle une procédure (un sous-programme, une routine), le logiciel 'saute' au sous-programme, il effectue celui-ci puis revient effectuer ce qui est sous l'appel.

En VB les procédures sont des Sub ou des Function.

- Les procédures Sub:

Elles débutent par le mot Sub et se terminent par End Sub. Elles ont des paramètres mais ne 'retournent' rien.

Exemple: une sub qui retourne la somme de 2 nombres:


Sub Addition (a , b, result)
result= a+b
End Sub

Pour l'utiliser:


Dim a, b, result As Integer
a=2
b=3
Addition (a ,b ,result)

- Les procédures Function:

Si on a besoin que la procédure retourne un résultat (un seul), on utilise une Fonction.

Elles débutent par Function et se terminent par End Function.

On peut fournir aux procédures des paramètres qui sont envoyés à la fonction.

Exemple:


Function Carré ( v as Single) As Single

    Return v*v

End Function

Cela crée une fonction qui se nomme 'Carré' , on peut lui envoyer un paramètre (elle accepte un Single dans v).

Cette fonction retourne un Single (indiqué par Function Carre() As Single) qui est le carré du paramètre fourni.

Pour l'utiliser :


Dim resultat As Single

resultat= Carré(2)        'resultat est alors égal à 4

On appelle la fonction carré avec le paramètre 2, elle retourne 4.

Les paramètres peuvent être des variables:


Dim resultat as Single

Dim valeur as Single=3

resultat= Carré(valeur)

Remarque: ici, on a un paramètre nommé 'valeur'; on appelle la fonction Carré avec ce paramètre. Dans la fonction Carré on retrouve ce paramètre; il se nomme 'v': Ce paramètre est passé à la fonction, mais il a un nom différent dans la fonction.

On conseille, quand le nom d'une procédure est composé de plusieurs mots, de mettre la première lettre de chaque mot en majuscule.

Exemple:


MyCalcul()

V-R-1. Les parenthèses

Rappel, même s'il n'y a pas de paramètre, mettre des () lors de l'appel de procédure.


MaRoutine()

V-R-2. Par Valeur, Par Référence

Il y a 2 manières d'envoyer des paramètres :

Par valeur : (By Val)c'est la valeur (le contenu de la variable) qui est envoyée.

(La variable est copiée dans une autre partie de la mémoire pour être utilisée par la routine appelée.)

Par référence :(By Ref) c'est l'adresse (le lieu physique ou se trouve la variable) qui est envoyée. Si la Sub modifie la variable, cette modification sera visible dans la procédure appelante après le retour.

Exemple de procédures:


Sub MaProcedure (ByRef x as Long, ByVal y As Long)

End Sub

Chaque paramètre est ByRef ou ByVal suivi du nom du paramétre dans la procédure puis de son type.

Si j'appelle cette procédure à partir d'une procédure nommée Main():


Sub Main()
Dim A, B As Long
         MaProcedure (A, B)

End sub

C'est l'adresse de A qui est envoyée et la valeur contenue dans la variable B. Elles se retrouvent dans les variables x et y de la procédure MaProcedure. Noter que le type de la variable fournie en paramètre dans Main et le type de la variable dans 'MaProcedure' doit être le même (ici un Long).

Si dans cette dernière je modifie x, A est modifié dans la Sub Main (puisque x et A pointe sur le même endroit). Si dans Maprocedure je modifie y , B n'est pas modifié.

Exemple permettant de bien différencier By Val et By Ref:

Exemple avec ByVal:


Sub MaProcedure

Dim A As Integer                                'On créer une variable A

A=1                                             'On met 1 dans A

Call MaProcedure(  A  ) 'On appelle la procédure MaProcedure  en envoyant le paramètre A 

Label1.Text= A.ToString 'On affiche la valeur de A

End Sub

 

Sub MaProcedure ( ByVal Variable As Integer )    'La procédure reçoit la valeur de A donc  1

                                                 ' et la met dans 'Variable' 

    Variable=Variable+1                           'Variable=2 mais A=1

End Sub

Après l'appel de la procédure A=1, Labe1 affiche '1' car bien que dans MaProcedure Variable =2 , cela n'a pas modifié A.

Exemple avec ByRef:


Sub MaProcedure

Dim A As Integer                                'On créer une variable A

A=1                                             'On met 1 dans A

Call MaProcedure(  A  ) 'On appelle la procédure MaProcedure en envoyant le paramètre A 

Label1.Text= A.ToString 'On affiche la valeur de A

End Sub

 

Sub MaProcedure ( ByRef Variable As Integer )    
'La procédure reçoit l'adresse de A ; Variable et A ont donc même adresse

                                                 'Variable et A contiennent 1 

    Variable=Variable+1                          'Variable=2 mais A=2 aussi

End Sub

Après l'appel de la procédure A=2, , Labe1 affiche '2' car La procédure reçoit l'adresse de A ; Variable et A ont donc même adresse; si je modifie variable cela modifie A.

Compris!!

L'avantage de passer un argument ByRef est que la procédure peut retourner une valeur au code qui a appelé la procédure en modifiant la valeur de la variable qui a été passée en argument.
L'avantage de passer un argument ByVal est que la variable de la routine est 'protégée' dans le code qui a appelé la procédure; elle ne peut pas être modifiée par la procédure qui reçoit le paramètre.

V-R-3. Par Défaut, que se passe-t-il ?

Si on n'indique pas By Val ou By Ref:

ATTENTION: Par défaut les paramètres sont transmis PAR VALEUR

Pour la clarté du code et pour éviter toute ambiguïté, spécifier ByRef ou ByVal, c'est plus lisible , plus clair.

Taper Sub MaProcedure (ByRef x as Long, ByVal x As Long)

Plutôt que Sub MaProcedure ( x as Long, x As Long)

V-R-4. Optional

Un paramètre ou argument peut être Optional, c'est à dire facultatif.

Indique que cet argument n'est pas requis lorsque la procédure est appelée. Si ce mot clé est utilisé, tous les arguments suivants doivent aussi être facultatifs et déclarés à l'aide du mot clé Optional. Chaque déclaration d'argument facultative doit indiquer une valeur par défaut qui sera utilisée dans la routine s'il n'y a pas de paramètre.


Sub MaRoutine (Optional X As Integer=0)

V-R-5. Tableau de paramètres

Il est possible d'envoyer un tableau comme paramètre.

Exemple:


Dim Reponses(10) As Integer

'Appel de la Sub
Affiche( Reponses())

La Sub 'Affiche' débute par:


Sub Affiche ( ByVal R() As Integer )

End Sub

V-R-6. ParamArray

Parfois il faut envoyer des paramètres de même type mais dont on ne connaît pas le nombre, dans ce cas on utilise ParamArray (Liste de paramètres):

Exemple d'une Function nommée 'Somme' qui calcule la somme de X Integer.


Function Somme ( ByVal ParamArray Valeurs() as Integer) As Integer

    Dim i as Integer

    Dim Total as Integer

    For i=0 to Valeurs.Length-1

        Total += Valeurs(i)

    Next i

    Return  Total

End Sub

Pour appeler cette fonction:


Dim LeTotal As Integer

LeTotal= Somme (2, 5, 6, 8 ,5)

A noter que le paramètre ParamArray doit être le dernier des paramètres, c'est obligatoirement un paramètre ByVal et comme on l'a dit, tous les paramètres sont de même type.

V-R-7. Portée des procédures

Le terme Sub ou Function peut être précédé d'une indication de portée; la procédure sera t-elle visible uniquement dans le module où elle se trouve ou partout?

La procédure peut être Private. Dans ce cas on ne peut l'appeler qu'à partir du module qui la contient.

Les procédures évènements, d'une Form sont, par exemple, Private:


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

End Sub

La procédure peut être Public. Dans ce cas on pourra l'appeler à partir de la totalité du programme.

La Sub 'Calcul' qui est par exemple dans un module, peut être appelée de partout.


									
Public Sub Calcul

End Sub

V-R-8. Nommage

Sub , Fonctions

Utilisez la 'case Pascal' pour les noms de routine (la première lettre de chaque mot est une majuscule).

Exemple: CalculTotal()

Évitez d'employer des noms difficiles pouvant être interprétés de manière subjective, notamment Analyse() pour une routine par exemple.

Utilisez les verbe/nom pour une routine : CalculTotal().

Pour les noms de paramètres, utilisez la 'case Camel' selon laquelle la première lettre des mots est une majuscule, sauf pour le premier mot.

Exemple: typeName

V-S. Portée des variables

Quand on déclare une variable, jusqu'où est-elle visible?

Quand une variable est visible, on peut l'utiliser. Il est important souvent de rendre une variable visible dans une procédure mais pas les autres, dans un seul module ou dans la totalité du programme. Comment faire celà?

V-S-1. Dans les procédures

On déclare une variable avec Dim.

Si on déclare une variable dans une procédure (une Sub ou une Function), elle est visible uniquement dans cette procédure, c'est une variable locale:


Sub MaProcedure (ByRef X As Integer)

    Dim Y As Integer

    ...

End sub

Y est déclaré en début de procédure, on pourra travailler avec Y dans la procédure jusqu'à End Sub.

Dans une autre procédure Y ne sera pas visible (l'utilisation de Y déclencherait une erreur.)

Après End Sub Y n'existe plus, son contenu est perdu.

Il en est de même pour X qui est déclaré sur la ligne Sub (X reçoit la valeur envoyée comme paramètre).

Une autre procédure pourra déclarer et utiliser une variable Y, mais, même si elle a le même nom cela ne sera pas la même: chaque variable Y est uniquement visible dans sa procédure.

Variable statique:

Si à la place de Dim on utilise Static, la variable est dite 'Statique': A la sortie de la procédure, la variable et sa valeur continue d'exister et on garde sa valeur en mémoire; lors des appels suivants de la procédure, on retrouve la valeur de la variable.

Exemple


Sub compteur

    Dim A as integer

    Static B as integer

    A +=1

    B +=1

End sub

A chaque appel de cette procédure A prend la valeur, 0 puis 1 puis disparaît.

B prend les valeurs 0, puis 1, puis 2... (incrémentation à chaque appel)

V-S-2. Dans un bloc d'instructions

Si vous déclarez une variable dans un bloc, elle ne sera visible que dans ce bloc:


Do

Dim Compteur As integer

 Compteur +=1

...

Loop

La variable Compteur existe uniquement entre Do et Loop.

Cela est aussi valable pour les blocs If:

Exemple:


If A=0 Then

    Dim risk As String = "Haut"

Else

    Dim risk As String = "Bas"

End If

Console.WriteLine("Le risque est " & Risk)

Dans la dernière ligne Risk est souligné comme contenant une erreur car il est considéré comme non déclaré. En effet les 2 déclarations Dim risk sont dans les blocs 'If..Else' et 'Else..End If'.

Attention quand même à la position de la variable locale, il peut y avoir des pièges:

Voyons ce code:


Dim i, j,  As Integer

For i = 1 To 10
    For J = 1 To 3
        Dim k As Integer
        K+ =1
        'Imprimer k
    Next
Next

On souhaite que K=1 puis 2 ,3 ,1 ,2 ,3.. FAUX!!

Cela donne :1 ,2 ,3 ,4 ,5 ,6 ,7 ....30 !!!??? pas normal

En remplaçant par Dim k As Integer = 0 cela donne des 1 ,1 ,1 ,1 ,1 , 'normal

Et en intercalant la déclaration de k entre les 2 For, cela marche comme on le souhaite:1, 2 ,3 ,1 ,2 ,3 .


Dim i, j,  As Integer

For i = 1 To 10 

    Dim k As Integer
    For J = 1 To 3
        K+ =1
        'Imprimer k
    Next
Next

V-S-3. Dans la section déclaration d'un Module

Dans la section déclaration d'un module (en haut du module juste après la ligne 'Module'), on utilise à la place de Dim:

Private, dans ce cas la variable est propre au module, elle est visible dans toutes les procédures du module, pas dans les autres modules.

Public, dans ce cas la variable est accessible dans la totalité du programme.


Module Module1

    Public A as String

    ....

 Sub MaRoutine

 End Sub

End Module

A est accessible partout dans la totalité du programme.

(On parle dans ce cas de variable dite 'Globale'.)

V-S-4. Dans la section déclaration d'une fenêtre, d'un formulaire

Dans la section déclaration d'un formulaire (en haut du formulaire juste après la ligne 'Inherits')

Private; indique dans ce cas que la variable est propre au formulaire, elle est visible dans toutes les procédures du formulaire, pas dans les autres modules ou formulaires.

Public; indique de même une variable UNIQUEMENT visible dans le formulaire.

Elle est visible hors du formulaire à condition de la préfixer avec le nom du formulaire (Class1.A).


Class Class1

   Inherits System.Windows.Forms

    Public A as String

    ....

 Sub MaRoutine

 End Sub

End Class

Exemple:

On peut atteindre la zone de déclaration en déroulant le menu de droite.

Dans l'exemple ci dessus:

MaVariable est visible dans le formulaire. et hors du formulaire à condition d'utiliser Form1.MaVariable.

MaVariable2 est visible dans le formulaire .

MaVariable3 n'est visible que dans la procédure Button1_Click.

V-S-5. En pratique

Pour se repérer et se souvenir quelle est la portée d'une variable, on utilise une lettre en début du nom de la variable (notation avec un préfixe dite 'hongroise'):

g_MaVariable sera public (g comme global).

m_Variable2 sera accessible au niveau du module.

Dans un module standard, on peut mettre 'Public' toutes les variables que l'on veut rendre accessible à tout le programme. Ce sont les variables (et constantes) générales utilisées dans la totalité de l'application: état du programme, utilisateur en cours...Pour des raisons que nous verrons plus loin, il faut éviter ce type de variable publique dites 'globale'.

Dans chaque formulaire on met dans la section déclarations, les variables du module: état du formulaire. Variable permettant l'affichage...

Dans chaque procédure les variables locales, compteur de boucle...

Pour les variables locales on peut donc utiliser un même nom dans différentes procédures, par exemple, on nomme souvent I les variables de boucle dans toutes les procédures, par contre

il faut éviter de donner un même nom à des variables dont la portée se recoupe.

VB l'accepte et utilise la variable la plus proche, celle du bloc ou du module...mais c'est dangereux et générateur de bugs.

De manière générale utiliser des variables avec une portée la plus réduite possible.

V-S-6. En général

Que se soit pour les variables, procédures ou Classes:

- Les variables qui sont Dim sont accessibles dans une procédure.

- Celles qui sont Public sont accessibles dans la totalité du programme.

- Celles qui sont Private ne sont accessibles qu'à l'intérieur même du module.

il y a en plus:

- Celles qui sont Protected sont similaires aux Private, mais dans le cas des classes, elles ont une particularité en cas d'héritage.

- Celles qui sont Friend ne sont accessibles qu'à l'intérieur du projet, et pas par des éléments extérieurs au projet en cours.

Précédent Sommaire Suivant

Les sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre cette page de présentation de ces sources constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © . Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.