Istruzione Enum (Visual Basic)

  • Articolo

Dichiara un'enumerazione e definisce i valori dei relativi membri.

Sintassi

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

Parti

  • attributelist

    Facoltativa. Elenco di attributi che si applicano a questa enumerazione. È necessario racchiudere l'elenco di attributi tra parentesi angolari ("<" e ">").

    L'attributo FlagsAttribute indica che il valore di un'istanza dell'enumerazione può includere più membri di enumerazione e che ogni membro rappresenta un campo bit nel valore di enumerazione.

  • accessmodifier

    Facoltativa. Specifica il codice che può accedere a questa enumerazione. Può essere uno dei valori seguenti:

  • Shadows

    Facoltativa. Specifica che questa enumerazione ridistribui e nasconde un elemento di programmazione denominato identico o un set di elementi di overload in una classe base. È possibile specificare Shadows solo nell'enumerazione stessa, non in uno dei relativi membri.

  • enumerationname

    Obbligatorio. Nome dell'enumerazione. Per informazioni sui nomi validi, vedere Nomi di elemento dichiarati.

  • datatype

    Facoltativa. Tipo di dati dell'enumerazione e di tutti i relativi membri.

  • memberlist

    Obbligatorio. Elenco delle costanti membro dichiarate in questa istruzione. Più membri vengono visualizzati in singole righe di codice sorgente.

    Ogni member ha la sintassi e le parti seguenti: [<attribute list>] member name [ = initializer ]

    Parte Descrizione
    membername Obbligatorio. Nome di questo membro.
    initializer Facoltativa. Espressione valutata in fase di compilazione e assegnata a questo membro.

  • End Enum

    Termina il blocco Enum.

Commenti

Se si dispone di un set di valori non modificabili correlati logicamente l'uno all'altro, è possibile definirli insieme in un'enumerazione. In questo modo vengono forniti nomi significativi per l'enumerazione e i relativi membri, che sono più facili da ricordare rispetto ai relativi valori. È quindi possibile usare i membri dell'enumerazione in molte posizioni nel codice.

I vantaggi dell'uso delle enumerazioni includono quanto segue:

  • Riduce gli errori causati dalla trasposizione o dalla digitazione errata dei numeri.

  • Semplifica la modifica dei valori in futuro.

  • Semplifica la lettura del codice, il che significa che è meno probabile che vengano introdotti errori.

  • Assicura la compatibilità con le versioni successive. Se si usano enumerazioni, è meno probabile che il codice abbia esito negativo se in futuro qualcuno modifica i valori corrispondenti ai nomi dei membri.

Un'enumerazione ha un nome, un tipo di dati sottostante e un set di membri. Ogni membro rappresenta una costante.

Un'enumerazione dichiarata a livello di classe, struttura, modulo o interfaccia, all'esterno di qualsiasi procedura, è un'enumerazione membro. È un membro della classe, della struttura, del modulo o dell'interfaccia che lo dichiara.

Le enumerazioni membro possono essere accessibili da qualsiasi posizione all'interno della classe, della struttura, del modulo o dell'interfaccia. Il codice esterno a una classe, una struttura o un modulo deve qualificare il nome dell'enumerazione membro con il nome di tale classe, struttura o modulo. È possibile evitare la necessità di usare nomi completi aggiungendo un'istruzione Import al file di origine.

Un'enumerazione dichiarata a livello di spazio dei nomi, all'esterno di qualsiasi classe, struttura, modulo o interfaccia, è un membro dello spazio dei nomi in cui viene visualizzato.

Il contesto di dichiarazione per un'enumerazione deve essere un file di origine, uno spazio dei nomi, una classe, una struttura, un modulo o un'interfaccia e non può essere una routine. Per altre informazioni, vedere Contesti delle dichiarazioni e livelli di accesso predefiniti.

È possibile applicare attributi a un'enumerazione nel suo complesso, ma non ai relativi membri singolarmente. Un attributo contribuisce a informazioni sui metadati dell'assembly.

Tipo di dati

L'istruzione Enum può dichiarare il tipo di dati di un'enumerazione. Ogni membro accetta il tipo di dati dell'enumerazione. È possibile specificare Byte, LongShortSByteUIntegerInteger, ULongo .UShort

Se non si specifica datatype per l'enumerazione, ogni membro accetta il tipo di dati del relativo initializer. Se si specificano entrambi datatype e initializer, il tipo di dati di initializer deve essere convertibile in datatype. Se non datatype è presente né initializer , il tipo di dati è predefinito su Integer.

