Partager via

Instruction Dim (Visual Basic)

Déclare et alloue de l’espace de stockage pour une ou plusieurs variables.

Syntaxe

[ <attributelist> ] [ accessmodifier ] [[ Shared ] [ Shadows ] | [ Static ]] [ ReadOnly ]
Dim [ WithEvents ] variablelist

Pièces

  • attributelist

    Optionnel. Consultez la Liste des attributs.

  • accessmodifier

    Optionnel. Il peut s’agir de l’un des éléments suivants :

    Consultez Access levels in Visual Basic.

  • Shared

    Optionnel. Consultez Partagé.

  • Shadows

    Optionnel. Consultez Shadows.

  • Static

    Optionnel. Voir Statique.

  • ReadOnly

    Optionnel. Voir ReadOnly.

  • WithEvents

    Optionnel. Spécifie qu’il s’agit de variables d’objet qui font référence à des instances d’une classe qui peuvent déclencher des événements. Consultez WithEvents.

  • variablelist

    Obligatoire. Liste des variables déclarées dans cette instruction.

    variable [ , variable ... ]

    Chaque variable emploie la syntaxe et les éléments suivants :

    variablename [ ( [ boundslist ] ) ] [ As [ New ] datatype [ With{[ .propertyname = propinitializer [ , ... ] ] } ] ] [ = initializer ]

    Composant Descriptif
    variablename Obligatoire. Nom de la variable. Voir Noms d’éléments déclarés.
    boundslist Optionnel. Liste des limites de chaque dimension d’une variable de tableau.
    New Optionnel. Crée une instance de la classe lorsque l’instruction Dim s’exécute.
    datatype Optionnel. Type de données de la variable.
    With Optionnel. Introduit la liste d’initialiseurs d’objets.
    propertyname Optionnel. Nom d’une propriété dans la classe dont vous créez une instance.
    propinitializer Obligatoire après propertyname =. Expression évaluée et affectée au nom de la propriété.
    initializer Facultatif s’il New n’est pas spécifié. Expression évaluée et affectée à la variable lors de sa création.

Remarques

Le compilateur Visual Basic utilise l’instruction Dim pour déterminer le type de données de la variable et d’autres informations, telles que le code qui peut accéder à la variable. L’exemple suivant déclare une variable pour contenir une Integer valeur.

Dim numberOfStudents As Integer

Vous pouvez spécifier n’importe quel type de données ou le nom d’une énumération, d’une structure, d’une classe ou d’une interface.

Dim finished As Boolean
Dim monitorBox As System.Windows.Forms.Form

Pour un type de référence, vous utilisez le New mot clé pour créer une instance de la classe ou de la structure spécifiée par le type de données. Si vous utilisez New, vous n’utilisez pas d’expression d’initialiseur. Au lieu de cela, vous fournissez des arguments, s’ils sont requis, au constructeur de la classe à partir de laquelle vous créez la variable.

Dim bottomLabel As New System.Windows.Forms.Label

Vous pouvez déclarer une variable dans une procédure, un bloc, une classe, une structure ou un module. Vous ne pouvez pas déclarer une variable dans un fichier source, un espace de noms ou une interface. Pour plus d’informations, consultez Contextes de déclaration et niveaux d’accès par défaut.

Une variable déclarée au niveau du module, en dehors de toute procédure, est une variable membre ou un champ. Les variables membres sont dans l’étendue dans toute leur classe, structure ou module. Une variable déclarée au niveau de la procédure est une variable locale. Les variables locales sont dans l’étendue uniquement dans leur procédure ou leur bloc.

Les modificateurs d’accès suivants sont utilisés pour déclarer des variables en dehors d’une procédure : Public, , ProtectedFriend, Protected Friend, et Private. Pour plus d’informations, consultez Niveaux d’accès en Visual Basic.

Le Dim mot clé est facultatif et généralement omis si vous spécifiez l’un des modificateurs suivants : Public, , ProtectedFriend, Protected Friend, Private, Shared, , Shadows, StaticReadOnlyou WithEvents.

Public maximumAllowed As Double
Protected Friend currentUserName As String
Private salary As Decimal
Static runningTotal As Integer

Si Option Explicit elle est activée (valeur par défaut), le compilateur requiert une déclaration pour chaque variable que vous utilisez. Pour plus d’informations, consultez l’instruction Option Explicit.

Spécification d’une valeur initiale

Vous pouvez affecter une valeur à une variable lors de sa création. Pour un type valeur, vous utilisez un initialiseur pour fournir une expression à affecter à la variable. L’expression doit évaluer une constante qui peut être calculée au moment de la compilation.

