Freigeben über

Enum-Struktur

  • Artikel

Stellt die Basisklasse für Enumerationen bereit.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public MustInherit Class Enum
    Inherits ValueType
    Implements IComparable, IFormattable, IConvertible
'Usage
Dim instance As Enum

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public abstract class Enum : ValueType, IComparable, IFormattable, IConvertible

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public ref class Enum abstract : public ValueType, IComparable, IFormattable, IConvertible

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public abstract class Enum extends ValueType implements IComparable, IFormattable, 
    IConvertible

SerializableAttribute 
ComVisibleAttribute(true) 
public abstract class Enum extends ValueType implements IComparable, IFormattable, 
    IConvertible

Hinweise

Eine Enumeration ist eine benannte Konstante, deren zugrunde liegender Typ jeder beliebige ganzzahliger Typ außer Char sein kann. Wenn kein zugrunde liegender Typ explizit deklariert wurde, wird Int32 verwendet. Programmiersprachen stellen üblicherweise die Syntax zum Deklarieren einer Enumeration bereit, die aus einer Gruppe benannter Konstanten und deren Werten besteht.

Enum stellt Methoden zum Vergleichen von Instanzen dieser Klasse bereit, zum Konvertieren des Werts einer Instanz in die entsprechende Zeichenfolgendarstellung, zum Konvertieren der Zeichenfolgenentsprechung einer Zahl in eine Instanz dieser Klasse und zum Erstellen einer Instanz einer angegebenen Enumeration mit einem bestimmten Wert.

Eine Enumeration kann auch als Bitfeld behandelt werden. Weitere Informationen finden Sie unter FlagsAttribute.

Implementierte Schnittstellen

Diese Klasse erbt von ValueType und implementiert die IComparable-Schnittstelle, die IFormattable-Schnittstelle und die IConvertible-Schnittstelle. Verwenden Sie für Konvertierungen die Convert-Klasse anstelle der expliziten Implementierung der Schnittstellenmember von IConvertible für diese Klasse.

Richtlinien für FlagsAttribute und Enum

  • Verwenden Sie das benutzerdefinierte FlagsAttribute-Attribut nur dann für eine Enumeration, wenn eine bitweise Operation (AND, OR, EXCLUSIVE OR) mit einem numerischen Wert ausgeführt werden soll.

  • Definieren Sie Enumerationskonstanten in Potenzen von zwei, d. h., 1, 2, 4, 8 usw. Dies bedeutet, dass sich die einzelnen Flags in kombinierten Enumerationskonstanten nicht überschneiden.

  • Sie sollten eine Enumerationskonstante für häufig verwendete Flagkombinationen erstellen. Wenn Sie z. B. über eine Enumeration für Datei-E/A-Vorgänge verwenden, die die Enumerationskonstanten Read = 1 und Write = 2 enthält, sollten Sie die Enumerationskonstante ReadWrite = Read OR Write erstellen, die das Read-Flag und das Write-Flag zusammenfasst. Außerdem könnte der zum Kombinieren der Flags verwendete bitweise OR-Vorgang in bestimmten Situationen als erweitertes Konzept angesehen werden, in denen einfache Aufgaben ausgeführt werden sollten.

  • Seien Sie beim Definieren negativer Zahlen als Flagenumerationskonstanten umsichtig, da viele Flagpositionen auf 1 festgelegt werden, wodurch der Code verwirren und Codierungsfehler verursachen könnte.

  • Ein Verfahren zum Testen, ob ein Flag in einem numerischen Wert festgelegt wurde, ist die Durchführung eines bitweisen AND-Vorgangs zwischen dem numerischen Wert und der Flagenumerationskonstante, bei dem alle numerischen Werte, die nicht dem Flag entsprechen, auf 0 (null) festgelegt werden. Testen Sie anschließend, ob das Ergebnis des Vorgangs gleich der Flagenumerationskonstante ist.

  • Verwenden Sie als Namen der Flagenumerationskonstante None, dessen Wert 0 (null) ist. Sie können die None-Enumerationskonstante nicht in einem bitweisen AND-Vorgang zum Testen eines Flags verwenden, da das Ergebnis immer 0 (null) ist. Sie können aber einen logischen (nicht bitweisen) Vergleich des numerischen Werts und der None-Enumerationskonstante durchführen, um zu bestimmen, ob in dem numerischen Wert Bits festgelegt wurden.

    Wenn Sie eine Wertenumeration anstelle einer Flagenumeration erstellen, empfiehlt sich trotzdem das Erstellen einer None-Enumerationskonstanten. Der Grund hierfür ist, dass der für die Enumeration verwendete Speicher von der Common Language Runtime standardmäßig mit 0 (null) initialisiert wird. Daher enthält die Enumeration einen ungültigen Wert, wenn Sie sie erstellen, ohne eine Konstante zu definieren, deren Wert 0 (null) ist.

    Wenn für die Anwendung ein Standardwert erforderlich ist, sollten Sie für dessen Darstellung eine Enumerationskonstante verwenden, deren Wert 0 (null) ist. Wenn kein Standardwert erforderlich ist, sollten Sie eine Enumerationskonstante mit dem Wert 0 (null) verwenden. Damit wird der Fall dargestellt, für den keine anderen Enumerationskonstanten festgelegt wurden.

  • Definieren Sie keinen Enumerationswert, um ausschließlich den Zustand der Enumeration selbst darzustellen. Definieren Sie beispielsweise keine Enumerationskonstante, die lediglich das Ende der Enumeration kennzeichnet. Wenn Sie den letzten Wert der Enumeration bestimmen müssen, überprüfen Sie diesen Wert explizit. Sie können des Weiteren eine Bereichsprüfung für die erste und letzte Enumerationskonstante durchführen, wenn alle Werte in dem Bereich gültig sind.

  • Geben Sie keine Enumerationskonstanten an, die für die zukünftige Verwendung reserviert sind.

  • Wenn Sie eine Methode oder Eigenschaft definieren, die eine Enumerationskonstante als Wert akzeptiert, sollten Sie den Wert validieren. Sie können dann einen numerischen Wert in den Enumerationstyp konvertieren, auch wenn der numerische Wert nicht in der Enumeration definiert ist.

