Instructions dans Visual Basic

Article
06/19/2023

Une instruction en Visual Basic est une instruction complète. Elle peut contenir des mots clés, des opérateurs, des variables, des constantes et des expressions. Chaque instruction appartient à l’une des catégories suivantes :

Instructions de déclaration, qui nomment une variable, une constante ou une procédure, et peuvent également spécifier un type de données.
Instructions exécutables, qui lancent des actions. Ces instructions peuvent appeler une méthode ou une fonction, et elles peuvent effectuer une boucle ou une branche via des blocs de code. Les instructions exécutables incluent les instructions d’assignement, qui attribuent une valeur ou une expression à une variable ou une constante.

Cette rubrique décrit chaque catégorie. Cette rubrique explique également comment combiner plusieurs instructions sur une seule ligne et comment continuer une instruction sur plusieurs lignes.

Instructions de déclaration

Les instructions de déclaration servent à nommer et définir des procédures, des variables, des propriétés, des tableaux et des constantes. Lorsque vous déclarez un élément de programmation, vous pouvez également définir son type de données, son niveau d’accès et son étendue. Pour plus d’informations, consultez Caractéristiques d’élément déclarées.

L’exemple suivant contient trois déclarations.

Public Sub ApplyFormat()
    Const limit As Integer = 33
    Dim thisWidget As New widget
    ' Insert code to implement the procedure.
End Sub

La première déclaration est l’instruction Sub. Avec son instruction correspondante, l’instruction End Sub déclare une procédure nommée applyFormat. Elle spécifie également que applyFormat est Public, ce qui signifie que n’importe quel code pouvant faire référence à celle-ci peut l’appeler.

La deuxième déclaration est l’instruction Const, qui déclare la constante limit, en spécifiant le type de données Integer et la valeur 33.

La troisième déclaration est l’instruction Dim, qui déclare la variable thisWidget. Le type de données est un objet spécifique, à savoir un objet créé à partir de la classeWidget. Vous pouvez déclarer une variable de n'importe quel type de données élémentaires ou de n'importe quel type d'objet exposé dans l'application que vous utilisez.

valeurs initiales

Lorsque le code contenant une instruction de déclaration s’exécute, Visual Basic réserve la mémoire requise pour l’élément déclaré. Si l’élément contient une valeur, Visual Basic l’initialise à la valeur par défaut de son type de données. Pour plus d’informations, consultez « Comportement » dans Instruction Dim.

Vous pouvez affecter une valeur initiale à une variable dans le cadre de sa déclaration, comme l’illustre l’exemple suivant.

Dim m As Integer = 45
' The preceding declaration creates m and assigns the value 45 to it.

Si une variable est une variable objet, vous pouvez créer explicitement une instance de sa classe lorsque vous la déclarez à l’aide du mot clé New Operator, comme l’illustre l’exemple suivant.

Dim f As New FileInfo("filename")

Notez que la valeur initiale que vous spécifiez dans une instruction de déclaration n’est pas affectée à une variable tant que l’exécution n’atteint pas son instruction de déclaration. Jusqu’à ce stade, la variable contient la valeur par défaut de son type de données.

Instructions exécutables

Une instruction exécutable effectue une action. Elle peut appeler une procédure, passer à un autre endroit du code, boucler plusieurs instructions ou évaluer une expression. Une instruction d’affectation est un cas particulier d’une instruction exécutable.

L’exemple suivant utilise une If...Then...Else structure de contrôle pour exécuter différents blocs de code en fonction de la valeur d’une variable. Dans chaque bloc de code, une boucle For...Next s’exécute un nombre de fois déterminé.

Public Sub StartWidget(ByVal aWidget As widget,
    ByVal clockwise As Boolean, ByVal revolutions As Integer)
    Dim counter As Integer
    If clockwise = True Then
        For counter = 1 To revolutions
            aWidget.SpinClockwise()
        Next counter
    Else
        For counter = 1 To revolutions
            aWidget.SpinCounterClockwise()
        Next counter
    End If