Dim quantity As Integer = 10
Dim message As String = "Just started"

Si un initialiseur est spécifié et qu’un type de données n’est pas spécifié dans une As clause, l’inférence de type est utilisée pour déduire le type de données de l’initialiseur. Dans l’exemple suivant, les deux num1 et num2 sont fortement typés en tant qu’entiers. Dans la deuxième déclaration, l’inférence de type déduit le type de la valeur 3.

' Use explicit typing.
Dim num1 As Integer = 3

' Use local type inference.
Dim num2 = 3

L’inférence de type s’applique au niveau de la procédure. Elle ne s’applique pas en dehors d’une procédure dans une classe, une structure, un module ou une interface. Pour plus d’informations sur l’inférence de type, consultez l’instruction Option Infer et l’inférence de type local.

Pour plus d’informations sur ce qui se passe lorsqu’un type de données ou un initialiseur n’est pas spécifié, consultez Types de données et valeurs par défaut plus loin dans cette rubrique.

Vous pouvez utiliser un initialiseur d’objet pour déclarer des instances de types nommés et anonymes. Le code suivant crée une instance d’une Student classe et utilise un initialiseur d’objet pour initialiser les propriétés.

Dim student1 As New Student With {.First = "Michael",
                                  .Last = "Tucker"}

Pour plus d’informations sur les initialiseurs d’objets, consultez Guide pratique pour déclarer un objet à l’aide d’un initialiseur d’objet, d’initialiseurs d’objets : types nommés et anonymes et types anonymes.

Déclaration de plusieurs variables

Vous pouvez déclarer plusieurs variables dans une instruction de déclaration, en spécifiant le nom de la variable pour chacune d’elles et en suivant chaque nom de tableau entre parenthèses. Plusieurs variables sont séparées par des virgules.

Dim lastTime, nextTime, allTimes() As Date

Si vous déclarez plusieurs variables avec une As clause, vous ne pouvez pas fournir d’initialiseur pour ce groupe de variables.

Vous pouvez spécifier différents types de données pour différentes variables à l’aide d’une clause distincte As pour chaque variable que vous déclarez. Chaque variable prend le type de données spécifié dans la première As clause rencontrée après sa variablename partie.

Dim a, b, c As Single, x, y As Double, i As Integer
' a, b, and c are all Single; x and y are both Double

Tableaux

Vous pouvez déclarer une variable pour contenir un tableau, qui peut contenir plusieurs valeurs. Pour spécifier qu’une variable contient un tableau, suivez immédiatement ses variablename parenthèses. Pour plus d’informations sur les tableaux, consultez Tableaux.

Vous pouvez spécifier la limite inférieure et supérieure de chaque dimension d’un tableau. Pour ce faire, incluez un boundslist entre parenthèses. Pour chaque dimension, spécifie boundslist la limite supérieure et éventuellement la limite inférieure. La limite inférieure est toujours égale à zéro, que vous le spécifiez ou non. Chaque index peut varier de zéro à sa valeur limite supérieure.

Les deux instructions suivantes sont équivalentes. Chaque instruction déclare un tableau de 21 Integer éléments. Lorsque vous accédez au tableau, l’index peut varier de 0 à 20.

Dim totals(20) As Integer
Dim totals(0 To 20) As Integer

L’instruction suivante déclare un tableau à deux dimensions de type Double. Le tableau comporte 4 lignes (3 + 1) de 6 colonnes (5 + 1) chacune. Notez qu’une limite supérieure représente la valeur la plus élevée possible pour l’index, et non la longueur de la dimension. La longueur de la dimension est la limite supérieure plus une.

Dim matrix2(3, 5) As Double

Un tableau peut avoir entre 1 et 32 dimensions.

Vous pouvez laisser toutes les limites vides dans une déclaration de tableau. Si vous effectuez cette opération, le tableau a le nombre de dimensions que vous spécifiez, mais il n’est pas initialisé. Elle a une valeur jusqu’à Nothing ce que vous initialisiez au moins certains de ses éléments. L’instruction Dim doit spécifier des limites pour toutes les dimensions ou pour aucune dimension.

' Declare an array with blank array bounds.
Dim messages() As String
' Initialize the array.
ReDim messages(4)

Si le tableau a plusieurs dimensions, vous devez inclure des virgules entre les parenthèses pour indiquer le nombre de dimensions.

Dim oneDimension(), twoDimensions(,), threeDimensions(,,) As Byte

