Cours de Visual Basic.Net

1. Présentation

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.

1.1 Historique

1.2 Nouveautés

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.

1.3 Installation

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 :

Ces spécifications concernent l’utilisation du FrameWork .Net ainsi que de l’IDE, pas l’exécution des programmes MSIL.

2. Environnement Visual Studio

2.1 L’interface

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

2.2 Fenêtres d’exploration

2.2.1 Explorateur de serveur

 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.

2.2.2 Explorateur de Solutions

 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

2.2.3 L’affichage de classes

 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.

2.2.4 Fenêtre de propriétés

 Déjà présente dans la version 6.0, cette fenêtre recense toutes les propriétés relatives à l’objet selectionné.

2.2.5 L’aide dynamique

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.

2.2.6 La liste des tâches

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

  -  

3. Gestion de projets

3.1 Les solutions

Une solution le plus haut conteneur logique d’éléments (projets, fichiers, feuilles, classes). Une solution peut contenir plusieurs projets.

3.2 Création d’un projet

Il est possible de créer un projet soit directement dans une solution ouverte soit dans une nouvelle solution.

• Menu Fichier > Nouveau > Projet

3.3 Configuration d’un projet

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.

4. Bases du langage

4.1 Structure du code

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.

4.1.1 Formulaire

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 ».

4.1.2 Module

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 »

4.1.3 Les commentaires

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

4.1.4 Les régions

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

4.2 Les variables

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

4.2.1 Types de variables

4.2.1.1 Types numériques

4.2.1.2 Types chaîne de caractère

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.

4.2.1.3 Autres types

... ... ...

4.2.2 Déclaration de variables

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

4.2.3 Portée et visibilité des variables

4.2.3.1 Portée des variables

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 ».

4.2.3.1 Visibilité des variables

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

4.2.4 Les tableaux

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)

4.2.5 Les constantes

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’’

4.2.6 Les énumérations

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 :

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.

4.3 Les opérateurs

il existe 5 types d’opérateurs

4.3.1 Opérateur d’affectation

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

4.3.2 Opérateurs Arithmétiques

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

4.3.3 Opérateurs de comparaison

Il permettent de comparer deux membres et, en fonction du résultat, retournent True ou False

... ... ...

4.3.4 Opérateurs de concaténation

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.

... ... ...

4.3.5 Opérateurs logiques

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.

... ... ...

4.4 Les structures de contrôle

Les structures de contrôle permettent de modifier le nombre d’exécution d’une instruction.

4.4.1 Les conditions

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.

4.4.2 Structures conditionnelles

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.

4.4.2.1 Structure If

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

4.4.2.2 Structure Select Case

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

4.4.2.3 Instruction conditionnelles

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’’)

4.4.3 Structures répétitives

Les structures répétitives ou structures de boule permettent d’exécuter un bloc d’instructions un certain nombre de fois.

4.4.3.1 Structure While

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

4.4.3.2 Structure Do loop

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

4.4.3.4 Structure For each

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

4.5 Procédures et fonctions

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)

4.5.1 Création de procédure

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 !!!

4.5.1.1 Déclaration

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

4.5.1.2 Appel

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)

4.5.2 Création de fonction

Les fonction sont des procédures retournant un résultat. 

4.5.2.1 Déclaration

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.

4.5.2.1 Appel

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))

4.5.3 Passage de paramètres

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.

4.5.3.1 Déclaration

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

4.5.3.2 Appel

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’’)

4.5.3.3 Passage par valeur et par référence

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

4.5.3.4 Passer un nombre quelconque de paramètre

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)

Pour la procédure somme, il sera donc possible d’effectuer les appels suivants :

Somme (12,2)

Somme(15,7,6,9,2,4)

4.6 Fonctions intégrées

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.