Uppräkningsuttryck (Visual Basic)
Deklarerar en uppräkning och definierar värdena för dess medlemmar.
Syntax
[ <attributelist> ] [ accessmodifier ] [ Shadows ]
Enum enumerationname [ As datatype ]
memberlist
End Enum
Delar
attributelist
Valfritt. Lista över attribut som gäller för den här uppräkningen. Du måste omsluta attributlistan i vinkelparenteser ("
<
" och ">
").Attributet FlagsAttribute anger att värdet för en instans av uppräkningen kan innehålla flera uppräkningsmedlemmar och att varje medlem representerar ett bitfält i uppräkningsvärdet.
accessmodifier
Valfritt. Anger vilken kod som kan komma åt den här uppräkningen. Kan vara något av följande:
Shadows
Valfritt. Anger att den här uppräkningen redeclares och döljer ett identiskt namngivet programmeringselement, eller en uppsättning överlagrade element, i en basklass. Du kan bara ange Skuggor för själva uppräkningen, inte för någon av dess medlemmar.
enumerationname
Obligatoriskt. Namn på uppräkningen. Information om giltiga namn finns i Deklarerade elementnamn.
datatype
Valfritt. Datatyp för uppräkningen och alla dess medlemmar.
memberlist
Obligatoriskt. Lista över medlemskonstanter som deklareras i den här instruktionen. Flera medlemmar visas på enskilda källkodsrader.
Var
member
och en har följande syntax och delar:[<attribute list>] member name [ = initializer ]
Delvis beskrivning membername
Obligatoriskt. Namnet på den här medlemmen. initializer
Valfritt. Uttryck som utvärderas vid kompileringstid och tilldelas till den här medlemmen. End
Enum
Enum
Avslutar blocket.
Kommentarer
Om du har en uppsättning oföränderlig värden som är logiskt relaterade till varandra kan du definiera dem tillsammans i en uppräkning. Detta ger meningsfulla namn för uppräkningen och dess medlemmar, som är lättare att komma ihåg än deras värden. Du kan sedan använda uppräkningsmedlemmarna på många platser i koden.
Fördelarna med att använda uppräkningar är följande:
Minskar fel som orsakas av transponering eller feltypning av tal.
Gör det enkelt att ändra värden i framtiden.
Gör koden lättare att läsa, vilket innebär att det är mindre troligt att fel introduceras.
Säkerställer kompatibilitet framåt. Om du använder uppräkningar är det mindre troligt att koden misslyckas om någon i framtiden ändrar de värden som motsvarar medlemsnamnen.
En uppräkning har ett namn, en underliggande datatyp och en uppsättning medlemmar. Varje medlem representerar en konstant.
En uppräkning som deklareras på klass-, struktur-, modul- eller gränssnittsnivå, utanför någon procedur, är en medlemsuppräkning. Det är en medlem i klassen, strukturen, modulen eller gränssnittet som deklarerar den.
Medlemsuppräkningar kan nås var som helst i deras klass, struktur, modul eller gränssnitt. Kod utanför en klass, struktur eller modul måste kvalificera en medlemsuppräknings namn med namnet på den klassen, strukturen eller modulen. Du kan undvika behovet av att använda fullständigt kvalificerade namn genom att lägga till en import-instruktion i källfilen.
En uppräkning som deklareras på namnområdesnivå, utanför någon klass, struktur, modul eller gränssnitt, är medlem i namnområdet där den visas.
Deklarationskontexten för en uppräkning måste vara en källfil, namnrymd, klass, struktur, modul eller gränssnitt och kan inte vara en procedur. Mer information finns i Deklarationskontexter och standardåtkomstnivåer.
Du kan använda attribut för en uppräkning som helhet, men inte för dess medlemmar individuellt. Ett attribut bidrar med information till sammansättningens metadata.
Datatyp
-instruktionen Enum
kan deklarera datatypen för en uppräkning. Varje medlem tar uppräkningens datatyp. Du kan ange Byte
, , Long
Integer
, SByte
, Short
, UInteger
, ULong
eller UShort
.
Om du inte anger datatype
för uppräkningen tar varje medlem datatypen för sin initializer
. Om du anger både datatype
och initializer
måste datatypen initializer
för vara konvertibel till datatype
. Om varken datatype
eller initializer
finns, är datatypen som standard Integer
.
Initiera medlemmar
Instruktionen Enum
kan initiera innehållet i valda medlemmar i memberlist
. Du använder initializer
för att ange ett uttryck som ska tilldelas medlemmen.
Om du inte anger initializer
för en medlem initierar Visual Basic det antingen till noll (om det är det första member
i memberlist
), eller till ett värde som är större än värdet för omedelbart före member
.
Uttrycket som anges i var och en initializer
kan vara valfri kombination av literaler, andra konstanter som redan har definierats och uppräkningsmedlemmar som redan har definierats, inklusive en tidigare medlem i den här uppräkningen. Du kan använda aritmetiska och logiska operatorer för att kombinera sådana element.
Du kan inte använda variabler eller funktioner i initializer
. Du kan dock använda konverteringsnyckelord som CByte
och CShort
. Du kan också använda AscW
om du anropar den med en konstant String
eller Char
ett argument, eftersom det kan utvärderas vid kompileringstillfället.
Uppräkningar får inte ha flyttalsvärden. Om en medlem tilldelas ett flyttalsvärde och Option Strict
anges till på, uppstår ett kompilatorfel. Om Option Strict
är av konverteras värdet automatiskt till Enum
typen .
Om värdet för en medlem överskrider det tillåtna intervallet för den underliggande datatypen, eller om du initierar en medlem till det högsta värde som tillåts av den underliggande datatypen, rapporterar kompilatorn ett fel.
Modifierare
Klass-, struktur-, modul- och gränssnittsmedlemsuppräkningar är standard för offentlig åtkomst. Du kan justera deras åtkomstnivåer med åtkomstmodifierarna. Namnområdesmedlemsuppräkningar är standard för vänåtkomst. Du kan justera deras åtkomstnivåer till offentliga, men inte till privata eller skyddade. Mer information finns i Åtkomstnivåer i Visual Basic.
Alla uppräkningsmedlemmar har offentlig åtkomst och du kan inte använda några åtkomstmodifierare på dem. Men om själva uppräkningen har en mer begränsad åtkomstnivå har den angivna uppräkningsåtkomstnivån företräde.
Som standard är alla uppräkningar typer och deras fält är konstanter. Därför kan nyckelorden Shared
, Static
och ReadOnly
inte användas när du deklarerar en uppräkning eller dess medlemmar.
Tilldela flera värden
Uppräkningar representerar vanligtvis ömsesidigt uteslutande värden. Genom att inkludera FlagsAttribute attributet i deklarationen Enum
kan du i stället tilldela flera värden till en instans av uppräkningen. Attributet FlagsAttribute anger att uppräkningen ska behandlas som ett bitfält, dvs. en uppsättning flaggor. Dessa kallas bitvis uppräkningar.
När du deklarerar en uppräkning med hjälp FlagsAttribute av attributet rekommenderar vi att du använder 2, det vill säga 1, 2, 4, 8, 16 och så vidare, för värdena. Vi rekommenderar också att "Ingen" är namnet på en medlem vars värde är 0. Ytterligare riktlinjer finns i FlagsAttribute och Enum.
Exempel 1
I följande exempel visas hur du använder -instruktionen Enum
. Observera att medlemmen kallas EggSizeEnum.Medium
, och inte som 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
Exempel 2
Metoden i följande exempel ligger utanför Egg
klassen. EggSizeEnum
Därför är fullständigt kvalificerad som 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
Exempel 3
I följande exempel används -instruktionen Enum
för att definiera en relaterad uppsättning med namngivna konstanta värden. I det här fallet är värdena färger som du kan välja för att utforma datainmatningsformulär för en databas.
Public Enum InterfaceColors
MistyRose = &HE1E4FF&
SlateGray = &H908070&
DodgerBlue = &HFF901E&
DeepSkyBlue = &HFFBF00&
SpringGreen = &H7FFF00&
ForestGreen = &H228B22&
Goldenrod = &H20A5DA&
Firebrick = &H2222B2&
End Enum
Exempel 4
I följande exempel visas värden som innehåller både positiva och negativa tal.
Enum SecurityLevel
IllegalEntry = -1
MinimumSecurity = 0
MaximumSecurity = 1
End Enum
Exempel 5
I följande exempel används en As
sats för att ange datatype
en uppräkning.
Public Enum MyEnum As Byte
Zero
One
Two
End Enum
Exempel 6
I följande exempel visas hur du använder en bitvis uppräkning. Flera värden kan tilldelas till en instans av en bitvis uppräkning. Deklarationen Enum
FlagsAttribute innehåller attributet som anger att uppräkningen kan behandlas som en uppsättning flaggor.
' 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
Exempel 7
Följande exempel itererar genom en uppräkning. Den använder GetNames metoden för att hämta en matris med medlemsnamn från uppräkningen och GetValues för att hämta en matris med medlemsvärden.
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