Dim, instruction (Visual Basic)

Article
09/12/2008

Mise à jour : novembre 2007

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

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

Éléments

attributelist
Facultatif. Consultez Liste d'attributs.
accessmodifier
Facultatif. Il peut s'agir de l'une des valeurs suivantes :
- Public
- Protégé
- Friend
- Private
- Protected Friend
Consultez Niveaux d'accès dans Visual Basic.
Shared
Facultatif. Consultez Shared.
Shadows
Facultatif. Consultez Shadows.
Static
Facultatif. Consultez Static.
ReadOnly
Facultatif. Consultez ReadOnly.
WithEvents
Facultatif. 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
Obligatoire. Liste des variables qui sont 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 Noms d'éléments déclarés.
boundslist	Facultatif. Liste des limites de chaque dimension d'une variable de tableau.
New	Facultatif. Crée une instance de la classe lorsque l'instruction Dim s'exécute.
datatype	Requis si Option Strict a la valeur On. Type de données de la variable.
With	Facultatif. Présente la liste d'initialiseurs d'objets.
propertyname	Facultatif. 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

Vous devez déclarer chaque variable que vous utilisez dans votre programme pour spécifier au compilateur Visual Basic le type de données de la variable et d'autres informations telles que le code qui peut y accéder. L'exemple suivant déclare une variable pour qu'elle contienne une valeur Integer.

Dim numberOfStudents As Integer

Vous pouvez utiliser Dim uniquement au niveau du module ou de la procédure. Cela signifie que le contexte de déclaration pour une variable doit être une classe, une structure, un module, une procédure ou un bloc et ne peut pas être 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.

Si Option Explicit est On (la valeur par défaut), le compilateur requiert une déclaration pour chaque variable que vous utilisez. Si vous Option Explicit Off, la valeur par défaut de chaque variable non déclarée est Object, type de données, ce qui n'est peut-être pas votre intention.

Vous pouvez spécifier le type de données de chaque variable dans l'instruction Dim. Vous pouvez également spécifier une valeur initiale. Sinon, Visual Basic utilise les paramètres par défaut. Pour plus d'informations, consultez « Règles relatives aux types de données » et « Valeurs par défaut » sous « Informations détaillées » dans cette page d'aide. L'exemple suivant déclare et initialise une variable String.

Dim summary As String = "Summary of results"

Vous pouvez spécifier le code qui peut accéder à une variable en fournissant un accessmodifier dans l'instruction Dim. Pour plus d'informations, consultez des « Modificateurs » et« Niveau d'accès » sous « Informations détaillées » dans cette page d'aide.

Vous pouvez déclarer une variable pour qu'elle contienne un tableau, lequel peut contenir plusieurs valeurs. Pour plus d'informations, consultez « Règles de tableau » sous « Informations détaillées » dans cette page d'aide. Pour plus d'informations sur les tableaux, consultez Tableaux dans Visual Basic. L'exemple suivant déclare une variable de tableau Integer.

Dim days() As Integer

En général, vous devez placer toutes vos instructions Dim au début de la région de code dans laquelle vous utilisez les variables. Pour plus d'informations, consultez « Dépannage » sous « Informations détaillées » dans cette page d'aide.

Visual Basic 2008 introduit des initialiseurs d'objets utilisés pour déclarer des instances de types nommés et anonymes, ainsi qu'une inférence de type local. Pour plus d'informations, consultez les rubriques Types anonymes, Initialiseurs d'objets : types nommés et anonymes et Inférence de type local.

Informations détaillées

Cette section aborde en détail les zones suivantes :

Déclaration
Types de données
Tableaux
Comportement
Dépannage

Règles de déclaration

Contexte de déclaration. Une variable déclarée au niveau du module, à l'extérieur de toute procédure, est une variable membre ou champ ; elle est membre de la classe, de la structure ou du module qui la déclare.

Une variable déclarée au niveau de la procédure est une variable locale ; elle est locale par rapport à la procédure ou au bloc qui la déclare.
Attributs. 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.
Utilisation implicite de Dim. Si vous spécifiez l'un des modificateurs Public, Protected, Friend, Protected Friend, Private, Shared, Shadows, Static, ReadOnly ou WithEvents, vous pouvez éventuellement omettre le mot clé Dim.
```
Public maximumAllowed As Double
Protected Friend currentUserName As String
Private salary As Decimal
Static runningTotal As Integer
```
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.
Variables WithEvents. 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 des variables 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 et gestionnaires d'événements.
Variables multiples. Vous pouvez déclarer de nombreuses variables dans la même instruction de déclaration, en spécifiant l'élément variablename pour 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
```

Règles relatives aux types de données

Types de données. L'instruction Dim peut déclarer le type de données d'une variable. 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
```
Type par défaut. Si vous ne spécifiez pas datatype, la variable prend le type de données de initializer. Si ni l'élément datatype ni l'élément initializer n'est présent, le type de données a la valeur Object, type de données par défaut. Si vous spécifiez datatype et initializer, le type de données de initializer doit pouvoir être converti en datatype.
Types divers. 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. Vous pouvez également déclarer plusieurs variables pour qu'elles soient du même type à l'aide d'une clause As commune. 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
```
Initialisation. L'instruction Dim peut initialiser le contenu de variables sélectionnées dans variablelist. Pour un type valeur, vous utilisez initializer 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"
```
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 datatype. Si vous utilisez New, vous n'utilisez pas d'expression initializer. 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
```
Si vous déclarez plusieurs variables avec la même clause As, vous ne pouvez pas spécifier un initializer pour ce groupe de variables.

Règles de tableau

Variables de tableau. Pour spécifier qu'une variable de variablelist est un tableau, vous faites suivre immédiatement son variablename de parenthèses. 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
```
Un tableau peut contenir entre 1et 32 dimensions.

