Dim, instruction (Visual Basic)

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

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

Composants

Notes

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 pouvant accéder à la variable.L'exemple suivant déclare une variable pour qu'elle contienne une valeur Integer.

Dim numberOfStudents As Integer

Vous pouvez spécifier un 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 référence, vous utilisez le mot clé New pour créer une instance de la classe ou structure spécifiée par le type de données.Si vous utilisez New, vous n'utilisez pas d'expression d'initialiseur.Vous fournissez plutôt des arguments, si nécessaire, au constructeur de la classe dans 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 (Visual Basic).

Une variable déclarée au niveau du module, à l'extérieur de toute procédure, est une variable membre ou un champ.Les variables membres sont dans la portée dans l'ensemble de leur classe, structure ou module.Une variable locale est une variable déclarée au niveau de la procédure.Les variables locales sont dans la portée de leur procédure ou bloc uniquement.

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

Le mot clé Dim est facultatif et généralement omis si vous spécifiez les modificateurs suivants : Public, Protected, Friend, Protected Friend, Private, Shared, Shadows, Static, ReadOnly ou WithEvents.

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

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

Spécification d'une valeur initiale

Vous pouvez assigner une valeur à une variable lorsqu'elle est créée.Pour un type valeur, vous utilisez un initialiseur pour fournir une expression à assigner à la variable.L'expression doit avoir pour valeur une constante qui peut être calculée à la compilation.

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

Si un initialiseur est spécifié et un type de données n'est pas spécifié dans une clause As, l'inférence de type est utilisée pour déduire le type de données de l'initialiseur.Dans l'exemple suivant, num1 et num2 sont fortement typés comme 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 à l'extérieur 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 Instruction Option Infer et Inférence de type local (Visual Basic).

Pour plus d'informations sur ce qui se passe quand un type de données ou un initialiseur n'est pas spécifié, consultez Valeurs et types de données 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 classe Student et utilise un initialiseur d'objet pour initialiser des propriétés.

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

Pour plus d'informations sur les initialiseurs d'objets, consultez Comment : déclarer un objet à l'aide d'un initialiseur d'objet (Visual Basic), Initialiseurs d'objets : types nommés et anonymes (Visual Basic) et Types anonymes (Visual Basic).

Déclaration de variables multiples

Vous pouvez déclarer de nombreuses variables dans la même instruction de déclaration, en spécifiant le nom de chacune d'elle et en faisant suivre chaque nom de tableau de parenthèses.Les variables multiples sont séparées par des virgules.

Dim lastTime, nextTime, allTimes() As Date

Si vous déclarez plusieurs variables avec une seule et même clause As, vous ne pouvez pas spécifier un 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 As séparée pour chaque variable que vous déclarez.Chaque variable prend le type de données spécifié dans la première clause As rencontrée après son élément variablename.

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 qu'elle contienne un tableau, lequel peut contenir plusieurs valeurs.Pour spécifier qu'une variable contient un tableau, faites suivre immédiatement son variablename de parenthèses.Pour plus d'informations sur les tableaux, consultez Tableaux dans Visual Basic.

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

Les deux instructions suivantes sont équivalentes.Chaque instruction déclare un tableau de 21 éléments Integer.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 a 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 correspond à la limite supérieure plus un.

Dim matrix2(3, 5) As Double

Un tableau peut contenir entre 1et 32 dimensions.

Vous pouvez laisser toutes les limites vides dans une déclaration de tableau.Si vous procédez ainsi, le tableau porte le nombre de dimensions que vous spécifiez, mais il n'est pas initialisé.Il a la valeur Nothing, jusqu'à ce que vous initialisiez au moins quelques-uns de ses éléments.L'instruction Dim doit spécifier des limites pour toutes les dimensions ou pour aucune d'entre elles.

' 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 zéro en déclarant l'une des dimensions du tableau à -1.Une variable contenant un tableau de longueur zéro n'a pas la valeur Nothing.Les tableaux de longueur zéro sont requis par certaines fonctions du Common Language Runtime.Si vous essayez d'accéder à ce type de tableau, une exception runtime se produit.Pour plus d’informations, consultez Tableaux dans Visual Basic.

