Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Déclare une énumération et définit les valeurs de ses membres.
Syntaxe
[ <attributelist> ] [ accessmodifier ] [ Shadows ]
Enum enumerationname [ As datatype ]
memberlist
End Enum
Pièces
attributelistOptionnel. 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’une 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.
accessmodifierOptionnel. Spécifie le code qui peut accéder à cette énumération. Il peut s’agir de l’un des éléments suivants :
ShadowsOptionnel. Spécifie que cette énumération redeclare et masque un élément de programmation nommé identiquement, ou un ensemble d’éléments surchargés, dans une classe de base. Vous pouvez spécifier des ombres uniquement sur l’énumération elle-même, et non sur l’un de ses membres.
enumerationnameObligatoire. Nom de l’énumération. Pour plus d’informations sur les noms valides, consultez Noms d’éléments déclarés.
datatypeOptionnel. Type de données de l’énumération et de tous ses membres.
memberlistObligatoire. Liste des constantes membres déclarées dans cette instruction. Plusieurs membres apparaissent sur des lignes de code source individuelles.
Chacune
membera la syntaxe et les parties suivantes :[<attribute list>] member name [ = initializer ]Composant Descriptif membernameObligatoire. Nom de ce membre. initializerOptionnel. Expression évaluée au moment de la compilation et affectée à ce membre. EndEnumTermine le
Enumbloc.
Remarques
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 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 à de nombreux endroits dans votre code.
Les avantages de l’utilisation d’énumérations sont les suivants :
Réduit les erreurs provoquées par la transposition ou les erreurs de saisie des nombres.
Facilite la modification des valeurs à l’avenir.
Facilite la lecture du code, ce qui signifie qu’il est moins probable que les erreurs seront introduites.
Garantit la compatibilité vers l’avant. Si vous utilisez des énumérations, votre code est moins susceptible d’échouer si dans le futur 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 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 depuis 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 module. Vous pouvez éviter d’avoir à utiliser des noms qualifiés 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 n’importe quelle classe, structure, module ou interface, est membre de l’espace de noms dans lequel il 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 contribue aux informations des 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, IntegerShortSByteUIntegerLongULongou .UShort
Si vous ne spécifiez datatype pas pour l’énumération, chaque membre prend le type de données de son initializer. Si vous spécifiez à la fois datatype et initializerque le type de données doit initializer être convertible en datatype. Si aucun n’est datatype présent initializer , le type de données est défini par défaut Integersur .
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 initializer pas pour un membre, Visual Basic l’initialise à zéro (s’il s’agit du premier member in memberlist), ou à une valeur supérieure par une valeur supérieure à celle immédiatement précédente member.
L’expression fournie dans chacun initializer peut être n’importe quelle combinaison de littéraux, d’autres constantes déjà définies et des 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 l’utiliser AscW si vous l’appelez avec une constante String ou Char un argument, car cela peut être évalué au moment de la compilation.
Les énumérations ne peuvent pas avoir de valeurs à virgule flottante. Si un membre reçoit une valeur à virgule flottante et Option Strict est activé, une erreur du compilateur se produit. Si Option Strict elle est désactivée, la valeur est automatiquement convertie en 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 de classe, de structure, de module et d’interface par défaut sont accessibles au 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 par défaut pour l’accès ami. Vous pouvez ajuster leurs niveaux d’accès au public, mais pas à des niveaux privés ou protégés. Pour plus d’informations, consultez Niveaux d’accès en 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 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 Sharedmots clés et ReadOnly les mots Staticclés 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 Enum déclaration, vous pouvez affecter à la place plusieurs valeurs à une instance de l’énumération. L’attribut FlagsAttribute spécifie que l’énumération doit être traitée comme un champ de bits, c’est-à-dire un ensemble d’indicateurs. Elles sont appelées énumérations au niveau du bit .
Lorsque vous déclarez une énumération à l’aide de l’attribut FlagsAttribute , nous vous recommandons d’utiliser les pouvoirs 2, c’est-à-dire 1, 2, 4, 8, 16, et ainsi de suite, pour les valeurs. Nous recommandons également que « Aucun » 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 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
Exemple 2
La méthode de 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
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 de concevoir 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
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 As clause est utilisée pour spécifier l’énumération datatype .
Public Enum MyEnum As Byte
Zero
One
Two
End Enum
Exemple 6
L’exemple suivant montre comment utiliser une énumération au niveau du bit. Plusieurs valeurs peuvent être affectées à une instance d’une énumération au niveau du bit. La Enum déclaration 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 dans une énumération. Il utilise la GetNames méthode 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
Collaborer avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner les problèmes et les demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
