Enum, instruction (Visual Basic)

Déclare une énumération et définit les valeurs de ses membres.

Syntaxe

[ <attributelist> ] [ accessmodifier ]  [ Shadows ]
Enum enumerationname [ As datatype ]
   memberlist
End Enum

Éléments

• attributelist

  Optionnel. Liste des attributs qui s’appliquent à cette énumération. Vous devez placer la liste d’attributs entre crochets (« < » et « > »).

  L’attribut FlagsAttribute indique que la valeur d’un instance de l’énumération peut inclure plusieurs membres d’énumération et que chaque membre représente un champ de bits dans la valeur d’énumération.

• accessmodifier

  Optionnel. Spécifie le code pouvant accéder à cette énumération. Il peut s'agir d'une des méthodes suivantes :

  • Public

  • Protected

  • Friend

  • Privé

  • Ami protégé

  • Private Protected

• Shadows

  Optionnel. Indique que cette énumération redéclare et masque un élément de programmation du même nom ou un ensemble d’éléments surchargés dans une classe de base. Vous pouvez définir les clichés instantanés uniquement sur l’énumération elle-même, et non sur ses membres.

• enumerationname

  Obligatoire. Nom de l’énumération. Pour plus d’informations sur les noms valides, consultez Noms d’éléments déclarés.

• datatype

  Optionnel. Type de données de l’énumération et de tous ses membres.

• memberlist

  Obligatoire. Liste des constantes membres déclarées dans cette instruction. Plusieurs membres apparaissent sur des lignes de code source individuelles.

  Chaque member emploie la syntaxe et les éléments suivants : [<attribute list>] member name [ = initializer ]

  Élément	Description
  membername	Obligatoire. Nom de ce membre.
  initializer	Optionnel. Expression évaluée au moment de la compilation et affectée à ce membre.

• End Enum

  Met fin au bloc Enum.

Notes

Si vous avez un ensemble de valeurs immuables qui sont logiquement liées les unes aux autres, vous pouvez les définir ensemble dans une énumération. Cela fournit des noms significatifs pour l’énumération et ses membres, qui sont plus faciles à mémoriser que leurs valeurs. Vous pouvez ensuite utiliser les membres d’énumération à de nombreux emplacements dans votre code.

Les avantages de l’utilisation d’énumérations sont les suivants :

• Permet de réduire les erreurs de transposition ou de saisie des nombres.

• Facilite la future modification des valeurs.

• Rend le code plus facile à lire, ce qui réduit le risque d’y introduire des erreurs.

• Garantit une compatibilité ascendante. Si vous utilisez les énumérations, le risque d’échec de votre code est moindre si, à l’avenir, un utilisateur modifie les valeurs correspondant aux noms des membres.

Une énumération a un nom, un type de données sous-jacent et un ensemble de membres. Chaque membre représente une constante.

Une énumération déclarée au niveau de la classe, de la structure, du module ou de l’interface, en dehors de toute procédure, est une énumération membre. Il s’agit d’un membre de la classe, de la structure, du module ou de l’interface qui le déclare.

Les énumérations de membres sont accessibles à partir de n’importe où dans leur classe, structure, module ou interface. Le code en dehors d’une classe, d’une structure ou d’un module doit qualifier le nom d’une énumération membre avec le nom de cette classe, structure ou de ce module. Vous pouvez éviter d’utiliser des noms complets en ajoutant une instruction Imports au fichier source.

Une énumération déclarée au niveau de l’espace de noms, en dehors de toute classe, structure, module ou interface, est membre de l’espace de noms dans lequel elle apparaît.

Le contexte de déclaration d’une énumération doit être un fichier source, un espace de noms, une classe, une structure, un module ou une interface et ne peut pas être une procédure. Pour plus d’informations, consultez Contextes de déclaration et niveaux d’accès par défaut.

Vous pouvez appliquer des attributs à une énumération dans son ensemble, mais pas à ses membres individuellement. Un attribut fournit des informations aux métadonnées de l’assembly.

Type de données

