Dim, instruction (Visual Basic)

Article
04/10/2013

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

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

Composants

Terme	Définition
attributelist	Optionnel.Consultez Liste d'attributs.
accessmodifier	Optionnel.Il peut s'agir de l'une des valeurs suivantes : Public Protégé Friend Privé Protected Friend Consultez Niveaux d'accès dans Visual Basic.
Shared	Optionnel.Consultez Shared.
Shadows	Optionnel.Consultez Shadows.
Static	Optionnel.Consultez Static.
ReadOnly	Optionnel.Consultez ReadOnly.
WithEvents	Optionnel.Spécifie qu'il s'agit de variables objets qui font référence aux instances d'une classe qui peut déclencher des événements.Consultez WithEvents.
variablelist	Requis.Liste des variables qui sont déclarées dans cette instruction. variable [ , variable ... ] Chaque variable emploie la syntaxe et les paramètres suivants : variablename [ ( [ boundslist ] ) ] [ As [ New ] datatype [ With { [ .propertyname = propinitializer [ , ... ] ] } ] ] [ = initializer ] ÉlémentDescription variablename Requis.Nom de la variable.Consultez Noms d'éléments déclarés (Visual Basic). boundslist Optionnel.Liste des limites de chaque dimension d'une variable 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.Présente la liste d'initialiseurs d'objets. propertyname Optionnel.Nom d'une propriété dans la classe dont vous faites une instance. propinitializer Requis après propertyname =.Expression évaluée et assignée au nom de la propriété. initializer Facultatif si New n'est pas spécifié.Expression évaluée et assigné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, 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.

Type de données spécifié ?	Initialiseur spécifié ?	Exemple	Résultat
Non	Non	Dim qty	Si Option Strict est désactivé (valeur par défaut), la variable est définie à Nothing. Si Option Strict est activée, une erreur de compilation se produit.
Non	Oui	Dim qty = 5	Si L'option déduisent est activé (valeur par défaut), la variable accepte le type de données de l'initialiseur.Consultez Inférence de type local (Visual Basic). Si Option Infer et Option Strict sont désactivés, la variable prend le type de données de Object. Si Option Infer est désactivé et Option Strict est activé, une erreur de compilation se produit.
Oui	Non	Dim qty As Integer	La variable est initialisée avec la valeur par défaut du 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 de compilation se produit.

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.

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 référence (y compris Object, String et tous les tableaux)	Nothing
Boolean	False
Date	1er janvier (0 heure) de l'an 1 pour (01/01/0001 12:00:00 AM).

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.

Déclaration de procédure	Variable initialisée	La variable n'existe plus.
Dans un module	Au premier appel de la procédure	Lorsque votre programme arrête l'exécution
Dans une classe ou une structure, la procédure est Shared	Au premier appel de la procédure 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	Au premier appel de la procédure sur une instance spécifique	Lorsque l'instance est libérée pour le garbage collection (GC)

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