Vous pouvez déclarer un tableau de longueur nulle en déclarant l’une des dimensions du tableau à -1. Une variable qui contient un tableau de longueur nulle n’a pas la valeur Nothing. Les tableaux de longueur nulle sont requis par certaines fonctions common language runtime. Si vous essayez d’accéder à un tel tableau, une exception d’exécution se produit. Pour plus d’informations, consultez Tableaux.

Vous pouvez initialiser les valeurs d’un tableau à l’aide d’un littéral de tableau. Pour ce faire, entourez les valeurs d’initialisation avec des accolades ({}).

Dim longArray() As Long = {0, 1, 2, 3}

Pour les tableaux multidimensionnels, l’initialisation de chaque dimension distincte est placée entre accolades dans la dimension externe. Les éléments sont spécifiés dans l’ordre principal des lignes.

Dim twoDimensions(,) As Integer = {{0, 1, 2}, {10, 11, 12}}

Pour plus d’informations sur les littéraux de tableau, consultez Tableaux.

Types et valeurs de données par défaut

Le tableau suivant décrit les résultats de différentes combinaisons de spécification du type de données et de l’initialiseur dans une Dim instruction.

Type de données spécifié ? Initialiseur spécifié ? Exemple : Résultat
Non Non Dim qty Si Option Strict est désactivée (valeur par défaut), la variable est définie Nothingsur .

Si Option Strict elle est activée, une erreur au moment de la compilation se produit.
Non Oui Dim qty = 5 Si Option Infer est activée (valeur par défaut), la variable accepte le type de données de l’initialiseur. Consultez l’inférence de type local.

Si Option Infer elle est désactivée et Option Strict désactivée, la variable prend le type de données de Object.

Si Option Infer elle est désactivée et Option Strict est activée, une erreur au moment de la compilation se produit.
Oui Non Dim qty As Integer La variable est initialisée à la valeur par défaut pour le type de données. Consultez le tableau plus loin dans cette section.
Oui Oui Dim qty As Integer = 5 Si le type de données de l’initialiseur n’est pas convertible en type de données spécifié, une erreur au moment de la compilation se produit.

Si vous spécifiez un type de données mais que vous ne spécifiez pas d’initialiseur, Visual Basic initialise la variable à la valeur par défaut de son type de données. Le tableau suivant présente les valeurs d’initialisation par défaut.

Type de données Valeur par défaut
Tous les types numériques (y compris Byte et SByte) 0
Char Binaire 0
Tous les types de référence (y compris Object, et Stringtous les tableaux) Nothing
Boolean False
Date 12:00 du 1er janvier de l’année 1 (01/01/0001 12:00:00 AM)

Chaque élément d’une structure est initialisé comme s’il s’agissait d’une variable distincte. Si vous déclarez la longueur d’un tableau mais que vous n’initialisez pas ses éléments, chaque élément est initialisé comme s’il s’agissait d’une variable distincte.

Durée de vie des variables locales statiques

Une Static variable locale a une durée de vie plus longue que celle de la procédure dans laquelle elle est déclarée. Les limites de la durée de vie de la variable dépendent de l’endroit où la procédure est déclarée et si elle est Shared.

Déclaration de procédure Variable initialisée La variable arrête l’existant
Dans un module La première fois que la procédure est appelée Lorsque votre programme arrête l’exécution
Dans une classe ou une structure, la procédure est Shared La première fois que la procédure est appelée sur une instance spécifique ou sur la classe ou la structure elle-même Lorsque votre programme arrête l’exécution
Dans une classe ou une structure, la procédure n’est pas Shared La première fois que la procédure est appelée sur une instance spécifique Lorsque l’instance est libérée par le nettoyage de la mémoire (GC)

Attributs et modificateurs

Vous pouvez appliquer des attributs uniquement aux variables membres, et non aux variables locales. Un attribut contribue aux métadonnées de l’assembly, ce qui n’est pas significatif pour le stockage temporaire, comme les variables locales.

Au niveau du module, vous ne pouvez pas utiliser le Static modificateur pour déclarer des variables membres. Au niveau de la procédure, vous ne pouvez pas utiliser Shared, , ShadowsReadOnly, ou WithEventstout modificateur d’accès pour déclarer des variables locales.

Vous pouvez spécifier le code qui peut accéder à une variable en fournissant un accessmodifier. Les variables membres de classe et de module (en dehors de toute procédure) par défaut pour l’accès privé et les variables membres de structure sont par défaut accessibles au public. Vous pouvez ajuster leurs niveaux d’accès avec les modificateurs d’accès. Vous ne pouvez pas utiliser de modificateurs d’accès sur des variables locales (à l’intérieur d’une procédure).

