Visual Basic .NET
Définition
Domaine, Discipline, Thématique
Justification
Définition écrite
Visual Basic .NET est un langage de programmation événementielle. Il est le successeur de Visual Basic 6.0. Il se compile et s’exécute sur l'architecture .NET(le framework .NET): les scripts VB 6.0 ne seront pas compilé en VB .NET. La première version fait ses débuts en 2002 (VB 7.0, Microsoft Visual Studio 2002, Framework .NET 1.0) et la dernière version en 2019 (VB 16.0, Microsoft Visual Studio 2019, Framework .NET 4.8). Visual Basic .NET permet le développement rapide d'applications Windows, de services web, de pages Web, l'accès aux bases de données…
|
Visual Basic .NET - Historique (+)
Définition graphique
Logo VB .NET
Interface VB .NET
Code VB .NET
{{{AutresMedias}}}
Concepts ou notions associés
Visual Basic .NET - Glossaire / (+)
Exemples, applications, utilisations
Les éléments de base de VB.Net
Comme toute langage de programmation, Visual Basic .NET permet de décrire des structures des données . Il offre un ensemble de notions telles que les variables, les constantes, les tableaux, les structures de contrôles et les procédures et les fonctions, qui peuvent être utilisées comme primitives pour développer des programmes.
Variable et constante
Notion de Variable
Les variables sont nécessaires pour stocker une valeur dynamique et réutilisable. C'est en fait une simple zone mémoire qui porte un nom choisi par le programmeur. Le nom de la variable est une adresse mémoire. Il faut déclarer chaque variable en précisant le type de celle-ci. La déclaration se fait avec le mot réservé Dim.
Syntaxe:
Dim <NomVariable> As <Type>
Pour la lisibilité du code on peut les commenter après une apostrophe ('). En ce qui concerne les noms des variables, on peut utiliser des majuscules, minuscules et chiffres. Les espaces et autres caractères spéciaux ne sont pas acceptés (accents, @, #). Le nom de la variable ne peut pas commencer par un chiffre.
Exemples:
Dim Ma_Variable As String Dim Nombre As Integer
Vous pouvez affecter des valeurs aux variables une fois qu’elles sont déclarées, comme montré dans l’exemple suivant :
Dim birthday As Date birthday = #3/9/1974# Dim birthday As Date = #3/9/1974# Dim goodNews As String = "Votre chèque est au courrier." Dim testCondition As Boolean = True
Vous pouvez déclarer des variables public, comme montré dans l’exemple suivant :
Public Ma_Variable As String
Lorsque vous créez une variable à l’aide de l’instruction Dim, Visual Basic initialise automatiquement les variables numériques sur 0, les chaînes de texte sur vide ("") et les variables de type date sur Janvier 1, 0001.
Les différents types de variables
Le langage VB utilise plusieurs types de données dont les plus utilisés sont le type String (chaîne de caractères), le type Integer (entier) et le type Single (décimal). Les types standards de données en VB sont résumés ci-dessous:
|
Type de variable |
Mémoire occupée |
Plage Utilisation principale |
|
Boolean |
2 octets |
Pour les conditions |
|
Byte
|
1 octet |
Pour les fichiers |
|
Char |
2 octets |
Pour les caractères |
|
Date |
8 octets |
Pour les dates |
|
Decimal
|
16 octets |
Pour les nombres décimaux |
|
Integer |
4 octets |
Pour les nombres entiers |
|
Long |
8 octets |
Pour les entiers longs |
|
Short |
2 octets |
Pour les entiers courts |
|
Single |
4 octets |
Pour les grands nombres à virgules (avec simple précision) |
|
String |
Variable |
Pour les chaînes de caractères |
Déclaration des constantes
Pour déclarer une constante, utilisez l’instruction Const avec la syntaxe suivante :
Syntaxe:
Const NomConstant As Type
Exemple:
Dim surface, rayon, périmètre As Double Const Pi As Double = 3.1415 surface = Pi * rayon ^ 2 périmètre = 2 * Pi * rayon
Les tableaux
Un tableau est une séquence d’éléments de données appartenant à un même type. Vous pouvez accéder aux éléments individuels d’un tableau en utilisant le nom du tableau et un ou plusieurs index (commençant à 0) pour spécifier la position de l’élément dans le tableau. Un tableau peut présenter une ou plusieurs dimensions avec un ou plusieurs éléments dans chaque dimension.
Déclaration d’un tableau unidimensionnel
Vous déclarez un tableau en spécifiant les éléments suivants :
- Nom du tableau
- Taille (nombre d’éléments)
- Type de données des éléments du tableau
- Modificateur d’accès (si nécessaire)
Syntaxe:
ModificateurAccès NomTableau(N) As <Type>
Cette instruction déclare un tableau NomTableau de taille N+1. Pour accéder au i ème élément du tableau, il faut préciser l’indice entre parenthèses comme suit : NomTableau(i-1), i doit être compris dans l’intervalle [0, N].
Vous pouvez déclarer des tableaux locaux au moyen de l’instruction Dim et en intégrant la déclaration à l’intérieur d’une procédure. Pour créer un tableau public, utilisez le mot clé Public à la place de Dim.
Exemples de déclarations d’un tableau local:
Sub initialisation( )
'Allouer 31 éléments (0) à (30)
Dim Tab(30) As Decimal
Dim number As Integer
For number = 0 to 30
Tab(number) = 100
Next number
End Sub
Exemples de déclarations d’un tableau public:
Public entiers(14) As Integer
Public réels(20) As Double
Public entiers( ) As Integer = {1, 2, 3, 4, 5, 6, 7}
Public Grille ( , ) As Integer ={{1,2},{3,4}}
Déclaration de tableaux multidimensionnels
Pour déclarer une variable de tableau multidimensionnel, ajoutez une paire de parenthèses après le nom de la variable et utilisez des virgules à l’intérieur pour séparer les dimensions.
Exemple:
Dim 2DArray(3,2) As Double 2DArray(2,1) = 23 2DArray(2,2) = 17
Dans Visual Basic .NET, vous pouvez redimensionner un tableau à tout moment en lui spécifiant une nouvelle grandeur. Vous pouvez même changer le nombre de dimensions du tableau.
Syntaxe:
ReDim tableauExistant ( NouvelleGrandeur )
Structures de contrôle
Structures conditionnelles
Forme simple
Syntaxe:
If condition(s) Then
Instruction(s)
Else
Instruction(s)
End IF
Exemple:
If Moyenne >= 12 Then
Admis = Admis + 1
Console.WriteLine (" Candidat admis ")
Else
Ajournes = Ajournes + 1
Console.WriteLine (" Candidat ajourné ")
End If
on peut utiliser IIF
Syntaxe:
IIf (Condition, ValeurSiVrai, ValeurSiFaux)
Exemple:
Dim Note As Single
Dim Reponse As String
Console.Write(" Tapez votre note: ")
Note = Console.Read()
Reponse = IIf(Note >= 10, " Admis ", " Ajourné ")
Console.WriteLine(Reponse)
Forme imbriqué
Syntaxe:
If condition(s) Then
Instruction(s)
If condition Then
Instruction(s)
Else If condition Then
Instruction(s)
Else condition Then
Instruction(s)
End IF
Else
Instruction(s)
End IF
Exemple:
If NombrePropose > NombreATrouver Then
Console.WriteLine("Votre nombre est trop grand !")
ElseIf NombrePropose < NombreATrouver Then
Console.WriteLine("Votre nombre est trop petit !")
Else
Console.WriteLine("Gagné !")
End If
Structure à choix
Syntaxe:
Select Case expression Case Liste_Valeurs_1
Instruction(s)
Case Liste_Valeurs_2
Instruction(s)
Case Else
Instruction(s)
End Select
Exemple:
Select Case CodeASCIICaractère
Case 65, 69, 73, 79, 85
Console.WriteLine(" C’est une voyelle ")
Case 66 To 90
Console.WriteLine(" C’est une consonne ")
Case Else
Console.WriteLine(" Ce n’est pas une lettre ")
End Select
Structures itératives
Les instructions répétitives sont utilisées pour boucler sur une suite d’instructions.
Structure complète
Si le nombre de boucles est connu à l’avance, on utilise l'instruction For … To … Next.
Syntaxe:
For Compteur = Début To Fin [Step Incrément]
Instruction(s)
[ ... Exit For] 'pour une interruption préalable de la boucle
[Instruction(s)]
Next [Compteur] 'le mot Compteur est facultatif
Exemple:
Dim i As Integer
For i = 1 To 12
Console.WriteLine(i * 2)
Next i 'le i n’est pas obligatoire
On peut utiliser For … Each … Next. C'est une extension de la boucle For … To … Next.
Syntaxe:
For Each Elément In Ensemble
Instruction(s)
[ ... Exit For]
[Instruction(s)]
Next [Elément]
Exemple:
Dim numbers() As Integer = {1, 4, 7}
Dim letters() As String = {"a", "b", "c"}
For Each number As Integer In numbers
For Each letter As String In letters
Console.Write(number.ToString & letter & " ")
Next
Next
Structure à condition d'arrêt
Test antérieur
La condition est ici testée au début, c'est-à-dire à l’entrée de la boucle. Avec Do while … Loop, la boucle est répétée tant que la condition est vraie. Si la condition n’est pas vraie au départ, les instructions de la boucle ne sont pas exécutées.
Syntaxe:
Do While Condition
Instruction(s)
[... Exit Do]
[Instruction(s)]
Loop
Exemple:
Do While MotPropose <> MotDePasse
MotPropose = InputBox("Donnez votre mot de passe")
Loop
De même avec Do Until … Loop
Syntaxe:
Do Until Condition
Instruction(s)
[... Exit Do]
[Instruction(s)]
Loop
Exemple:
Do Until MotPropose = MotDePasse
MotPropose = InputBox("Donnez votre mot de passe")
Loop
Test postérieur
La condition est ici testée à la fin de la boucle. Avec Do … Loop While, la boucle est répétée tant que la condition est vraie. Les instructions de la boucle sont donc exécutées au moins une fois.
Syntaxe:
Do
Instruction(s)
[... Exit Do]
[Instruction(s)]
Loop While Condition
Exemple:
Do
MotPropose = InputBox("Donnez votre mot de passe")
Loop While MotPropose <> MotDePasse
De même avec Do … Loop Until
Syntaxe:
Do
Instruction(s)
[... Exit Do]
[Instruction(s)]
Loop Until Condition
Exemple:
Do
MotPropose = InputBox("Donnez votre mot de passe")
Loop Until MotPropose = MotDePasse
Procédure et fonction
Les procédures
VB.NET permet l’utilisation des procédures et des fonctions avec ou sans paramètres. Rappelez-vous que la grande différence entre la procédure et la fonction est que cette dernière retourne une valeur lorsqu’elle est appelée.
Transmission par valeur : ByVal
Pour transmettre un paramètre par valeur, celui-ci doit être obligatoirement précédé par le mot réservé ByVal. Dans ce cas si la procédure appelée modifie la valeur de la variable d'origine, la valeur initiale de la variable ne change pas. Lorsque l'exécution revient à la procédure appelante, la variable contient la valeur qu'elle avait avant la transmission de la valeur.
Syntaxe:
Private Sub NomProcédure( ByVal argument As Type, … )
Instruction(s)
End Sub
Exemple:
Private Sub Permutation(ByVal valeur1 As Integer, ByVal valeur2 As Integer)
Dim variable As Integer
variable = valeur1
valeur1 = valeur2
valeur2 = variable
End Sub
L’appel de la procédure se fait soit en inscrivant Call suivi du nom de la procédure, et des paramètres à lui transmettre, soit en écrivant uniquement le nom de la procédure, suivi des paramètres à lui transmettre.
Exemple:
Dim X, Y As Integer
X = InputBox("Donnez 1er entier: ")
Y = InputBox("Donnez 2ème entier: ")
Console.WriteLine("Avant permutation X = " & X & " et Y = " & Y )
Call Affectation(X, Y) ' avec les parenthèses
Console.WriteLine("Après permutation X = " & X & " et Y = " & Y )
Transmission par référence : ByRef
Si le paramètre est précédé par le mot réservé ByRef, la variable est transmise par référence (c à d a travers l’adresse des données en mémoire). Ainsi, toute modification de la variable locale correspondante dans la procédure se reflète sur la variable utilisée lors de l’appel.
Dans l'exemple précédant on remplace ByVal par ByRef
Les fonctions
Lors de la déclaration d'une fonction, la valeur qui doit être retournée par celle-ci doit être affectée au nom de la fonction. La déclaration de la fonction se termine par les mots réservés End function.
Syntaxe:
Private function NomFonction( Argument As Type, … ) As Type
Instruction(s)
NomFonction = RésultatDeLaFonction ‘ou bien return RésultatDeLaFonction
End function
Exemple:
Private function Somme( valeur1 As Integer, valeur2 As Integer ) As integer Somme = Valeur1 + valeur2 End function
L’appel suivant retourne la somme de X et Y et affecte le résultat à la variable Z.
Exemple:
Dim X, Y, Z As Integer X = 10 Y = 20 Z = Somme(X, Y)
Orienté objet Visual Basic .Net
Classe et objet
Un objet est une entité qui contient des données qui définissent son état (on les appelle des propriétés) et des fonctions (on les appelle des méthodes). Un objet est créé selon un modèle qu'on appelle une classe. donc on les appellera des objets ou des instances de classes.
Exemple de classe:
Public Class personne
' attributs
Private prenom As String
Private nom As String
Private age As Integer
' méthode
Public Sub initialise(ByVal P As String, ByVal N As String, ByVal age As Integer)
Me.prenom = P
Me.nom = N
Me.age = age
End Sub
' méthode
Public Sub identifie()
Console.WriteLine ((prenom & "," & nom & "," & age))
End Sub
End Class
Pour que p1 référence un objet de la classe personne, il faut écrire :
Dim p1 as personne=new personne()
Cela a pour effet de créer un objet de type personne non encore initialisé : les attributs nom et prenom qui sont des références d'objets de type String auront la valeur nothing, et age la valeur 0. Il y a donc une initialisation par défaut. Maintenant que p1 référence un objet, l'instruction d'initialisation de cet objet suivante est valide :
p1.initialise("Tounsi","Ali",22)
Constructeur et destructeur
Un constructeur est une procédure qui porte le nom New et qui est appelée lors de la création de l'objet. On s'en sert généralement pour l'initialiser.
Exemple :
Public Class personne
' attributs
Private prenom As String
Private nom As String
Private age As Integer
' constructeurs
Public Sub New(ByVal P As [String], ByVal N As [String], ByVal age As Integer)
initialise(P, N, age)
End Sub
Public Sub New(ByVal P As personne)
initialise(P)
End Sub
' méthodes d'initialisation de l'objet
Public Sub initialise(ByVal P As String, ByVal N As String, ByVal age As Integer)
Me.prenom = P
Me.nom = N
Me.age = age
End Sub
Public Sub initialise(ByVal P As personne)
prenom = P.prenom
nom = P.nom
Me.age = P.age
End Sub
' méthode
Public Sub identifie()
Console.WriteLine((prenom & "," & nom & "," & age))
End Sub
End Class
Voici un court programme de test :
Sub Main()
Dim p1 As New personne("Tounsi", "Rania", 30)
Console.Writeline("p1=")
p1.identifie()
Dim p2 As New personne(p1)
Console.WriteLine("p2=")
p2.identifie()
End Sub
les résultats obtenus :
p1=tounsi,Rania,30 p2=tounsi,Rania,30
Un destructeur est une procédure qui est automatiquement exécutée à la mort de l'objet. Une telle procédure se nomme Finalize().
Protected Overrides Sub Finalize( ) 'Peut fermer des connexions ou d’autres ressources conn.Close End Sub
Encapsulation
L'encapsulation est un concept important de la Programmation Orientée Objet. Il permet de rassembler des données(attributs) et des traitements(méthodes) dans une seule entité (classe) et interdit d'agir directement sur les données d'un objet sauf à l'aide des méthodes. En général, les attributs d'une classe sont déclarées privées alors que ses méthodes sont déclarées publiques.
Programmation évènementielle Visual Basic .Net
Erreurs ou confusions éventuelles
- Confusion entre VB et VB .NET
- Confusion entre IDE et Framework
- Confusion entre procédure et fonction
- Confusion entre transmission par valeur et transmission par référence
- Erreur fréquente: mal utilisation de la portée des objets
- Erreur fréquente: chois de la structure conditionnelle adéquate
- Erreur fréquente: chois de la structure itérative adéquate
Questions possibles
Liaisons enseignements et programmes
Idées ou Réflexions liées à son enseignement
Aides et astuces
- ..................
- .................
- ..................
- .................
Education: Autres liens, sites ou portails
- ..................
- ..................
- ..................
Bibliographie
Pour citer cette page: (Basic .NET)
ABROUGUI, M & al, 2020. Visual Basic .NET. In Didaquest [en ligne]. <http:www.didaquest.org/wiki/Visual_Basic_.NET>, consulté le 24, novembre, 2024
- « Visual Basic ». In Wikipédia, 20 avril 2020. https://fr.wikipedia.org/w/index.php?title=Visual_Basic&oldid=169803403.
- « Programmation Visual Basic .NET/Introduction — Wikilivres ». Consulté le 21 avril 2020. https://fr.wikibooks.org/wiki/Programmation_Visual_Basic_.NET/Introduction.
- cours-gratuit.com. « [PDF] Tutoriel avancé du langage Visual Basic .NET