End Sub

L’instruction If de l’exemple précédent vérifie la valeur du paramètre clockwise. Si la valeur est True, elle appelle la méthode spinClockwise de aWidget. Si la valeur est False, elle appelle la méthode spinCounterClockwise de aWidget. La structure de contrôle If...Then...Else se termine par End If.

Dans chaque bloc, la boucle For...Next appelle la méthode appropriée plusieurs fois égale à la valeur du paramètre revolutions.

Instructions d’assignation

Les instructions d’affectation effectuent des opérations d’affectation, qui consistent à prendre la valeur sur le côté droit de l’opérateur d’affectation (=) et à la stocker dans l’élément à gauche, comme le montre l’exemple suivant.

v = 42

Dans l’exemple précédent, l’instruction d’affectation stocke la valeur littérale 42 dans la variable v.

Éléments de programmation disponibles

L’élément de programmation situé à gauche de l’opérateur d’affectation doit être en mesure d’accepter et de stocker une valeur. Cela signifie qu’il doit s’agir d’une variable ou d’une propriété qui n’est pas ReadOnly, ou qu’elle doit être un élément de tableau. Dans le contexte d’une instruction d’affectation, un tel élément est parfois appelé lvalue, pour « valeur gauche ».

La valeur à droite de l’opérateur d’affectation est générée par une expression, qui peut se composer de n’importe quelle combinaison de littéraux, de constantes, de variables, de propriétés, d’éléments de tableau, d’autres expressions ou d’appels de fonction. L'exemple suivant illustre ce comportement.

x = y + z + FindResult(3)

L’exemple précédent ajoute la valeur détenue dans la variable y à la valeur détenue dans la variable z, puis ajoute la valeur retournée par l’appel à la fonction findResult. La valeur totale de cette expression est ensuite stockée dans la variable x.

Types de données dans les instructions d’affectation

En plus des valeurs numériques, l’opérateur d’affectation peut également affecter des Stringvaleurs, comme l’illustre l’exemple suivant.

Dim a, b As String
a = "String variable assignment"
b = "Con" & "cat" & "enation"
' The preceding statement assigns the value "Concatenation" to b.

Vous pouvez également affecter des Booleanvaleurs, à l’aide d’un Booleanlittéral ou d’une Booleanexpression, comme l’illustre l’exemple suivant.

Dim r, s, t As Boolean
r = True
s = 45 > 1003
t = 45 > 1003 Or 45 > 17
' The preceding statements assign False to s and True to t.

De même, vous pouvez affecter des valeurs appropriées aux éléments de programmation du type de données Char, Date ou Object. Vous pouvez également affecter une instance d’objet à un élément déclaré comme étant de la classe à partir de laquelle cette instance est créée.

Instructions d'assignation composée

Les Instructions d'assignation composée effectuent d’abord une opération sur une expression avant de l’affecter à un élément de programmation. L’exemple suivant illustre l’un de ces opérateurs, +=, qui incrémente la valeur de la variable sur le côté gauche de l’opérateur par la valeur de l’expression à droite.

n += 1

L’exemple précédent ajoute 1 à la valeur de n, puis stocke cette nouvelle valeur dans n. Il s’agit d’un équivalent abrégé de l’instruction suivante :

n = n + 1

Diverses opérations d’affectation composée peuvent être effectuées à l’aide d’opérateurs de ce type. Pour obtenir la liste de ces opérateurs et avoir plus d’informations sur ces derniers, consultez Opérateurs d’assignation.

L’opérateur d’assignation de concaténation (&=) est utile pour ajouter une chaîne à la fin de celles déjà existantes, comme l’illustre l’exemple suivant.

Dim q As String = "Sample "
q &= "String"
' q now contains "Sample String".

Conversions de types dans les instructions d’assignation

