Enum, instruction (Visual Basic)

Article
04/10/2013

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

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

Composants

Élément	Description
attributelist	Facultatif.Liste des attributs s'appliquant à cette énumération.Vous devez placer le liste d'attributs crochets pointus («<"et">"). Le FlagsAttribute attribut indique que la valeur d'une instance de l'énumération peut inclure plusieurs membres de l'énumération, et que chaque membre représente un champ de bits dans la valeur d'énumération.
accessmodifier	Facultatif.Spécifie le code pouvant accéder à cette énumération.Il peut s'agir de l'une des valeurs suivantes : Public Protégé Friend Privé Vous pouvez spécifier ProtectedFriend pour autoriser l'accès à partir du code dans la classe de l'énumération, une classe dérivée ou le même assembly.
Shadows	Facultatif.Spécifie que cette énumération redéclare et masque un élément de programmation de même nom, ou un ensemble d'éléments surchargés, dans une classe de base.Vous pouvez uniquement spécifier Shadows sur l'énumération elle-même, et non sur l'un de 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 (Visual Basic).
datatype	Facultatif.Type de données de l'énumération et de tous ses membres.
memberlist	Obligatoire.Liste des constantes membres qui sont déclarées dans cette instruction.Plusieurs membres apparaissent sur les lignes de code source individuelles. Chaque member emploie la syntaxe et les éléments suivants : [<attribute list>] member name [ = initializer ] ÉlémentDescription membername Obligatoire.Nom de ce membre. initializer Facultatif.Expression qui est évaluée au moment de la compilation et assignée à ce membre.
EndEnum	Met fin au bloc Enum.

Notes

Si vous avez un jeu de valeurs invariables qui sont liées logiquement les unes aux autres, vous pouvez les définir ensemble dans une énumération.Cela fournit des noms explicites 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 à divers endroits de votre code.

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

elle permet de réduire les erreurs dues à la transposition ou à l'entrée incorrecte de nombres ;
elle facilite la modification ultérieure des valeurs ;
Rend le code plus facile à lire, ce qui signifie qu'il est peu probable que les erreurs vont être introduites.
elle garantit la compatibilité ascendante.Si vous utilisez des énumérations, votre code est moins susceptible d'échouer si à l'avenir quelqu'un modifie les valeurs correspondant aux noms de membres.

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

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

Les énumérations de membres sont accessibles à partir de n'importe où au sein de leur classe, structure, module ou interface.Le code à l'extérieur d'une classe, d'une structure ou d'un module doit qualifier le nom d'une énumération de membre avec le nom de cette classe, de cette structure ou de ce module.Vous pouvez éviter la nécessité d'utiliser des noms qualifiés complets en ajoutant une importations instruction dans le 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 un membre de l'espace de noms dans lequel elle apparaît.

Le contexte de déclaration pour une énumération doit être un fichier source, espace de noms, classe, structure, module ou 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 (Visual Basic).

Vous pouvez appliquer des attributs à l'ensemble d'une énumération, 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 datatype et initializer, le type de données de initializer doit pouvoir être converti en datatype.Si ni l'élément datatype ni l'élément initializer n'est présent, le type de données a la valeur Integer par défaut.

L'initialisation des membres

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

Si vous ne spécifiez pas initializer pour un membre, Visual Basic l'initialise soit à zéro (si c'est le premier member dans memberlist), soit à une valeur supérieure d'une unité à la valeur du member qui précède immédiatement.

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 ni de fonctions dans initializer.Toutefois, vous pouvez utiliser des mots clés de conversions, tels que CByte et CShort.Vous pouvez également utiliser AscW si vous l'appelez avec une constante String ou un argument Char, car l'évaluation peut se produire au moment de la compilation.

Les énumérations ne peuvent pas comporter de valeurs à virgule flottante.Si un membre est affecté une valeur à virgule flottante et Option Strict a la valeur on, une erreur de compilation se produit.Si Option Strict est désactivé, la valeur est automatiquement convertie en la Enum type.

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-jacent, le compilateur signale une erreur.

Modificateurs

Les énumérations de membres d'une classe, d'une structure, d'un module et d'une interface disposent par défaut d'un accès public.Vous pouvez régler leurs niveaux d'accès avec les modificateurs d'accès.Les énumérations de membres d'un espace de noms disposent par défaut d'un accès ami.Vous pouvez régler un niveau d'accès public, mais pas privé ni protégé.Pour plus d'informations, consultez Niveaux d'accès dans Visual Basic.

Tous les membres d'énumération ont un accès public, et vous ne pouvez pas utiliser de modificateurs d'accès sur ceux-ci.Toutefois, si l'énumération proprement dite possède un niveau d'accès plus restreint, le niveau d'accès spécifié de l'énumération prend la priorité.

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 valeurs multiples

Énumérations représentent généralement les valeurs mutuellement exclusives.En incluant les FlagsAttribute l'attribut dans le Enum déclaration, vous pouvez plutôt attribuer plusieurs valeurs à une instance de l'énumération.Le FlagsAttribute attribut spécifie que l'énumération soient traités comme un champ de bits, c'est-à-dire un ensemble d'indicateurs.Il s'agit de au niveau du bit énumérations.

Lorsque vous déclarez une énumération à l'aide de la FlagsAttribute attribut, nous vous recommandons d'utiliser les puissances de 2, qui est, 1, 2, 4, 8, 16 et ainsi de suite, pour les valeurs.Nous vous recommandons également que « None » est le nom d'un membre dont la valeur est 0.Pour connaître les instructions supplémentaires, consultez FlagsAttribute et Enum.

Exemple

L'exemple suivant montre comment utiliser la Enum instruction.Notez que le membre est appelé EggSizeEnum.Mediumet non en tant que 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

La méthode dans l'exemple suivant est en dehors de la Egg classe.Par conséquent, EggSizeEnum est qualifié en tant que 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

L'exemple suivant utilise l'instruction Enum pour définir un jeu connexe de valeurs de constantes nommées.Dans ce cas, les valeurs sont des couleurs que vous pouvez choisir pour désigner des formulaires d'entrée 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

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

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

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

Public Enum MyEnum As Byte
  Zero
  One
  Two
End Enum

L'exemple suivant montre comment utiliser une énumération au niveau du bit.Plusieurs valeurs peuvent être affectés à une instance d'une énumération au niveau du bit.Le Enum déclaration comprend le FlagsAttribute attribut 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

L'exemple suivant effectue une itération dans une énumération.Il utilise le GetNames méthode pour récupérer un tableau de noms de membres 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