Beispiel

Im folgenden Codebeispiel wird die Verwendung einer Enumeration zur Darstellung benannter Werte sowie einer weiteren Enumeration zur Darstellung benannter Bitfelder veranschaulicht.

Imports System

Public Class EnumTest
    
    Enum Days
        Saturday
        Sunday
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
    End Enum 'Days
    
    Enum BoilingPoints
        Celcius = 100
        Fahrenheit = 212
    End Enum 'BoilingPoints
    
    <FlagsAttribute()> _
    Enum Colors
        Red = 1
        Green = 2
        Blue = 4
        Yellow = 8
    End Enum 'Colors

    Public Shared Sub Main()
        Dim weekdays As Type = GetType(Days)
        Dim boiling As Type = GetType(BoilingPoints)

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:")

        Dim s As String
        For Each s In  [Enum].GetNames(weekdays)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(weekdays, [Enum].Parse(weekdays, s), "d"))
        
        Next s
        Console.WriteLine()
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.")
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:")

        For Each s In  [Enum].GetNames(boiling)
            Console.WriteLine("{0,-11} = {1}", s, [Enum].Format(boiling, [Enum].Parse(boiling, s), "d"))
        Next s

        Dim myColors As Colors = Colors.Red Or Colors.Blue Or Colors.Yellow
        Console.WriteLine()
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors)
    End Sub 'Main
End Class 'EnumTest

using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celcius = 100, Fahrenheit = 212 };
    [FlagsAttribute]
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static void Main() {

        Type weekdays = typeof(Days);
        Type boiling = typeof(BoilingPoints);

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:");

        foreach ( string s in Enum.GetNames(weekdays) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format( weekdays, Enum.Parse(weekdays, s), "d"));

        Console.WriteLine();
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.");
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:");

        foreach ( string s in Enum.GetNames(boiling) )
            Console.WriteLine( "{0,-11}= {1}", s, Enum.Format(boiling, Enum.Parse(boiling, s), "d"));

        Colors myColors = Colors.Red | Colors.Blue | Colors.Yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors);
    }
}

using namespace System;
enum class Days
{
   Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday
};

enum class BoilingPoints
{
   Celcius = 100,
   Fahrenheit = 212
};

[FlagsAttribute]

enum class Colors
{
   Red = 1,
   Green = 2,
   Blue = 4,
   Yellow = 8
};