La valeur que vous affectez à une variable, une propriété ou un élément de tableau doit être d’un type de données approprié à cet élément de destination. En général, vous devez essayer de générer une valeur du même type de données que celle de l’élément de destination. Toutefois, pendant l’affectation, certains types peuvent être convertis en d’autres.

Pour plus d’informations sur la conversion entre les différents types de données, consultez Conversions de types dans Visual Basic. En bref, Visual Basic convertit automatiquement une valeur d’un type donné en tout autre type auquel il s’étend. Une conversion étendue est une conversion qui réussit toujours au moment de l’exécution, sans jamais perdre de données. Par exemple, Visual Basic peut convertir une valeur Integer en Double, car Integer s’étend en Double. Pour plus d’informations, consultez Widening and Narrowing Conversions.

Les conversions restrictives (celles qui ne s’étendent pas) présentent un risque de défaillance au moment de l’exécution ou de perte de données. Vous pouvez explicitement effectuer une conversion restrictive à l’aide d’une fonction de conversion de type, ou vous pouvez implicitement diriger le compilateur afin d’effectuer toutes les conversions, en définissant Option Strict Off. Pour plus d’informations, consultez Conversions implicites et explicites.

Mise en place de plusieurs instructions sur une ligne

Vous pouvez avoir plusieurs instructions sur une seule ligne séparée par le caractère deux-points (:). L'exemple suivant illustre ce comportement.

Dim sampleString As String = "Hello World" : MsgBox(sampleString)

Bien qu’elle soit parfois pratique, cette forme de syntaxe rend votre code plus difficile à lire et à gérer. Par conséquent, il est recommandé de conserver une instruction sur une seule ligne.

Poursuite d’une instruction sur plusieurs lignes

Une instruction s’adapte généralement à une ligne, mais quand elle est trop longue, vous pouvez la poursuivre sur la ligne suivante à l’aide d’une séquence de continuation de ligne, qui se compose d’un espace suivi d’un trait de soulignement (_) suivi d’un retour chariot. Dans l’exemple suivant, l’instruction exécutable MsgBox se poursuit sur deux lignes.

Public Sub DemoBox()
    Dim nameVar As String
    nameVar = "John"
    MsgBox("Hello " & nameVar _
        & ". How are you?")
End Sub

Continuation de ligne implicite

Dans de nombreux cas, vous pouvez continuer une instruction sur la ligne suivante sans utiliser le caractère de soulignement (_). Les éléments de syntaxe suivants continuent l’instruction sur la ligne de code suivante de manière implicite.

Après une virgule (,). Par exemple :

Public Function GetUsername(ByVal username As String,
                            ByVal delimiter As Char,
                            ByVal position As Integer) As String

    Return username.Split(delimiter)(position)
End Function

Après une parenthèse ouvrante (() ou avant une parenthèse fermante ()). Par exemple :

