Depuis son apparition, le langage Visual Basic ainsi que ses divers environnements de développement ont su s’imposer comme les standards en matière d’outils de réalisation d’applications Windows.
|
Version |
Nouveautés |
|
1.0 |
Sortie en 91, Visual Basic innove en particulier grâce à son environnement de développement permettant de masquer les tâches fastidieuse |
|
3.0 |
Evolution du langage, apparition de nouvelles fonction et de structures de contrôle (select case) |
|
4.0 |
Sorti en 96, la version 4.0 marque une étape importante dans l’évolution du langage : - Création d’application 32 bits - Création et utilisation de DLL - Apparition des fonctionnalités Objet (Classes) |
|
5.0 |
Disparition des applications 16 bits et stabilité accrue du langage |
|
6.0 |
Peu d’évolution sur le langage mais apparition de la technologie ADO (remplaçante de DAO et RDO) et des outils de connexion aux sources de données (DataEnvironment) |
La version .Net (ou version 7.0) de Visual Basic et plus généralement de l’IDE Visual Studio marquent une étape importante dans l’évolution du langage. L’élément principal de l’infrastructure .NET est le CLR (Common Language Runtime), langage offrant un ensemble de classe permettant à l’utilisateur d’interagir avec le système. Ces classes peuvent être utilisée avec n’importe quel langage .Net (Vb, C++, C#) car elle font partie d’une norme commune : le CLS (Common Language Specification).
Une autre des révolutions du .Net réside dans le MSIL (Microsoft Intermediate
Language) : les applications réalisées avec Vb .Net sont d’abord compilés en pseudo code, le
MSIL, et c’est lors de l’exécution que le compilateur (JIT pour Just In Time) compile le code MSIL afin de le rendre exécutable par le processeur utilisé. L’avantage de ce système est double :
- Gain de ressource lors de l’exécution car seules celle devant être utilisées seront chargées et de ce fait, leur installation préalable n’est pas obligatoire
- Portabilité des applications sur différentes plateformes à la manière de la machine virtuelle Java.
A l’instar de la version 6.0, développer en VB .Net requiert une configuration machine beaucoup plus importante.
Ci dessous figurent les spécifications Microsoft :
|
Config. Minimum |
Config Optimale |
|
|
Processeur |
P2 450 Mhz |
P3 733 Mhz |
|
Mémoire Vive (Ram) |
128 Mo |
256 Mo |
|
Espace Disque |
3 Gb |
3Gb |
|
Carte Vidéo |
800x600, 256 Couleurs |
1024x768, 65536 Couleurs |
|
Lecteur CD Rom |
Obligatoire |
Obligatoire |
|
Système d’exploitation |
Windows 2000 Windows NT 4.0 Windows Me Windows 98 |
|
Ces spécifications concernent l’utilisation du FrameWork .Net ainsi que de l’IDE, pas l’exécution des programmes MSIL.
Les habitués de Visual Studio 6.0 ne seront pas déroutés : l’interface de Visual Basic .net reprend la plupart des palettes standards avec quelques outils en plus :
- la barre d’outils regroupe les différents contrôles par catégories
- La zone centrale permet tour à tour d’écrire le code et de définir les interfaces graphiques utilisateurs
- A droite, l’explorateur de solutions et la fenêtre de propriétés
L’explorateur de serveur permet de recenser sous forme hiérarchique l’ensemble des objets d’un serveur (Serveurs SQL, journaux, Services …). Cette fenêtre est principalement utilisées afin d’accéder au schéma d’une base de données utilisée dans une application.
L’explorateur de solutions (Ex explorateur de projet sous
VB 6.0) référence l’ensemble des éléments du projets (Fichier de configuration pour l’assemblage, super classes hérités, Feuilles….)
Une solution contient les fichiers suivants : .sln : fichier de configuration de la solution
.vbproj : fichier projet, (ancien .vbp)
.vb : fichiers contenant du code (anciens .bas, .frm, .cls)
.resx : associé à une feuille, contient les ressources
L’affichage de classes liste de manière hierarchique les différentes classes du projet ainsi que leurs méthodes, propriétés, évènements et autre relations d’héritage.
Déjà présente dans la version 6.0, cette fenêtre recense toutes les propriétés relatives à l’objet selectionné.
L’aide dynamique propose à tous les moments de la conception des rubriques d’aide utiles en fonction de ce que vous faîtes. Par exemple, la rubrique « créer une collection de contrôles » sera affichée lorsque vous ajouterez un bouton radio à votre application.
La fenêtre liste des tâche permet de recenser l’ensemble des tâche à réaliser sur votre projet.
Cette liste peut être remplie de plusieurs façons :
- Une tâche que vous aurez vous même définie (ex : appeler le client à 11h)
- Une tâche issue des commentaires de votre code : tous commentaires de votre code commencant par « todo: » sera automatiquement ajouté
- Lorsqu’une erreur de syntaxe est détectée par Visual Studio, elle est automatiquement ajoutée dans la liste
-
Une solution le plus haut conteneur logique d’éléments (projets, fichiers, feuilles, classes). Une solution peut contenir plusieurs projets.
Il est possible de créer un projet soit directement dans une solution ouverte soit dans une nouvelle solution.
• Menu Fichier > Nouveau > Projet
|
Principaux projets Visual Basic |
|
|
Type |
Description |
|
Application Windows |
|
|
Bibliothèque de classe |
|
|
Bibliothèque de contrôle Windows |
|
|
Application Smart Device |
|
|
Application Web |
|
|
Service Web |
|
|
Application console |
|
|
Service Windows |
|
Pour chaque projet de votre solution, un ensemble de propriétés sont configurables. Pour accéder aux propriétés d’un projet, clic droit sur le projet dans l’explorateur de solution et Propriétés.
|
Propriétés communes |
|
|
Propriété |
Description |
|
Nom de l’assembly |
Nom du fichier généré après compilation (MSIL) |
|
Type de sortie |
Type d’application a générer |
|
Objet de démarrage |
Feuille ou procédure servant de point de départ au programme |
|
Espace de nom racine |
Permet de définir un préfixe pour accéder à l’ensemble des classes disponibles dans le projet |
|
Icône de l’application |
Fichier .ico servant d’icône au fichier de sortie |
|
Option explicit |
Interdit l’utilisation d’une variable non déclarée |
|
Option Strict |
Oblige l’écriture de explicite de la conversion de données |
|
Option compare |
Distinction de la casse en mode binaire (pas en mode texte) |
|
Espaces de noms |
Permet de définir les espaces de noms qui devront être automatiquement importés dans le projet (ex : permet d’écrire « form » à la place de « » |
|
Chemin d’accès de référence |
Définit les dossiers dans lesquels se trouvent les références utilisées dans le projet |
|
Présentation page |
Mode de positionnement des contrôles : en mode Grid, le placement est libre, en mode Flow, le placement se fait dans l’ordre de création. |
|
Schéma cible |
Navigateur pour lequel le code HTML doit être compatible |
|
Langage de script Client |
Type de langage à utiliser |
|
Propriétés de configuration |
|
|
Propriété |
Description |
|
Action de démarrage |
Action à réaliser par l’environnement lors de la demande |
|
d’exécution |
|
|
Argument de la ligne de commande |
Permet de passer des paramètres lors de l’exécution du programme |
|
Répertoire de travail |
Répertoire actif pour l’application |
|
Débogueurs |
Débogueurs à activer lors de l’exécution |
|
Optimisation |
Définit un ensemble de contrôles que le compilateur ne fera pas lors de la compilation du programme |
|
Chemin de sortie |
Répertoire où sera généré l’exécutable ou la bibliothèque |
|
Activer les avertissements de génération |
Si coché, le compilateur ajoutera ses remarques à la liste des tâches |
|
Considérer les avertissements du compilateur comme des erreurs |
Lors de la compilation, les avertissements (Warning) fait par le compilateur stopperont la compilation (aucun fichier généré) |
|
Constantes de compilation conditionnelles |
Cette option permet de définir des constantes qui influeront sur les lignes compilées |
Un exemple valant mieux qu’un long discours, nous allons commencer par décortiquer un programme de base avant de parcourir le langage en lui même.
Lors de la création d’un formulaire, le code suivant est automatiquement généré :
- Le code est en fait constitué de la définition d’une nouvelle classe portant le nom du formulaire.
- L’instruction « inherits » indique que la classe que nous créons doit hériter (récupérer) de tous les éléments inscrits dans la classe « form »
- Enfin, la région « Code généré par le concepteur Windows Form » contient l’appel aux méthodes de base de classe form ainsi que l’initialisation des contrôles.
Tout ajout d’éléments au formulaire (Variables, procédures, contrôles) seront ensuite perçus (selon leur visibilité) comme membres de la classe « form1 ».
Lors de la création d’un nouveau module, le code suivant est automatiquement généré :
Tout le code contenu dans le module sera inséré entre « module » et « end module »
Les commentaires permettent d’ajouter des annotations sur le code qui, une fois la compilation lancée, ne seront pas traitées par le compilateur et ainsi exclue du programme final.
Pour ajouter un commentaire, utiliser le caractère apostrophe « ‘ ». lorsqu’un commentaire est ajouté, tout le reste de la ligne sera un commentaire.
‘ceci est un commentaire
Dim mavar as string ‘ceci est un autre commentaire
Il n’est pas possible de créer des commentaires multilignes. Dans ce cas, vous êtes obligé de répéter le caractère apostrophe au début de chaque ligne
A noter que lorsqu’un commentaire commence par le mot clé todo:, il sera automatiquement ajouté dans la liste des tâches
‘todo: commentaire automatiquement ajouté dans la liste des tâches
Les régions sont une nouvelle fonctionnalité de Visual Basic permettant de masquer une partie du code pour gagner en lisibilité.
La fonctionnalité appliquée aux région se retrouve sur chaque procédure Visual Basic : le signe + situé à gauche du nom des procédures permet de ne garder que leur déclaration.
Il est possible de créer vos propres régions avec la syntaxe suivante :
#Region ‘’libellé de la région‘’
…
#End Region
|
#Region ‘’Déclaration des variables’’ dim i, j as integer =0 dim nom as string #End Region |
Les variables permettent de stocker des informations lors de l’exécution du programme.
Une variable est caractérisée par les informations suivantes
- Un nom : le nom d’une variable commence obligatoirement par une lettre, peut contenir des lettres, chiffres et le signe « _ » (underscore) avec un maximum de 255 caractères. Visual Basic ne tient pas compte de la casse (Majuscules / Minuscules)
- Un type : le type d’un variable précise le type de la valeur stockées par la mémoire (numérique, chaîne de caractère, date …)
- Une portée : la portée d’une variable correspond à sa durée de vie
|
Nom |
Min |
Max |
Taille |
|
|
Byte |
0 |
255 |
8 bits |
|
|
Short |
-32768 |
32767 |
16 bits |
|
|
Integer |
-2 147 483 648 |
2 147 483 647 |
32 bits |
|
|
Long |
-9223372036854775808 |
9223372036854775807 |
64 bits |
|
|
Single |
-3.402823 E 38 |
3.402823 E 38 |
32 bits |
|
|
Double |
-1.79769313486231 E 308 |
-1.79769313486232 E 308 |
64 bits |
|
|
Decimal |
-79228162514264337593543950335 |
79228162514264337593543950335 |
16 Octets |
|
Depuis la version .Net, les chaînes de caractère sont enregistrées au format Unicode, c’est à dire que chaque caractère utilise 2 octets.
|
Nom |
Description |
Exemple |
|
Char |
Utilisé pour stocker un seul caractère |
‘’a’’ |
|
String |
Chaîne de caractère à longueur variable d’une taille de 0 à environ 1 milliard de caractères |
‘’Sandrine Desayes’’ |
... ... ...
La déclaration des variables permet, lors de l’exécution d’un programme de réserver l’espace mémoire nécessaire au stockage des informations. Par défaut, la déclaration des variables est obligatoire mais il est possible de la désactiver (voir les options communes de projet). Il est cependant déconseiller de la désactiver car une simple erreur de syntaxe au niveau du nom d’une variable ne sera pas interprété comme une erreur par le compilateur et de ce fait, le programme travaillera sur deux emplacements mémoire bien distincts.
La déclaration des variables se fait de la façon suivante
Dim nomvariable1, nomvariable2, nomvariable3 as type_variables = valeur_par_defaut
L’affectation d’une valeur par défaut est facultative.
Dim i as integer = 0
Dim moncar as char = ‘’i’’
Dim aujourdui as date = #12/07/02#
Dim nom as string
La portée d’une variable est équivalent à sa durée de vie, c’est à dire tant qu’elle est accessible. La portée est définie en fonction de l’endroit où est placée sa déclaration. Quatre niveaux de portée existent :
- Niveau Bloc : si la variable est déclarée dans un bloc (boucle while, condition …), la variable ne sera valable que à l’intérieur du bloc
- Niveau Procédure : si la variable est déclarée à l’intérieur d’une procédure ou d’une fonction, elle ne sera accessible qu’à l’intérieur de cette procédure / fonction
- Niveau Module : la variable déclarée dans un module sera accessible uniquement à partir des éléments du modules (procédures, fonctions)
- Niveau projet : la variable est accessible à partir de tous les éléments du projet. Dans ce cas, il faut utiliser le mot clé « friend » à la place du mot « dim ».
En dehors de l’emplacement où est définie la variable, plusieurs mot clés sont disponibles pour agir sur la visibilité :
- Public : tous les blocs de code peuvent accéder à la variable
- Private : seul les éléments membres de la classe ou du module peuvent y accéder
Dim i as integer Public y as string
Private z as integer
Un tableau est un regroupement de variables accessibles par le même nom et différentiables par leurs indices.
- Un tableau peut avoir jusqu’à 32 dimensions.
- Les indices de tableaux commencent toujours à 0.
- Lors de la déclaration d’un tableau, l’indice maximum est précisé : le tableau comportera donc (indice_max + 1) valeurs.
Dim montableau(10) as integer
Dim tableau2(5) as string
Pour accéder à un élément du tableau, il faut préciser le nom du tableau avec entre parenthèses l’indice de l’élément désiré.
Montableau(2) = 123
Tableau2(5) = ‘’toto’’
En Vb, les tableaux sont dynamiques, c’est à dire qu’il est possible de modifier leur taille. Pour cela, il faut utiliser l’instruction « Redim » suivi du nom du tableau et de sa nouvelle taille.
Redim montableau(15)
Cependant, l’instruction « Redim » ne conserve pas les données déjà présentes dans le tableau. Pour conserver son contenu, utiliser le mot clé « preserve »
Redim preserve montableau(15)
Les constantes permettent de stocker une valeur en s’assurant qu’elle ne sera jamais modifiée. Elles sont généralement utilisées pour améliorer la modularité du code en ne définissant qu’une seule fois une valeur utilisée plusieurs fois.
Il n’est pas obligatoire de préciser le type de la constante sauf lorsque l’option « Strict » du compilateur est activée.
Dim tx_tva = 19.6
Dim voyelles as string = ‘’aeiouy’’
Les énumérations permettent de définir un type de variable dont les valeurs appartiennent à un domaine précis. Chacune des valeurs d’une énumération correspond à un entier : le premier élément de l’énumération est initialisé à 0, le second à 1 etc…
Enum civilite
Monsieur
Madame
Mademoiselle
End enum
Il est cependant possible de personnaliser les indices utilisés :
|
Enum jour Jeudi = 4 Lundi = 1 Dimanche = 7 … End enum |
Une fois l’énumération déclarée, il est possible de déclarer une variable du type de l’énumération.
Dim macivilite as civilite
De cette façon, la variable macivilite pourra uniquement prendre les valeurs définies dans l’énumération :
... ... ...
De manière générale, les énumérations sont utilisées pour le passage de paramètres, de façon à utiliser des constantes « parlantes » plutôt que des valeurs numériques pas toujours compréhensibles.
il existe 5 types d’opérateurs
Un seul opérateur d’affectation existe et ce quelque soit le type de données concerné : le signe égal « = ». Il permet d’affecter une valeur à une variable.
Mavar = 123
Attention, le signe égal est aussi utilisé pour la comparaison.
Il est également possible d’utiliser les opérateurs arithmétique lors d’une affectation.
Dim i as integer = 5
I += 3 ‘équivalent à i = i + 3
les opérateurs arithmétique permettent d’effectuer des calculs sur des variables, constantes …
... ... ...
Dim nombre as double
Nombre = 50 + 7
Nombre = 8 mod 2
Il permettent de comparer deux membres et, en fonction du résultat, retournent True ou False
... ... ...
La concaténation est l’union de deux chaînes. Deux opérateurs existent :
- Le plus « + » : dans ce cas, il faut que les deux membres de la concaténation soient de type chaîne de caractères.
- L’éperluette « & » : dans ce cas, l’opérateur effectue une conversion implicite lorsque les deux membres ne sont pas des chaînes de caractères.
... ... ...
Les opérateurs logiques permettent de combiner des expressions logique (renvoyant True ou False) à l’intérieur de conditions.
Par rapport à la version 6 du langag, deux opérateurs font leur apparition : AndAlso et OrElse. Ces opérateurs permettent une optimisation des conditions dans le sens où il n’effectueront le second test que si le premier ne répond pas à la condition.
... ... ...
Les structures de contrôle permettent de modifier le nombre d’exécution d’une instruction.
Une condition est une comparaison entre deux membres dont le résultat retourne True (Vrai) ou False (Faux). Une condition est composée d’au moins 2 membres (variables, constantes, appel de fonction) et éventuellement d’opérateurs logiques permettant de lier les sous conditions. Les conditions sont utilisées dans les structures de contrôle afin d’en définir leur fonctionnement.
Egalement nommées structures de décision, les structures conditionnelles aiguillent l’exécution de tel ou tel bloc de code en fonction d’une condition.
Plusieurs syntaxes sont possibles :
• Forme simple
A utiliser dans le cas où vous ne souhaitez réaliser qu’une seule instruction lorsque la condition est vérifiée. Dans ce cas, la condition et l’instruction à réaliser doivent se trouver sur le même ligne.
If qte_stock < 10 then nouvelle_commande()
• Forme normale
La forme normale permet d’exécuter plusieurs instructions lorsque la condition est vérifiée.
If qte_stock < 10 then
nouvelle_commande()
prevenir_service_reception()
End if
• Forme évoluée
La forme évoluée permet d’exécuter plusieurs instructions lorsque la condition est vérifiée et d’exécuter d’autres instructions.
If note < 10 then
Msgbox(‘’Examen échoué’’)
Else
Msgbox(‘’Examen réussi’’)
End if
La structure de contrôle Select Case permet d’effectuer un ensemble de test sur une seule valeur. Cette valeur peut-être le contenu d’une variable, le résultat d’un calcul ou d’une fonction. Le principal intérêt de cette structure est de clarifier le code : en effet, toute utilisation de cette structure peut être remplacée par un ensemble de structures If.
Les différentes possibilités de test sont les suivantes :
- Case constante : test valide si valeur = constante
- Case min to max : pour les valeurs numérique, permet de définir un interval
- Case is > constante : pour les valeurs numériques, définition d’un interval non fermé
- Case Else : cette condition sera validée si tous les tests définis dans le select case sont faux
Dim note as integer
Note = inputbox(‘’Veuillez saisir une note’’)
Select case Note
Case is <= 10
Msgbox(‘’Examen échoué’’)
Case 11 to 19
Msgbox(‘’Examen réussi’’)
Case 20
Msgbox(‘’Excellent, tout est juste’’)
Case else
Msgbox(‘’Note invalide’’)
End Select
3 autres instructions existent pour effectuer des tests :
• Iif
L’instruction IIF permet d’évaluer une condition et de retourner des valeurs différentes en fonction du résultat de la condition.
IIF (condition, valeur_retournée_si_vrai, valeur_retournée_si_faux)
Appreciation = iif(note < 10, ‘’Echoué’’, ‘’Reçu’’)
• Switch
L’instruction Switch regroupe plusieurs conditions et retourne le résultat correspondant pour la première condition vraie.
Switch (condition1, valeur1, condition2, valeur2 ….)
Lib_famille = Switch (code_famille=1, ‘’Info’’, code_famille=2, ‘’Consommable’’)
• Choose
L’instruction Choose permet de choisir une valeur dans une liste en fonction d’un Index. Attention, les Index commencent à 1 !
Choose(index, valeur1, valeur2 ….)
Lib_famille = Choose(code_famille, ‘’Info’’, ‘’Consommable’’)
Les structures répétitives ou structures de boule permettent d’exécuter un bloc d’instructions un certain nombre de fois.
La structure while répète les instructions contenues entre While et End while tant que la condition est vérifiée.
While condition
…
end while
dim i as integer = 0 while i < 10
msgbox (i) i++
end while
La structure do loop possède 4 variantes. Elle peut être paramétrée avec les mots clés while (tant que la condition est vérifiée) et Until (Jusqu’à ce que la condition soit vérifiée).
Do while condition
…
loop
Do until condition
…
loop
Dans ces deux cas, la condition est évaluée une première fois avant l’entrée dans la boucle, c’est à dire qu’il est tout à fait possible que les instructions de la boucle ne soient exécutées aucune fois.
Une seconde variant de cette structure permet d’exécuter au moins une fois les instructions de la boucle et d’évaluer la condition ensuite :
Do
…
loop while condition
Do
…
loop until condition
4.4.3.3 Structure For
La structure For est utilisée pour exécutée un bloc d’instruction un nombre de fois déterminé tout en gérant un compteur qui sera automatiquement incrémenté. Le nombre d’exécution est fonction de l’intervalle définit pour le compteur :
For compteur = valeur_depart to valeur_fin step valeur_increment
…
next
L’exemple suivant affiche les nombres 1,3,5,7,9
dim i as integer for i = 1 to 10 step 2
msgbox (i)
next
La structure For Each permet de parcourir un tableau ou une collection (tableau d’objets) sans se préoccuper de leurs indices. L’utilisation d’une telle structure est généralement plus rapide lors de l’exécution qu’un parcourt par indices.
For each element in collection_ou_tableau
…
next
Dans une application Visual Basic, les instructions doivent obligatoirement figurer dans une procédure ou une fonction. Ce sont des unités logique de code qui seront ensuite appelées. Le découpage d’un programme en procédures et fonctions présente plusieurs intérêts :
• Lisibilité du code : lors de débogage, il est plus facile d’analyser le comportement de plusieurs blocs de code de 10 lignes qu’un pavé de 200 lignes
• Modularité : l’écriture de procédures et fonctions permet ensuite d’effectuer des appels à partir de plusieurs endroits dans le code au lieu de réécrire les même instructions
• Evolutivité : lorsqu’une procédure est utilisée dans plusieurs partie du programme, modifier la procédure permettra de répercuter les modifications pour tous les appels de la procédure
Enfin, il existe plusieurs cas dans lequel l’utilisation de procédures est imposé par Vb.
Il existe en Vb 4 catégories de procédures :
• Les procédures sub qui exécutent du code à la demande
• Les procédures évènementielle déclenchées automatiquement lorsqu’un événement se produit (clic sur un bouton par exemple)
• Les fonctions qui exécutent un bloc de code et retournent une valeur
• Les procédures de propriétés obligatoires lors de la manipulation d’objets (leur utilisation est spécifié dans le chapitre consacré aux objets)
L’utilisation d’une procédure comporte deux étapes : la déclaration définissant le comportement de celle ci et l’appel demandant l’exécution.
Attention, la déclaration d’une procédure ne l’exécute en aucun cas !!!
public sub nom_procedure(paramètres)
…
end sub
- Toutes les instructions situées entre sub et end sub feront partie de la procédure
- Le nom d’une procédure suit les même règles que pour les variables
- Il possible de préciser la visibilité de la procédure en remplaçant public par private ou friend
Pour appeler une procédure, il suffit de placer son nom avec le mot clé call (facultatif)
Call nom_procedure(valeurs_parametres) nom_procedure(valeurs_parametres)
Les fonction sont des procédures retournant un résultat.
Lors de la déclaration d’une fonction, il faut reprendre les même éléments que pour les procédures avec en plus le type de retour de la fonction (String, integer…).
La fonction doit également comporter l’instruction Return qui permet de définir la valeur retournée par la fonction.
|
Public function nom_fonction(paramètres) as type_retour … return valeur_retour end function |
Nous l’avons dit plus haut, un fonction est une procédure retournant une valeur. Cette valeur peut être issue d’un calcul ou être un code erreur. De ce fait, lors de l’appel d’un fonction, il faut récupérer le résultat afin de le traiter. Le résultat peut donc être stocké directement dans une variable ou encore être passé en paramètre à une autre procédure ou fonction.
Variable = nom_fonction(valeurs_parametres)
Msgbox (nom_fonction(valeurs_parametres))
Le passage de paramètres permet de personnaliser le fonctionnement d’une procédure ou d’une fonction en lui précisant lors de l’appel les valeurs sur lesquelles elle devra travailler.
C’est lors de la déclaration de la procédure ou de la fonction que vous devez préciser les paramètres attendus. Ces paramètres seront ensuite utilisables comme des variables locales à la procédure.
Public sub nom_procedure (parametre1 as type_parametre1, parametre2 as type_parametre2 …)
Public sub feliciter (nom as string)
Msgbox (‘’bravo ‘’ & nom)
End sub
Dans certains cas, un paramètre peut être facultatif. Dans ce cas, il faut placer le mot clé optionnal devant le paramètre et, éventuellement, spécifier la valeur par défaut avec l’opérateur d’affectation :
Public sub feliciter (nom as string, optional prenom as string = ‘’inconnnu’’)
Msgbox (‘’bravo ‘’ & nom & ‘’ ‘’ & prenom)
End sub
Lors de l’appel d’une procédure ou d’une fonction, il faut donner les valeurs des différents paramètres utilisés par la fonction.
Feliciter(‘’Dupont’’)
Feliciter(‘’Dupont’’, ‘’gerard’’)
Lors du passage de paramètres à une procédure ou à une fonction, deux méthodes sont disponibles :
• Passage par valeur
C’est le mode de passage de paramètre par défaut : lors du passage par référence, seule la valeur du paramètre est passé à la procédure. Cette dernière travaille donc sur une variable locale.
Pour définir un passage de paramètre par valeur, il suffit d’ajouter le mot clé « byval » devant le nom du paramètre dans la déclaration de la procédure.
Dans l’exemple suivant, les 2 variables nom et enom font référence à des emplacements mémoires distincts.
Sub main()
Dim nom as string = ‘’toto’’
Afficher(nom)
End sub
Sub afficher(byval enom as string)
Msgbox(enom)
End sub
• Passage par référence
Dans le cas d’un passage par référence, ce n’est pas la valeur du paramètre qui est passé mais l’adresse de la variable contenant la valeur : dans ce cas, la procédure appelée et la procédure appelante travaille sur la même variable, même si le nom utilisé pour le paramètre est différent du nom de la variable initiale. De ce fait, il est possible de modifier le contenu de la variable passée en paramètre à partir de la procédure appelée.
Pour définir un passage de paramètre par valeur, il suffit d’ajouter le mot clé « byref » devant le nom du paramètre dans la déclaration de la procédure.
Sub main()
Dim nom as string = ‘’toto’’
Modifier(nom)
Msgbox(nom) ‘affiche titi
End sub
Sub modifier(byref enom as string)
Enom = ‘’titi’’
End sub
Visual basic .Net permet le passage d’un nombre quelconque de paramètre grâce au mot clé « ParamArray ». Il suffit de définir un paramètre de type tableau correspondant au type des paramètres qui devront être passé. Chaque élément du tableau correspond ensuite à un paramètre.
Sub nom_procedure(ParamArray tableau() as type_parametre)
|
Sub somme (ParamArray nombres() as integer) Dim nombre as integer Dim total as integer For each nombre in nombres Total += nombre Next Msgbox (total) End sub |
Pour la procédure somme, il sera donc possible d’effectuer les appels suivants :
Somme (12,2)
Somme(15,7,6,9,2,4)
Visual Basic comporte un ensemble de fonctions déjà intégrées permettant de réaliser les opérations de base sur les nombres, chaînes et dates. Ces fonctions peuvent apparaître sous deux formes :
- Fonction standards Vb
- Méthodes des classes de type (System.String, System.DateTime …)
De manière générale, il est préférable d’utiliser les méthodes liées aux type de variables dans le sens où elles sont accessibles par simple ajout du point après le nom de la variable (Liaison précoce).
Attention, l’appel des méthodes ne change pas la valeur de la variable mais retourne la valeur modifiée.