int main()
{
   Type^ weekdays = Days::typeid;
   Type^ boiling = BoilingPoints::typeid;
   Console::WriteLine(  "The days of the week, and their corresponding values in the Days Enum are:" );
   Array^ a = Enum::GetNames( weekdays );
   Int32 i = 0;
   do
   {
      Object^ o = a->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( weekdays, Enum::Parse( weekdays, o->ToString() ),  "d" ) );
   }
   while ( ++i < a->Length );

   Console::WriteLine();
   Console::WriteLine(  "Enums can also be created which have values that represent some meaningful amount." );
   Console::WriteLine(  "The BoilingPoints Enum defines the following items, and corresponding values:" );
   i = 0;
   Array^ b = Enum::GetNames( boiling );
   do
   {
      Object^ o = b->GetValue( i );
      Console::WriteLine(  "{0,-11}= {1}", o->ToString(), Enum::Format( boiling, Enum::Parse( boiling, o->ToString() ),  "d" ) );
   }
   while ( ++i < b->Length );

   Array^ c = Enum::GetNames( Colors::typeid );
   Colors myColors = Colors::Red | Colors::Blue | Colors::Yellow;
   Console::WriteLine();
   Console::Write(  "myColors holds a combination of colors. Namely:" );
   for ( i = 0; i < 3; i++ )
      Console::Write(  " {0}", c->GetValue( i ) );
}

import System.*;

public class EnumTest
{
    enum Days
    {
        saturday (0),
        sunday (1),
        monday (2),
        tuesday (3),
        wednesday (4),
        thursday (5),
        friday (6);
    } //Days

    enum BoilingPoints
    {
        celsius (100),
        fahrenheit (212);
    } //BoilingPoints

    /** @attribute FlagsAttribute()
     */
    enum Colors
    {
        red (1),
        green (2),
        blue (4),
        yellow (8);
    } //Colors

    public static void main(String[] args)
    {
        Type weekdays = Days.class.ToType();
        Type boiling = BoilingPoints.class.ToType();

        Console.WriteLine("The days of the week, and their corresponding"
            + " values in the Days Enum are:");
        String s[] = Enum.GetNames(weekdays);
        for (int iCtr = 0; iCtr < s.length; iCtr++) {
            Console.WriteLine("{0,-11}= {1}", s[iCtr],
                Enum.Format(weekdays, Enum.Parse(weekdays, s[iCtr]), "d"));
        }

        Console.WriteLine();
        Console.WriteLine("Enums can also be created which have values that"
            + " represent some meaningful amount.");
        Console.WriteLine("The BoilingPoints Enum defines the following items,"
            + " and corresponding values:");
        String s1[] = Enum.GetNames(boiling);
        for (int iCtr = 0; iCtr < s1.length; iCtr++) {
            Console.WriteLine("{0,-11}= {1}", s1[iCtr], 
                Enum.Format(boiling, Enum.Parse(boiling, s1[iCtr]), "d"));
        }
        Colors myColors = Colors.red | Colors.blue | Colors.yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}",
            myColors);
    } //main
} //EnumTest

import System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celcius = 100, Fahrenheit = 212 };
    FlagsAttribute
    enum Colors { Red = 1, Green = 2, Blue = 4, Yellow = 8 };

    public static function Main() {

        var weekdays : Type = Days;
        var boiling : Type = BoilingPoints;

        Console.WriteLine("The days of the week, and their corresponding values in the Days Enum are:");

        for( var i : int in Enum.GetNames(weekdays) )
            Console.WriteLine( "{0,-11}= {1}", Enum.GetNames(weekdays).GetValue(i), 
            Enum.Format( weekdays, Enum.Parse(weekdays, Enum.GetNames(weekdays).GetValue(i)), "d"));

        Console.WriteLine();
        Console.WriteLine("Enums can also be created which have values that represent some meaningful amount.");
        Console.WriteLine("The BoilingPoints Enum defines the following items, and corresponding values:");

        for ( var j : int in Enum.GetNames(boiling) )
            Console.WriteLine( "{0,-11}= {1}", Enum.GetNames(boiling).GetValue(j), 
            Enum.Format(boiling, Enum.Parse(boiling, Enum.GetNames(boiling).GetValue(j)), "d"));

        var myColors : Colors = Colors.Red | Colors.Blue | Colors.Yellow;
        Console.WriteLine();
        Console.WriteLine("myColors holds a combination of colors. Namely: {0}", myColors);
    }
}

Threadsicherheit

Dieser Typ ist sicher bei Multithreadoperationen.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

Enum-Member
System-Namespace
ValueType
FlagsAttribute
Char-Struktur
Int32