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
Terme |
Définition |
||||||||||||||||||
attributelist |
Optionnel. Consultez Liste d'attributs. |
||||||||||||||||||
accessmodifier |
Optionnel. Il peut s'agir de l'une des valeurs suivantes : 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 ]
|
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).
Notes
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)
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)
Initialiseurs d'objets : types nommés et anonymes (Visual Basic)
Inférence de type local (Visual Basic)