Dim username = GetUsername(
    Security.Principal.WindowsIdentity.GetCurrent().Name,
    CChar("\"),
    1
  )

Après une accolade ouvrante ({) ou avant une accolade fermante (}). Par exemple :
```
Dim customer = New Customer With {
  .Name = "Terry Adams",
  .Company = "Adventure Works",
  .Email = "terry@www.adventure-works.com"
}
```
Pour plus d’informations, consultez Initialiseurs d’objet : Types nommés et anonymes ou Initialiseurs de collection.

Après une expression d’incorporation d’ouverture (<%=) ou de fermeture (%>) dans un XML littéral. Par exemple :

Dim customerXml = <Customer>
                      <Name>
                          <%=
                              customer.Name
                          %>
                      </Name>
                      <Email>
                          <%=
                              customer.Email
                          %>
                      </Email>
                  </Customer>

Pour plus d’informations, consultez Expressions incorporées dans XML.

Après l’opérateur de concaténation (&). Par exemple :

cmd.CommandText = 
    "SELECT * FROM Titles JOIN Publishers " &
    "ON Publishers.PubId = Titles.PubID " &
    "WHERE Publishers.State = 'CA'"

Pour plus d’informations, consultez Opérateurs listés par fonctionnalité.

Après les opérateurs d’affectation (=, &=, :=, +=, -=, *=, /=, \=, ^=, <<=, >>=). Par exemple :
```
Dim fileStream =
  My.Computer.FileSystem.
    OpenTextFileReader(filePath)
```
Pour plus d’informations, consultez Opérateurs listés par fonctionnalité.
Après les opérateurs binaires (+, -, /, *, Mod, <>, <, >, <=, >=, ^, >>, <<, And, AndAlso, Or, OrElse, Like, Xor) dans une expression. Par exemple :
```
Dim memoryInUse =
  My.Computer.Info.TotalPhysicalMemory +
  My.Computer.Info.TotalVirtualMemory -
  My.Computer.Info.AvailablePhysicalMemory -
  My.Computer.Info.AvailableVirtualMemory
```
Pour plus d’informations, consultez Opérateurs listés par fonctionnalité.
Après les opérateurs Is et IsNot. Par exemple :
```
If TypeOf inStream Is 
  IO.FileStream AndAlso
  inStream IsNot
  Nothing Then

    ReadFile(inStream)

End If
```
Pour plus d’informations, consultez Opérateurs listés par fonctionnalité.
Après un caractère de qualificateur de membre (.) et avant le nom du membre. Par exemple :
```
Dim fileStream =
  My.Computer.FileSystem.
    OpenTextFileReader(filePath)
```
Toutefois, vous devez inclure un caractère de continuation de ligne (_) après un caractère de qualificateur de membre lorsque vous utilisez l’instruction With ou fournissez des valeurs dans la liste d’initialisation pour un type. Envisagez de rompre la ligne après l’opérateur d’affectation (par exemple =) lorsque vous utilisez des instructions With ou des listes d’initialisation d’objets. Par exemple :
```
' Not allowed:
' Dim aType = New With { .
'    PropertyName = "Value"

' Allowed:
Dim aType = New With {.PropertyName =
    "Value"}



Dim log As New EventLog()

' Not allowed:
' With log
'    .
'      Source = "Application"
' End With

' Allowed:
With log
    .Source =
      "Application"
End With
```
Pour plus d’informations, consultez Instruction With... End With ou Initialiseurs d’objet : types nommés et anonymes.
Après un qualificateur de propriété d’axe XML (., .@ ou ...). Toutefois, quand vous spécifiez un qualificateur de membre, vous devez inclure un caractère de continuation de ligne (_) lorsque vous utilisez le mot-clé With. Par exemple :
```
Dim customerName = customerXml.
  <Name>.Value

Dim customerEmail = customerXml...
  <Email>.Value
```
Pour plus d'informations, consultez Propriétés XML Child Axis.
Après un signe inférieur à (<) ou avant un signe supérieur à (>) lorsque vous spécifiez un attribut. Également après un signe supérieur à (>), lorsque vous spécifiez un attribut. Toutefois, vous devez inclure un caractère de fin de ligne (_) lorsque vous spécifiez des attributs au niveau de l'assemblage ou du module. Par exemple :
```
<
Serializable()
>
Public Class Customer
    Public Property Name As String
    Public Property Company As String
    Public Property Email As String
End Class
```
Pour plus d'informations, voir Aperçu des attributs.
Avant et après les opérateurs de requête (Aggregate, Distinct, From, Group By, Group Join, Join, Let, Order By, Select, Skip, Skip While, Take, Take While, Where, In, Into, On, Ascending, et Descending). Vous ne pouvez pas rompre une ligne entre les mots-clés des opérateurs de requête constitués de plusieurs mots-clés (Order By, Group Join, Take Whileet Skip While). Par exemple :
```
Dim vsProcesses = From proc In
                    Process.GetProcesses
                  Where proc.MainWindowTitle.Contains("Visual Studio")
                  Select proc.ProcessName, proc.Id,
                         proc.MainWindowTitle
```
Pour plus d’informations, consultez Requêtes.

Après le In mot clé dans une For Each instruction. Par exemple :

For Each p In
  vsProcesses

    Console.WriteLine("{0}" & vbTab & "{1}" & vbTab & "{2}",
      p.ProcessName,
      p.Id,
      p.MainWindowTitle)
Next

Pour plus d’informations, consultez Instruction For Each....

Après le From mot clé dans un initialiseur de collection. Par exemple :
```
Dim days = New List(Of String) From
  {
   "Mo", "Tu", "We", "Th", "F", "Sa", "Su"
  }
```
Pour plus d’informations, consultez Initialiseurs de collection.

Ajout de commentaires

Le code source n’est pas toujours explicite, même pour le programmeur qui l’a écrit. Pour documenter leur code, par conséquent, la plupart des programmeurs utilisent librement les commentaires incorporés. Les commentaires dans un code peuvent expliquer une procédure ou une instruction particulière à toute personne lisant ou travaillant ultérieurement avec ce dernier. Lors de la compilation, Visual Basic ignore les commentaires et n’affecte pas le code compilé.

Les lignes de commentaire commencent par une apostrophe (') ou REM suivies d’un espace. Elles peuvent être ajoutées n’importe où dans le code, sauf dans une chaîne. Pour ajouter un commentaire à une instruction, insérez une apostrophe ou REM après l’instruction, suivie du commentaire. Les commentaires peuvent également aller sur leur propre ligne distincte. L’exemple suivant illustre ces possibilités.

' This is a comment on a separate code line.
REM This is another comment on a separate code line.
x += a(i) * b(i) ' Add this amount to total.
MsgBox(statusMessage) REM Inform operator of status.

Vérification des erreurs de compilation

Si, après avoir tapé une ligne de code, la ligne s’affiche avec un trait de soulignement bleu ondulé (un message d’erreur peut également apparaître), c’est qu’il y a une erreur de syntaxe dans l’instruction. Vous devez trouver quel est le problème avec l’instruction (en regardant dans la liste des tâches ou en pointant sur l’erreur avec le pointeur de la souris et en lisant le message d’erreur) et le corriger. Tant que vous n’avez pas résolu toutes les erreurs de syntaxe dans votre code, votre programme ne sera pas compilé correctement.

Terme	Définition
Opérateurs d’assignation	Fournit des liens vers des pages de référence de langue couvrant les opérateurs d’affectation tels que `=`, `*=`et `&=`.
Opérateurs et expressions	Montre comment combiner des éléments avec des opérateurs pour générer de nouvelles valeurs.
Procédure : Diviser et combiner des instructions dans le code	Montre comment diviser une instruction unique en plusieurs lignes et comment placer plusieurs instructions sur la même ligne.
Procédure : Étiqueter des instructions	Montre comment étiqueter une ligne de code.

Partager via

Instructions dans Visual Basic

Instructions de déclaration

valeurs initiales

Instructions exécutables

Instructions d’assignation

Éléments de programmation disponibles

Types de données dans les instructions d’affectation

Instructions d'assignation composée

Conversions de types dans les instructions d’assignation

Mise en place de plusieurs instructions sur une ligne

Poursuite d’une instruction sur plusieurs lignes

Continuation de ligne implicite

Ajout de commentaires

Vérification des erreurs de compilation

Ressources supplémentaires

Partager via

Instructions dans Visual Basic

Instructions de déclaration

valeurs initiales

Instructions exécutables

Instructions d’assignation

Éléments de programmation disponibles

Types de données dans les instructions d’affectation

Instructions d'assignation composée

Conversions de types dans les instructions d’assignation

Mise en place de plusieurs instructions sur une ligne

Poursuite d’une instruction sur plusieurs lignes

Continuation de ligne implicite

Ajout de commentaires

Vérification des erreurs de compilation

Sections connexes

Ressources supplémentaires