Instruction Dim (Visual Basic)

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

Syntaxe

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

Éléments

• attributelist

  Optionnel. Consultez la Liste des attributs.

• accessmodifier

  Optionnel. Il peut s'agir d'une des méthodes suivantes :

  • Public

  • Protected

  • Friend

  • Privé

  • Ami protégé

  • Private Protected

  Consultez Access levels in Visual Basic.

• Shared

  Optionnel. Consultez Partagé.

• Shadows

  Optionnel. Consultez Shadows.

• Static

  Optionnel. Consultez Statique.

• ReadOnly

  Optionnel. Consultez ReadOnly.

• WithEvents

  Optionnel. Spécifie qu’il s’agit de variables objet qui font référence à des instances d’une classe pouvant 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 ]

  Élément	Description
  variablename	Obligatoire. Nom de la variable. Consultez Declared Element Names.
  boundslist	Optionnel. Liste des limites de chaque dimension d’une variable de tableau.
  New	Optionnel. Crée une instance de la classe lors de l’exécution de l’instruction Dim.
  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 pour laquelle vous créez une instance.
  propinitializer	Obligatoire après propertyname =. Expression évaluée et attribuée au nom de la propriété.
  initializer	Facultatif si New n’est pas spécifié. Expression évaluée et attribuée à la variable lors de sa création.

Notes

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

Dim numberOfStudents As Integer

Vous pouvez spécifier le type de données de votre choix 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 mot clé New 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 les arguments qui sont nécessaires 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 ni 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 de 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 au sein de leur procédure ou bloc.

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 en Visual Basic.

Le mot clé Dim est facultatif et généralement omis si vous spécifiez l’un des 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 nécessite une déclaration pour chaque variable utilisée. Pour plus d’informations, consultez Option Explicit, instruction.

Spécification d’une valeur initiale

Vous pouvez attribuer une valeur à une variable lors de sa création. Pour un type valeur, vous utilisez un initialiseur afin fournir une expression à attribuer à la variable. L’expression doit être évaluée à 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 clause As, l’inférence de type est utilisée pour déduire le type de données à partir de l’initialiseur. Dans l’exemple suivant, 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 à partir 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 de classe, de structure, de module ni d’interface. Pour plus d’informations sur l’inférence de type, consultez Instruction Option Infer et Inférence de type de variable locale.

Pour plus d’informations sur le comportement quand un type de données ou un initialiseur n’est pas spécifié, consultez Types de données et valeurs par défaut ultérieurement 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 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, 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 chacune d’elles et en suivant chaque nom de tableau avec les 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 clause As, 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 As distincte 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 la partie 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 contenir un tableau pouvant contenir plusieurs valeurs. Pour spécifier qu’une variable contient un tableau, faites suivre variablename immédiatement de 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 cela, incluez boundslist entre les parenthèses. Pour chaque dimension, boundslist spécifie la limite supérieure et éventuellement la limite inférieure. La limite inférieure est toujours égale à zéro, que la valeur soit spécifiée ou non. Chaque index peut varier de la valeur zéro à la limite supérieure.

Les deux instructions suivantes sont équivalentes. Chaque instruction déclare un tableau de 21 éléments Integer. Quand vous accédez au tableau, l’index peut varier de la valeur 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 correspond à 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 avoir entre 1 et 32 dimensions.

Vous pouvez laisser toutes les limites vides dans une déclaration de tableau. Si vous procédez ainsi, le tableau a 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 certains éléments. L’instruction Dim doit spécifier des limites soit pour toutes les dimensions, soit pour aucune dimension.

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

Si le tableau comporte 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 comme étant -1. Une variable qui contient un tableau de longueur zéro n’a pas la valeur Nothing. Des 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 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 cela, entourez les valeurs d’initialisation d’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 row-major.

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

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

Types de données et valeurs par défaut

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

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

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 variable locale Static a une durée de vie plus longue que 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’emplacement où la procédure est déclarée et de la définition de Shared.

Attributs et modificateurs

Vous pouvez appliquer des attributs uniquement aux variables membres, pas aux variables locales. Un attribut fournit des informations sur les 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 modificateur Static pour déclarer des variables membres. Au niveau de la procédure, vous ne pouvez pas utiliser Shared, Shadows, ReadOnly, WithEvents ni des modificateurs 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) sont définies par défaut sur l’accès privé, et les variables membres de structure sont définies par défaut sur l’accès 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 des variables membres, pas sur des 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.

Libération des ressources managées

Le récupérateur de mémoire (garbage collector, GC) .NET Framework supprime les ressources managées sans codage supplémentaire de votre part. Toutefois, vous pouvez forcer la suppression d’une ressource managée au lieu d’attendre le récupérateur de mémoire.

Si une classe contient une ressource particulièrement précieuse et rare (comme une connexion de base de données ou un handle de fichier), vous ne souhaitez peut-être pas patienter jusqu’à ce que le récupérateur de mémoire suivant nettoie une classe instance 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 nettoyage de la mémoire. Une classe qui implémente cette interface expose une méthode Dispose pouvant ê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, d’exécution d’un ensemble d’instructions, puis de 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 variable speedValue est déclarée au niveau de la classe. Le mot clé Private est utilisé pour déclarer la variable. La variable est accessible par toute procédure de 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

• Const (instruction)
• ReDim (instruction)
• Option Explicit (instruction)
• Instruction Option Infer
• Option Strict Statement
• Page Compiler, Concepteur de projets (Visual Basic)
• Déclaration de variable
• Tableaux
• Initialiseurs d'objets : types nommés et anonymes
• Types anonymes
• Initialiseurs d'objets : types nommés et anonymes
• Comment : déclarer un objet à l'aide d'un initialiseur d'objet
• Inférence de type local