Partager via

Déclarations en Visual Basic

Une instruction en Visual Basic est une instruction complète. Il peut contenir des mots clés, des opérateurs, des variables, des constantes et des expressions. Chaque déclaration 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 boucler ou rediriger à travers des blocs de code. Les instructions exécutables incluent les instructions Assignment, 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

Vous utilisez des instructions de déclaration pour 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 End Sub , elle déclare une procédure nommée applyFormat. Il spécifie également que applyFormat c’est Public, ce qui signifie que n’importe quel code qui peut faire référence à celui-ci peut l’appeler.

La deuxième déclaration est l’instruction Const , qui déclare la constante limit, en spécifiant le Integer type de données 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 Widget classe. Vous pouvez déclarer une variable à être de n’importe quel type de données élémentaire ou d’un 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 Dim Statement.

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. Il peut appeler une procédure, se brancher vers un autre emplacement dans le code, parcourir 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 For...Next boucle exécute un nombre spécifié de fois.

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 spinClockwise méthode de aWidget. Si la valeur est False, elle appelle la spinCounterClockwise méthode de aWidget. La structure de If...Then...Else contrôle se termine par End If.

La For...Next boucle dans chaque bloc appelle la méthode appropriée un nombre de fois égal à la valeur du paramètre revolutions.

Instructions d'affectation

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 dans 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 éligibles

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

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 String des valeurs, 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 Boolean valeurs, à l’aide d’un Boolean littéral ou d’une Boolean expression, 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 de 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’affectation composée

Les instructions d’affectation 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 plus d’informations sur ces opérateurs, consultez Opérateurs d’affectation.

L’opérateur d’affectation de concaténation (&=) est utile pour ajouter une chaîne à la fin des chaînes 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 déclarations d’affectation

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, certains types peuvent être convertis en d’autres types pendant l’affectation.

Pour plus d’informations sur la conversion entre les types de données, consultez Conversions de types en 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 et ne perd pas de données. Par exemple, Visual Basic convertit une valeur Integer en Double en cas de besoin, 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 effectuer une conversion restrictive explicitement à l’aide d’une fonction de conversion de type, ou vous pouvez diriger le compilateur pour effectuer toutes les conversions implicitement en définissant Option Strict Off. Pour plus d’informations, consultez Conversions implicites et explicites.

Mettre 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 cela.

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

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

Poursuite d’une déclaration 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, d’un trait de soulignement (_), et d’un retour chariot. Dans l’exemple suivant, l’instruction MsgBox exécutable 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 consécutive suivante sans utiliser le caractère de soulignement (_). Les éléments de syntaxe suivants continuent implicitement l’instruction sur la ligne de code suivante.

  • 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 ouverte (() ou avant une parenthèse fermante ()). Par exemple:

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

  • Après une accolade ouverte ({) 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 incorporée ouverte (<%=) ou avant la fermeture d’une expression incorporée (%>) dans un littéral XML. 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 With des instructions 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 l'instruction With... End With ou les initialiseurs d'objet : types nommés et anonymes.

  • Après un qualificateur de propriété d’axe XML (., .@ ou ...). Toutefois, vous devez inclure un caractère de continuation de ligne (_) lorsque vous spécifiez un qualificateur de membre lorsque vous utilisez le With mot clé. Par exemple:

    Dim customerName = customerXml.
  <Name>.Value

Dim customerEmail = customerXml...
  <Email>.Value

    Pour plus d’informations, consultez Propriétés de l’axe XML.

  • Après un signe inférieur à (<) ou avant un signe supérieur à (>) lorsque vous spécifiez un attribut. Ensuite, après un signe supérieur à (>) lorsque vous spécifiez un attribut. Toutefois, vous devez inclure un caractère de continuation de ligne (_) lorsque vous spécifiez des attributs au niveau de l’assembly ou au niveau 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, consultez Vue d’ensemble des attributs.

  • Opérateurs de requête avant et après (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...Next.

  • 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 le code peuvent expliquer une procédure ou une instruction particulière à toute personne lisant ou travaillant avec elle ultérieurement. Visual Basic ignore les commentaires lors de la compilation et n’affecte pas le code compilé.

Les lignes de commentaire commencent par une apostrophe (') ou REM suivies d’un espace. Ils peuvent être ajoutés 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 une 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), il existe une erreur de syntaxe dans l’instruction. Vous devez savoir ce qui se passe mal 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 corrigez-la. 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’affectation 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.
Guide pratique pour interrompre 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.
Guide pratique : étiqueter des instructions Montre comment étiqueter une ligne de code.