Vous pouvez spécifier WithEvents uniquement sur les variables membres, et non sur les variables locales à l’intérieur d’une procédure. Si vous spécifiez WithEvents, le type de données de la variable doit être un type de classe spécifique, et non Object. Vous ne pouvez pas déclarer un tableau avec WithEvents. Pour plus d’informations sur les événements, consultez Événements.

Remarque

Le code en dehors d’une classe, d’une structure ou d’un module doit qualifier le nom d’une variable membre avec le nom de cette classe, structure ou module. Le code en dehors d’une procédure ou d’un bloc ne peut pas faire référence à des variables locales au sein de cette procédure ou de ce bloc.

Libération des ressources managées

Le garbage collector .NET Framework supprime les ressources managées sans code supplémentaire de votre part. Toutefois, vous pouvez forcer l’élimination d’une ressource managée au lieu d’attendre le garbage collector.

Si une classe conserve une ressource particulièrement précieuse et rare (telle qu’une connexion de base de données ou un handle de fichier), vous ne souhaiterez peut-être pas attendre que le garbage collection suivant nettoie une instance de classe qui n’est plus utilisée. Une classe peut implémenter l’interface IDisposable pour fournir un moyen de libérer des ressources avant un garbage collection. Une classe qui implémente cette interface expose une Dispose méthode qui peut être appelée pour forcer la libération immédiate des ressources précieuses.

L’instruction Using automatise le processus d’acquisition d’une ressource, l’exécution d’un ensemble d’instructions, puis la suppression de la ressource. Toutefois, la ressource doit implémenter l’interface IDisposable . Pour plus d’informations, consultez using, instruction.

Exemple 1

L’exemple suivant déclare des variables à l’aide de l’instruction Dim avec différentes options.

' Declare and initialize a Long variable.
Dim startingAmount As Long = 500

' Declare a local variable that always retains its value,
' even after its procedure returns to the calling code.
Static totalSales As Double

' Declare a variable that refers to an array.
Dim highTemperature(31) As Integer

' Declare and initialize an array variable that
' holds four Boolean check values.
Dim checkValues() As Boolean = {False, False, True, False}

Exemple 2

L’exemple suivant répertorie les nombres premiers compris entre 1 et 30. L’étendue des variables locales est décrite dans les commentaires de code.

Public Sub ListPrimes()
    ' The sb variable can be accessed only
    ' within the ListPrimes procedure.
    Dim sb As New System.Text.StringBuilder()

    ' The number variable can be accessed only
    ' within the For...Next block.  A different
    ' variable with the same name could be declared
    ' outside of the For...Next block.
    For number As Integer = 1 To 30
        If CheckIfPrime(number) = True Then
            sb.Append(number.ToString & " ")
        End If
    Next

    Debug.WriteLine(sb.ToString)
    ' Output: 2 3 5 7 11 13 17 19 23 29
End Sub

Private Function CheckIfPrime(ByVal number As Integer) As Boolean
    If number < 2 Then
        Return False
    Else
        ' The root and highCheck variables can be accessed
        ' only within the Else block.  Different variables
        ' with the same names could be declared outside of
        ' the Else block.
        Dim root As Double = Math.Sqrt(number)
        Dim highCheck As Integer = Convert.ToInt32(Math.Truncate(root))

        ' The div variable can be accessed only within
        ' the For...Next block.
        For div As Integer = 2 To highCheck
            If number Mod div = 0 Then
                Return False
            End If
        Next

        Return True
    End If
End Function

Exemple 3

Dans l’exemple suivant, la speedValue variable est déclarée au niveau de la classe. Le Private mot clé est utilisé pour déclarer la variable. La variable est accessible par n’importe quelle procédure de la Car classe.

' Create a new instance of a Car.
Dim theCar As New Car()
theCar.Accelerate(30)
theCar.Accelerate(20)
theCar.Accelerate(-5)

Debug.WriteLine(theCar.Speed.ToString)
' Output: 45

Public Class Car
    ' The speedValue variable can be accessed by
    ' any procedure in the Car class.
    Private speedValue As Integer = 0

    Public ReadOnly Property Speed() As Integer
        Get
            Return speedValue
        End Get
    End Property

    Public Sub Accelerate(ByVal speedIncrease As Integer)
        speedValue += speedIncrease
    End Sub
End Class

Voir aussi

  • Last updated on