L’instruction Enum peut déclarer le type de données d’une énumération. Chaque membre prend le type de données de l’énumération. Vous pouvez spécifier Byte, Integer, Long, SByte, Short, UInteger, ULong ou UShort.

Si vous ne spécifiez pas datatype pour l’énumération, chaque membre prend le type de données de son initializer. Si vous spécifiez à la fois datatype et initializer, le type de données de initializer doit être convertible en datatype. Si ni datatype ni initializer n’est présent, le type de données par défaut est Integer.

Initialisation des membres

L’instruction Enum peut initialiser le contenu des membres sélectionnés dans memberlist. Vous utilisez initializer pour fournir une expression à affecter au membre.

Si vous ne spécifiez pas initializer pour un membre, Visual Basic l’initialise soit à zéro (s’il s’agit du premier member dans memberlist), soit à une valeur supérieure d’un par rapport au précédent immédiat de member.

L’expression fournie dans chaque initializer peut être n’importe quelle combinaison de littéraux, d’autres constantes déjà définies et de membres d’énumération déjà définis, y compris un membre précédent de cette énumération. Vous pouvez utiliser des opérateurs arithmétiques et logiques pour combiner ces éléments.

Vous ne pouvez pas utiliser de variables ou de fonctions dans initializer. Toutefois, vous pouvez utiliser des mots clés de conversion tels que CByte et CShort. Vous pouvez également utiliser AscW si vous l’appelez avec une constante String ou un argument Char, car cela peut être évalué au moment de la compilation.

Les énumérations ne peuvent pas avoir de valeurs à virgule flottante. Si une valeur à virgule flottante est attribuée à un membre et que Option Strict est défini sur activé, une erreur du compilateur se produit. Si Option Strict est désactivé, la valeur est automatiquement convertie en type Enum.

Si la valeur d’un membre dépasse la plage autorisée pour le type de données sous-jacent, ou si vous initialisez un membre à la valeur maximale autorisée par le type de données sous-jacentes, le compilateur signale une erreur.

Modificateurs

Les énumérations de membres de classe, de structure, de module et d’interface sont par défaut l’accès public. Vous pouvez ajuster leurs niveaux d’accès avec les modificateurs d’accès. Les énumérations des membres de l’espace de noms sont par défaut l’accès ami. Vous pouvez ajuster leurs niveaux d’accès au public, mais pas au niveau privé ou protégé. Pour plus d’informations, consultez Niveaux d’accès en Visual Basic.

Tous les membres de l’énumération disposent d’un accès public et vous ne pouvez pas utiliser de modificateurs d’accès sur eux. Toutefois, si l’énumération elle-même a un niveau d’accès plus restreint, le niveau d’accès d’énumération spécifié est prioritaire.

Par défaut, toutes les énumérations sont des types et leurs champs sont des constantes. Par conséquent, les mots clés Shared, Static et ReadOnly ne peuvent pas être utilisés lors de la déclaration d’une énumération ou de ses membres.

Affectation de plusieurs valeurs

Les énumérations représentent généralement des valeurs mutuellement exclusives. En incluant l’attribut FlagsAttribute dans la déclaration Enum, vous pouvez affecter plusieurs valeurs à une instance de l’énumération. L’attribut FlagsAttribute précise que l’énumération doit être traitée comme un champ de bits, c’est-à-dire un ensemble d’indicateurs. Il s’agit d’énumérations au niveau du bit.

Lorsque vous déclarez une énumération à l’aide de l’attribut FlagsAttribute, nous vous recommandons d’utiliser des pouvoirs de 2, c’est-à-dire 1, 2, 4, 8, 16, etc. pour les valeurs. Nous recommandons également que « None » soit le nom d’un membre dont la valeur est 0. Pour obtenir des instructions supplémentaires, consultez FlagsAttribute et Enum.

Exemple 1

L’exemple suivant montre comment utiliser l’instruction Enum. Notez que le membre est appelé EggSizeEnum.Medium, et non Medium.

Public Class Egg
    Enum EggSizeEnum
        Jumbo
        ExtraLarge
        Large
        Medium
        Small
    End Enum

    Public Sub Poach()
        Dim size As EggSizeEnum

        size = EggSizeEnum.Medium
        ' Continue processing...
    End Sub
