Dela via

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 ]

    Del 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.

Anmärkningar

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, , LongInteger, SByte, Short, UInteger, ULongeller 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 initializermå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.

Modifikatorer

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, Staticoch 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 EnumFlagsAttribute 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

Se även