Pour plus d'informations, consultez Tableaux dans Visual Basic.
Limites de tableau. Vous pouvez spécifier la limite inférieure et supérieure de chaque dimension. Pour ce faire, vous 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.
```
Dim matrix2(3, 5) As Double
```
Notez qu'une limite supérieure représente la valeur la plus élevée possible pour cet index et non la longueur de cette dimension qui est la limite supérieure plus un.
Limites de tableaux vides. 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 donc la valeur de 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.
```
Dim messages() As String
```
Tableaux vides. Il est possible d'utiliser la valeur -1 pour déclarer la limite supérieure d'une dimension d'un tableau. En d'autres termes, le tableau est vide mais sa valeur n'est pas Nothing. Cette distinction est requise par certaines fonctions du Common Language Runtime. Toutefois, le code Visual Basic n'est pas en mesure d'accéder à un tel tableau. Si vous tentez de procéder ainsi, une erreur IndexOutOfRangeException se produit pendant l'exécution. Pour plus d'informations, consultez Comment : créer un tableau sans éléments.
Initialisation des tableaux. Vous pouvez initialiser les valeurs d'un tableau en mettant 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}}
```

Comportement

Valeurs par défaut. Si vous ne spécifiez pas initializer pour une variable, Visual Basic initialise celle-ci à 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.

**Niveau d'accès.**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).
Portée. Les variables locales sont dans la portée de leur procédure ou bloc uniquement. Les variables membres sont dans la portée dans l'ensemble de leur classe, structure ou module.
Qualification. 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.

Durée de vie. 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 cesse d'exister
Dans un module	Au premier appel de la procédure	Lorsque votre programme arrête l'exécution
Dans une classe ou structure, 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 structure, non 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)

Dépannage

Ordre d'exécution. L'instruction Dim n'est pas elle-même une instruction exécutable. Toutefois, si elle initialise une ou plusieurs variables, les initialisations sont traitées comme des instructions d'assignation. Cela signifie que la valeur d'une variable passe par les étapes suivantes :
1. Sur la première entrée dans l'élément de code déclarant la variable, Visual Basic l'initialise à la valeur par défaut pour son type de données.
2. Lorsque l'exécution arrive à l'instruction Dim de la variable, Visual Basic l'initialise à la valeur fournie dans l'instruction Dim.
3. Chaque fois que l'exécution retourne à l'instruction Dim de la variable, Visual Basic lui affecte une nouvelle fois la valeur fournie dans l'instruction Dim.
Les conséquences sont les suivantes lorsque vous utilisez une instruction Dim pour initialiser une variable :
- si vous utilisez la variable avant d'exécuter l'instruction Dim, sa valeur est la valeur par défaut de son type de données et non la valeur fournie dans l'instruction Dim ;
- si l'exécution n'atteint jamais l'instruction Dim, la variable n'est jamais initialisée à la valeur fournie dans l'instruction Dim ;
- si vous modifiez la valeur et que vous retournez en revanche à l'instruction Dim, votre valeur modifiée est remplacée par la valeur fournie dans l'instruction Dim ;
si vous placez toutes vos instructions Dim au début de la région de code dans laquelle elles apparaissent, par exemple un module ou une procédure, votre code les initialise comme prévu.

Exemple

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

' The following statement declares and initializes a Long variable.
Dim startingAmount As Long = 500

' The following statement declares a variable that refers to a Button 
' object, creates a new Button object, and assigns it to the variable.
Dim switchButton As New System.Windows.Forms.Button

' The following statement declares a variable that can only be 
' accessed by code in the same class, structure, or module.
Private homeTelephone As String = ""

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

' The following statement declares a variable that refers to an array.
Dim highTemperature(31) As Integer

' The following statement declares and initializes an array variable 
' that holds 4 Boolean check values.
Dim checkValues() As Boolean = {False, False, True, False}

Voir aussi

Partager via