Inizializzazione dei membri

L'istruzione Enum può inizializzare il contenuto dei membri selezionati in memberlist. Si usa initializer per specificare un'espressione da assegnare al membro.

Se non si specifica initializer per un membro, Visual Basic lo inizializza su zero (se è il primo member in memberlist) o su un valore maggiore di uno di quello dell'oggetto immediatamente precedente member.

L'espressione fornita in ogni initializer oggetto può essere qualsiasi combinazione di valori letterali, altre costanti già definite e membri di enumerazione già definiti, incluso un membro precedente di questa enumerazione. È possibile usare operatori aritmetici e logici per combinare tali elementi.

Non è possibile usare variabili o funzioni in initializer. È tuttavia possibile usare parole chiave di conversione, CByte ad esempio e CShort. È anche possibile usare AscW se lo si chiama con una costante String o Char un argomento, poiché può essere valutato in fase di compilazione.

Le enumerazioni non possono avere valori a virgola mobile. Se un membro viene assegnato un valore a virgola mobile e Option Strict viene impostato su su, si verifica un errore del compilatore. Se Option Strict è disattivato, il valore viene convertito automaticamente nel Enum tipo.

Se il valore di un membro supera l'intervallo consentito per il tipo di dati sottostante o se si inizializza qualsiasi membro al valore massimo consentito dal tipo di dati sottostante, il compilatore segnala un errore.

Modificatori

Classe, struttura, modulo e enumerazione membro dell'interfaccia predefinita per l'accesso pubblico. È possibile modificare i livelli di accesso con i modificatori di accesso. L'enumerazione membro dello spazio dei nomi è predefinita per l'accesso a un amico. È possibile modificare i livelli di accesso al pubblico, ma non a privati o protetti. Per altre informazioni, vedere Livelli di accesso in Visual Basic.

Tutti i membri dell'enumerazione hanno accesso pubblico e non è possibile usare i modificatori di accesso su di essi. Tuttavia, se l'enumerazione stessa ha un livello di accesso più limitato, il livello di accesso di enumerazione specificato ha la precedenza.

Per impostazione predefinita, tutte le enumerazioni sono tipi e i relativi campi sono costanti. Non è pertanto possibile usare le Sharedparole chiave , Statice ReadOnly quando si dichiara un'enumerazione o i relativi membri.

Assegnazione di più valori

Le enumerazioni rappresentano in genere valori esclusivi a vicenda. Includendo l'attributo FlagsAttribute nella Enum dichiarazione, è invece possibile assegnare più valori a un'istanza dell'enumerazione. L'attributo FlagsAttribute specifica che l'enumerazione viene considerata come un campo bit, ovvero un set di flag. Questi sono chiamati enumerazioni bit per bit .

Quando si dichiara un'enumerazione usando l'attributo FlagsAttribute , è consigliabile usare i poteri di 2, ovvero 1, 2, 4, 8, 16 e così via, per i valori. È anche consigliabile che "Nessuno" sia il nome di un membro il cui valore è 0. Per altre linee guida, vedere FlagsAttribute e Enum.

Esempio 1

L'esempio seguente mostra come usare l'istruzione Enum. Si noti che il membro viene definito EggSizeEnum.Medium, e non come 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

Esempio 2

Il metodo nell'esempio seguente è esterno alla Egg classe. Pertanto, EggSizeEnum è completo come 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

Esempio 3

Nell'esempio seguente viene usata l'istruzione Enum per definire un set correlato di valori costanti denominati. In questo caso, i valori sono colori che è possibile scegliere di progettare moduli di immissione dati per un database.

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

Esempio 4

Nell'esempio seguente vengono illustrati i valori che includono numeri positivi e negativi.

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

Esempio 5

Nell'esempio seguente viene usata una As clausola per specificare l'enumerazione datatype .

Public Enum MyEnum As Byte
    Zero
    One
    Two
End Enum

Esempio 6

Nell'esempio seguente viene illustrato come usare un'enumerazione bit per bit. È possibile assegnare più valori a un'istanza di un'enumerazione bit per bit. La Enum dichiarazione include l'attributo, che indica che l'enumerazione FlagsAttribute può essere considerata come un set di flag.

' 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

Esempio 7

Nell'esempio seguente viene eseguita un'iterazione tramite un'enumerazione. Usa il GetNames metodo per recuperare una matrice di nomi membro dall'enumerazione e GetValues recuperare una matrice di valori membro.

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

Vedi anche