Vous pouvez initialiser les valeurs d'un tableau à l'aide d'un littéral de tableau.Pour ce faire, mettez les valeurs d'initialisation entre accolades ({}).

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

Pour les tableaux multidimensionnels, l'initialisation de chaque dimension séparée est entourée d'accolades dans la dimension externe.Les éléments sont spécifiés dans l'ordre ligne-champ.

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

Pour plus d'informations sur les littéraux de tableaux, consultez Tableaux dans Visual Basic.

Valeurs et types de données par défaut

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

Si vous spécifiez un type de données mais pas d'initialiseur, Visual Basic initialise la variable à la valeur par défaut pour ce type de données.Le tableau suivant indique les valeurs d'initialisation par défaut.

Chaque élément d'une structure est initialisé comme s'il s'agissait d'une variable séparée.Si vous déclarez la longueur d'un tableau sans initialiser ses éléments, chaque élément est initialisé comme s'il s'agissait d'une variable distincte.

Durée de vie de la variable locale statique

Une variable locale Static 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ù est déclarée la procédure et si celle-ci est de type Shared.

Attributs et modificateurs

Vous ne pouvez appliquer des attributs qu'aux variables membres et non aux variables locales.Un attribut fournit des informations aux métadonnées de l'assembly, ce qui n'a pas de sens pour le stockage temporaire tel que les variables locales.

Au niveau du module, vous ne pouvez pas utiliser le modificateur Static pour déclarer des variables membres.Au niveau de la procédure, vous ne pouvez pas utiliser Shared, Shadows, ReadOnly, WithEvents ni aucun autre 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 ou de module (en dehors de toute procédure) prennent par défaut l'accès privé, tandis que les variables membres de structure prennent par défaut l'accès public.Vous pouvez régler leurs niveaux d'accès avec les modificateurs d'accès.Vous ne pouvez pas utiliser de modificateurs d'accès sur les 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 (Visual Basic).

[!REMARQUE]

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

Libération des ressources managées

Le garbage collector du .NET Framework possède des ressources managées sans codage supplémentaire de votre part.Toutefois, vous pouvez forcer la disposition d'une ressource managée au lieu d'attendre que le garbage collector.

Si les conserve d'une classe sur une ressource particulièrement précieuse et rare (telle qu'une connexion de base de données ou un handle de fichier), vous ne pas souhaiter attendre le garbage collection pour nettoyer une instance de classe qui n'est plus utilisé.Une classe peut implémenter l'interface d' IDisposable pour fournir une méthode pour libérer des ressources avant un garbage collection.Une classe qui implémente des de cette interface expose une méthode d' Dispose qui peut être appelée pour forcer les précieuses ressources à libérer immédiatement.

L'instruction d' Using automatiser le processus d'acquérir une ressource, d'exécuter un jeu d'instructions, puis d'avoir une ressource.Toutefois, la ressource doit implémenter l'interface d' IDisposable .Pour plus d’informations, consultez Using, instruction (Visual Basic).

Exemple

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

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

' Declare a variable that refers to a Button object,
' create a Button object, and assign the Button object
' to the variable.
Dim switchButton As New System.Windows.Forms.Button

' 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}

L'exemple suivant répertorie les nombres premiers entre 1 et 30.La portée 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

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

' 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

Tâches

Comment : déclarer un objet à l'aide d'un initialiseur d'objet (Visual Basic)

Référence

Const, instruction (Visual Basic)

ReDim, instruction (Visual Basic)

Option Explicit, instruction (Visual Basic)

Instruction Option Infer

Option Strict, instruction

Page Compiler, Concepteur de projets (Visual Basic)

Concepts

Déclaration de variable en Visual Basic

Initialiseurs d'objets : types nommés et anonymes (Visual Basic)

Types anonymes (Visual Basic)

Initialiseurs d'objets : types nommés et anonymes (Visual Basic)

Inférence de type local (Visual Basic)

Autres ressources

Tableaux dans Visual Basic