End Class

Exemple 2

La méthode de l’exemple suivant est en dehors de la classe Egg. Par conséquent, EggSizeEnum est entièrement qualifié comme Egg.EggSizeEnum.

Public Sub Scramble(ByVal size As Egg.EggSizeEnum)
    ' Process for the three largest sizes.
    ' Throw an exception for any other size.
    Select Case size
        Case Egg.EggSizeEnum.Jumbo
            ' Process.
        Case Egg.EggSizeEnum.ExtraLarge
            ' Process.
        Case Egg.EggSizeEnum.Large
            ' Process.
        Case Else
            Throw New ApplicationException("size is invalid: " & size.ToString)
    End Select
End Sub

Exemple 3

L’exemple suivant utilise l’instruction Enum pour définir un ensemble associé de valeurs constantes nommées. Dans ce cas, les valeurs sont des couleurs que vous pouvez choisir pour concevoir des formulaires de saisie de données pour une base de données.

Public Enum InterfaceColors
    MistyRose = &HE1E4FF&
    SlateGray = &H908070&
    DodgerBlue = &HFF901E&
    DeepSkyBlue = &HFFBF00&
    SpringGreen = &H7FFF00&
    ForestGreen = &H228B22&
    Goldenrod = &H20A5DA&
    Firebrick = &H2222B2&
End Enum

Exemple 4

L’exemple suivant montre des valeurs qui incluent des nombres positifs et négatifs.

Enum SecurityLevel
    IllegalEntry = -1
    MinimumSecurity = 0
    MaximumSecurity = 1
End Enum

Exemple 5

Dans l’exemple suivant, une clause As est utilisée pour spécifier le datatype d’une énumération.

Public Enum MyEnum As Byte
    Zero
    One
    Two
End Enum

Exemple 6

L’exemple suivant présente l’utilisation de l’énumération au niveau du bit. Plusieurs valeurs peuvent être affectées à une instance d’une énumération au niveau du bit. La déclaration Enum inclut l’attribut FlagsAttribute, qui indique que l’énumération peut être traitée comme un ensemble d’indicateurs.

' Apply the Flags attribute, which allows an instance
' of the enumeration to have multiple values.
<Flags()> Public Enum FilePermissions As Integer
    None = 0
    Create = 1
    Read = 2
    Update = 4
    Delete = 8
End Enum

Public Sub ShowBitwiseEnum()

    ' Declare the non-exclusive enumeration object and
    ' set it to multiple values.
    Dim perm As FilePermissions
    perm = FilePermissions.Read Or FilePermissions.Update

    ' Show the values in the enumeration object.
    Console.WriteLine(perm.ToString)
    ' Output: Read, Update

    ' Show the total integer value of all values
    ' in the enumeration object.
    Console.WriteLine(CInt(perm))
    ' Output: 6

    ' Show whether the enumeration object contains
    ' the specified flag.
    Console.WriteLine(perm.HasFlag(FilePermissions.Update))
    ' Output: True
End Sub

Exemple 7

L’exemple suivant itère au sein d’une énumération. Elle utilise la méthode GetNames pour récupérer un tableau de noms de membres à partir de l’énumération, et GetValues pour récupérer un tableau de valeurs de membre.

Enum EggSizeEnum
    Jumbo
    ExtraLarge
    Large
    Medium
    Small
End Enum

Public Sub Iterate()
    Dim names = [Enum].GetNames(GetType(EggSizeEnum))
    For Each name In names
        Console.Write(name & " ")
    Next
    Console.WriteLine()
    ' Output: Jumbo ExtraLarge Large Medium Small 

    Dim values = [Enum].GetValues(GetType(EggSizeEnum))
    For Each value In values
        Console.Write(value & " ")
    Next
    Console.WriteLine()
    ' Output: 0 1 2 3 4 
End Sub

Voir aussi

• Enum
• AscW
• Const (instruction)
• Dim (instruction)
• Conversions implicites et explicites
• Type Conversion Functions
• Constantes et énumérations