Enum Класс

Определение

Предоставляет базовый класс для перечислений.Provides the base class for enumerations.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible
Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, IFormattable
Наследование
Производный
Атрибуты
Реализации

Примеры

В следующем примере демонстрируется использование перечисления для представления именованных значений и другого перечисления для представления именованных битовых полей.The following example demonstrates using an enumeration to represent named values and another enumeration to represent named bit fields.

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

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

[Flags]

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 ) );
}
using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [Flags]
    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);
    }
}
Public Class EnumTest
    Enum Days
        Saturday
        Sunday
        Monday
        Tuesday
        Wednesday
        Thursday
        Friday
    End Enum 
    
    Enum BoilingPoints
        Celsius = 100
        Fahrenheit = 212
    End Enum 
    
    <Flags()> _
    Enum Colors
        Red = 1
        Green = 2
        Blue = 4
        Yellow = 8
    End Enum 

    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 
End Class 

Комментарии

Перечисление — это набор именованных констант, базовый тип которых имеет любой целочисленный тип.An enumeration is a set of named constants whose underlying type is any integral type. Если базовый тип не объявлен явно, Int32 используется.If no underlying type is explicitly declared, Int32 is used. Enumявляется базовым классом для всех перечислений в .NET Framework.Enum is the base class for all enumerations in the .NET Framework. Типы перечисления определяются с помощью enum ключевого C# слова в Enumи... End Enum конструкция в Visual Basic.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enumпредоставляет методы для сравнения экземпляров этого класса, преобразования значения экземпляра в строковое представление, преобразования строкового представления числа в экземпляр этого класса и создания экземпляра указанного перечисления и значения.Enum provides methods for comparing instances of this class, converting the value of an instance to its string representation, converting the string representation of a number to an instance of this class, and creating an instance of a specified enumeration and value.

Кроме того, перечисление можно рассматривать как битовое поле.You can also treat an enumeration as a bit field. Дополнительные сведения см. в разделе Неисключительные члены и раздел атрибутов flags и в FlagsAttribute разделе.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

В этом разделе.In this topic:

Создание типа перечисления Creating an enumeration type
Создание экземпляра типа перечисления Instantiating an enumeration type
Рекомендации по перечислению Enumeration best practices
Выполнение операций с перечислениями Performing operations with enumerations
Выполнение преобразованийPerforming conversions
Синтаксический анализ значений перечисленияParsing enumeration values
Форматирование значений перечисленияFormatting enumeration values
Перебор членов перечисленияIterating enumeration members
Неисключительные члены и атрибут FlagsNon-exclusive members and the Flags attribute
Добавление методов перечисленияAdding enumeration methods

Создание типа перечисленияCreating an enumeration type

Языки программирования обычно предоставляют синтаксис для объявления перечисления, состоящего из набора именованных констант и их значений.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. В следующем примере показан синтаксис, C# используемый и Visual Basic для определения перечисления.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Он создает перечисление ArrivalStatus с именем, которое имеет ArrivalStatus.Earlyтри ArrivalStatus.OnTimeчлена: ArrivalStatus.Late, и.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Обратите внимание, что в обоих случаях перечисление не наследуется Enumявным образом. отношение наследования обрабатывается компилятором неявно.Note that in both cases, the enumeration does not explicitly inherit from Enum; the inheritance relationship is handled implicitly by the compiler.

public enum ArrivalStatus { Late=-1, OnTime=0, Early=1 };
Public Enum ArrivalStatus As Integer
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Предупреждение

Никогда не следует создавать тип перечисления, базовый тип которого не является целочисленным или Char.You should never create an enumeration type whose underlying type is non-integral or Char. Несмотря на то, что можно создать такой тип перечисления с помощью отражения, вызовы методов, которые используют полученный тип, являются ненадежными и могут также создавать дополнительные исключения.Although you can create such an enumeration type by using reflection, method calls that use the resulting type are unreliable and may also throw additional exceptions.

Создание экземпляра типа перечисленияInstantiating an enumeration type

Можно создать экземпляр типа перечисления так же, как и любой другой тип значения: путем объявления переменной и присвоения ей одной из констант перечисления.You can instantiate an enumeration type just as you instantiate any other value type: by declaring a variable and assigning one of the enumeration's constants to it. В следующем примере создается экземпляр ArrivalStatus со ArrivalStatus.OnTimeзначением.The following example instantiates an ArrivalStatus whose value is ArrivalStatus.OnTime.

public class Example
{
   public static void Main()
   {
      ArrivalStatus status = ArrivalStatus.OnTime;
      Console.WriteLine("Arrival Status: {0} ({0:D})", status);
   }
}
// The example displays the following output:
//       Arrival Status: OnTime (0)
Public Module Example
   Public Sub Main()
      Dim status As ArrivalStatus = ArrivalStatus.OnTime
      Console.WriteLine("Arrival Status: {0} ({0:D})", status)
   End Sub
End Module
' The example displays the following output:
'        Arrival Status: OnTime (0)

Кроме того, можно создать экземпляр значения перечисления следующими способами.You can also instantiate an enumeration value in the following ways:

  • С помощью определенных функций языка программирования для приведения (как в C#) или преобразования (как в Visual Basic) целочисленное значение в значение перечисления.By using a particular programming language's features to cast (as in C#) or convert (as in Visual Basic) an integer value to an enumeration value. В следующем примере создается ArrivalStatus объект, значение которого является ArrivalStatus.Early таким образом.The following example creates an ArrivalStatus object whose value is ArrivalStatus.Early in this way.

    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    Dim status2 As ArrivalStatus = CType(1, ArrivalStatus)
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2)
    ' The example displays the following output:
    '       Arrival Status: Early (1)
    
  • Путем вызова его неявного конструктора без параметров.By calling its implicit parameterless constructor. Как показано в следующем примере, в данном случае базовое значение экземпляра перечисления равно 0.As the following example shows, in this case the underlying value of the enumeration instance is 0. Однако это не обязательно значение допустимой константы в перечислении.However, this is not necessarily the value of a valid constant in the enumeration.

    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    Dim status1 As New ArrivalStatus()
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1)
    ' The example displays the following output:
    '        Arrival Status: OnTime (0)
    
  • Путем вызова Parse метода или TryParse для синтаксического анализа строки, содержащей имя константы в перечислении.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Дополнительные сведения см. в разделе анализ значений перечисления .For more information, see the Parsing Enumeration Values section.

  • Путем вызова ToObject метода для преобразования целочисленного значения в тип перечисления.By calling the ToObject method to convert an integral value to an enumeration type. Дополнительные сведения см. в разделе выполнение преобразований .For more information, see the Performing Conversions section.

Рекомендации по перечислениюEnumeration best practices

При определении типов перечислений рекомендуется использовать следующие рекомендации:We recommend that you use the following best practices when you define enumeration types:

  • Если вы не определили член перечисления, значение которого равно 0, рассмотрите возможность None создания перечислимой константы.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. По умолчанию память, используемая для перечисления, инициализируется средой CLR равным нулю.By default, the memory used for the enumeration is initialized to zero by the common language runtime. Следовательно, если не определить константу, значение которой равно нулю, то при создании перечисление будет содержать недопустимое значение.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Если существует очевидный вариант по умолчанию, который должен представлять приложение, рассмотрите возможность использования перечислимой константы, значение которой равно нулю, чтобы представить ее.If there is an obvious default case that your application has to represent, consider using an enumerated constant whose value is zero to represent it. Если регистр по умолчанию отсутствует, рассмотрите возможность использования перечислимой константы, значение которой равно нулю, чтобы указать вариант, который не представлен ни одной из других перечислимых констант.If there is no default case, consider using an enumerated constant whose value is zero to specify the case that is not represented by any of the other enumerated constants.

  • Не указывайте константы перечисления, зарезервированные для будущего использования.Do not specify enumerated constants that are reserved for future use.

  • При определении метода или свойства, принимающего перечисляемую константу в качестве значения, рассмотрите возможность проверки значения.When you define a method or property that takes an enumerated constant as a value, consider validating the value. Причина в том, что можно привести числовое значение к типу перечисления, даже если это числовое значение не определено в перечислении.The reason is that you can cast a numeric value to the enumeration type even if that numeric value is not defined in the enumeration.

Дополнительные рекомендации по типам перечислений, константы которых являются битовыми полями, перечислены в неисключительных членах и разделе атрибута flags .Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Выполнение операций с перечислениямиPerforming operations with enumerations

При создании перечисления нельзя определять новые методы.You cannot define new methods when you are creating an enumeration. Однако тип перечисления наследует полный набор статических методов Enum и экземпляров класса.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. В следующих разделах рассматриваются большинство этих методов, а также несколько других методов, которые обычно используются при работе со значениями перечисления.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Выполнение преобразованийPerforming conversions

Преобразование между членом перечисления и его базовым типом осуществляется с помощью оператора приведения ( C#in) или преобразования (в Visual Basic).You can convert between an enumeration member and its underlying type by using a casting (in C#) or conversion (in Visual Basic) operator. В следующем примере операторы приведения или преобразования используются для выполнения преобразований из целого числа в значение перечисления и из значения перечисления в целое число.The following example uses casting or conversion operators to perform conversions both from an integer to an enumeration value and from an enumeration value to an integer.

int value3 = 2;
ArrivalStatus status3 = (ArrivalStatus) value3;

int value4 = (int) status3;
Dim value3 As Integer = 2
Dim status3 As ArrivalStatus = CType(value3, ArrivalStatus)

Dim value4 As Integer = CInt(status3)

Enum Класс такжеToObject включает метод, который преобразует значение любого целочисленного типа в значение перечисления.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. В следующем примере ToObject(Type, Int32) метод используется для Int32 преобразования в ArrivalStatus значение.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. Обратите внимание, что ToObject , поскольку возвращает значение типа Object, использование оператора приведения или преобразования по-прежнему может потребоваться для приведения объекта к типу перечисления.Note that, because the ToObject returns a value of type Object, the use of a casting or conversion operator may still be necessary to cast the object to the enumeration type.

int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);
Dim number As Integer = -1
Dim arrived As ArrivalStatus = CType(ArrivalStatus.ToObject(GetType(ArrivalStatus), number), ArrivalStatus)

При преобразовании целого числа в значение перечисления можно присвоить значение, которое не является членом перечисления.When converting an integer to an enumeration value, it is possible to assign a value that is not actually a member of the enumeration. Чтобы избежать этого, перед выполнением преобразования можно передать целое число в IsDefined метод.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. В следующем примере этот метод используется для определения того, можно ли преобразовать элементы массива целочисленных значений в ArrivalStatus значения.The following example uses this method to determine whether the elements in an array of integer values can be converted to ArrivalStatus values.

using System;

public enum ArrivalStatus { Unknown=-3, Late=-1, OnTime=0, Early=1 };

public class Example
{
   public static void Main()
   {
      int[] values = { -3, -1, 0, 1, 5, Int32.MaxValue };
      foreach (var value in values)
      {
         ArrivalStatus status;
         if (Enum.IsDefined(typeof(ArrivalStatus), value))
            status = (ArrivalStatus) value;
         else
            status = ArrivalStatus.Unknown;
         Console.WriteLine("Converted {0:N0} to {1}", value, status);
      }
   }
}
// The example displays the following output:
//       Converted -3 to Unknown
//       Converted -1 to Late
//       Converted 0 to OnTime
//       Converted 1 to Early
//       Converted 5 to Unknown
//       Converted 2,147,483,647 to Unknown
Public Enum ArrivalStatus As Integer
   Unknown = -3
   Late = -1
   OnTime = 0
   Early = 1
End Enum

Module Example
   Public Sub Main()
      Dim values() As Integer = { -3, -1, 0, 1, 5, Int32.MaxValue }
      For Each value In values
         Dim status As ArrivalStatus
         If [Enum].IsDefined(GetType(ArrivalStatus), value)
            status = CType(value, ArrivalStatus) 
         Else
            status = ArrivalStatus.Unknown
         End If
         Console.WriteLine("Converted {0:N0} to {1}", value, status)
      Next   
   End Sub
End Module
' The example displays the following output:
'       Converted -3 to Unknown
'       Converted -1 to Late
'       Converted 0 to OnTime
'       Converted 1 to Early
'       Converted 5 to Unknown
'       Converted 2,147,483,647 to Unknown

Несмотря на Enum то, что класс предоставляет явные реализации IConvertible интерфейса для преобразования значения перечисления в целочисленный тип, следует Convert использовать методы класса, например ToInt32, для Выполните эти преобразования.Although the Enum class provides explicit interface implementations of the IConvertible interface for converting from an enumeration value to an integral type, you should use the methods of the Convert class, such as ToInt32, to perform these conversions. В следующем примере показано, как можно использовать GetUnderlyingType метод вместе Convert.ChangeType с методом для преобразования значения перечисления в его базовый тип.The following example illustrates how you can use the GetUnderlyingType method along with the Convert.ChangeType method to convert an enumeration value to its underlying type. Обратите внимание, что в этом примере не требуется, чтобы базовый тип перечисления был известен во время компиляции.Note that this example does not require the underlying type of the enumeration to be known at compile time.

ArrivalStatus status = ArrivalStatus.Early;
var number = Convert.ChangeType(status, Enum.GetUnderlyingType(typeof(ArrivalStatus)));
Console.WriteLine("Converted {0} to {1}", status, number);
// The example displays the following output:
//       Converted Early to 1
Dim status As ArrivalStatus = ArrivalStatus.Early
Dim number = Convert.ChangeType(status, [Enum].GetUnderlyingType(GetType(ArrivalStatus)))
Console.WriteLine("Converted {0} to {1}", status, number)
' The example displays the following output:
'       Converted Early to 1

Синтаксический анализ значений перечисленияParsing enumeration values

Методы Parse иTryParse позволяют преобразовать строковое представление значения перечисления в это значение.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. Строковое представление может быть либо именем, либо базовым значением константы перечисления.The string representation can be either the name or the underlying value of an enumeration constant. Обратите внимание, что методы синтаксического анализа будут успешно преобразовывать строковые представления чисел, которые не являются элементами определенного перечисления, если строки можно преобразовать в значение базового типа перечисления.Note that the parsing methods will successfully convert string representations of numbers that are not members of a particular enumeration if the strings can be converted to a value of the enumeration's underlying type. Чтобы избежать этого, IsDefined можно вызвать метод, чтобы убедиться, что результат метода анализа является допустимым значением перечисления.To prevent this, the IsDefined method can be called to ensure that the result of the parsing method is a valid enumeration value. Пример иллюстрирует этот подход и демонстрирует вызовы Parse(Type, String) методов и. Enum.TryParse<TEnum>(String, TEnum)The example illustrates this approach and demonstrates calls to both the Parse(Type, String) and Enum.TryParse<TEnum>(String, TEnum) methods. Обратите внимание, что неуниверсальный метод анализа возвращает объект, который может потребоваться привести (в C#) или преобразовать (в Visual Basic) к соответствующему типу перечисления.Note that the non-generic parsing method returns an object that you may have to cast (in C#) or convert (in Visual Basic) to the appropriate enumeration type.

string number = "-1";
string name = "Early";

try {
   ArrivalStatus status1 = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), number);
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status1)))
      status1 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", number, status1);
}
catch (FormatException) {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}   
   
ArrivalStatus status2;
if (Enum.TryParse<ArrivalStatus>(name, out status2)) {
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status2)))
      status2 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", name, status2);
}
else {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}
// The example displays the following output:
//       Converted '-1' to Late
//       Converted 'Early' to Early
Dim number As String = "-1"
Dim name As String = "Early"
Dim invalid As String = "32"

Try 
   Dim status1 As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), number), ArrivalStatus)
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status1) Then status1 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", number, status1)
Catch e As FormatException
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End Try   
   
Dim status2 As ArrivalStatus
If [Enum].TryParse(Of ArrivalStatus)(name, status2) Then
   If Not [Enum].IsDefined(GetType(ArrivalStatus), status2) Then status2 = ArrivalStatus.Unknown
   Console.WriteLine("Converted '{0}' to {1}", name, status2)
Else
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number)
End If
' The example displays the following output:
'       Converted '-1' to Late
'       Converted 'Early' to Early

Форматирование значений перечисленияFormatting enumeration values

Можно преобразовать значения перечисления в их строковые представления, вызвав статический Format метод, а также перегрузки метода экземпляра. ToStringYou can convert enumeration values to their string representations by calling the static Format method, as well as the overloads of the instance ToString method. Строку формата можно использовать для управления точным способом представления значения перечисления в виде строки.You can use a format string to control the precise way in which an enumeration value is represented as a string. Дополнительные сведения см. в разделе строки формата перечисления.For more information, see Enumeration Format Strings. В следующем примере используется каждая из поддерживаемых строк формата перечисления ("G" или "g", "d" или "d", "x" или "x", "f" или "f") для преобразования члена ArrivalStatus перечисления в его строковые представления.The following example uses each of the supported enumeration format strings ("G" or "g", "D" or "d", "X" or "x", and "F" or "f" ) to convert a member of the ArrivalStatus enumeration to its string representations.

string[] formats= { "G", "F", "D", "X"};
ArrivalStatus status = ArrivalStatus.Late;
foreach (var fmt in formats)
   Console.WriteLine(status.ToString(fmt));

// The example displays the following output:
//       Late
//       Late
//       -1
//       FFFFFFFF
Dim formats() As String = { "G", "F", "D", "X"}
Dim status As ArrivalStatus = ArrivalStatus.Late
For Each fmt As String In formats
   Console.WriteLine(status.ToString(fmt))
Next
' The example displays the following output:
'       Late
'       Late
'       -1
'       FFFFFFFF

Перебор членов перечисленияIterating enumeration members

C# For Each foreach Тип не IEnumerable<T> реализует интерфейс или, который позволяет выполнять итерацию элементов коллекции с помощью конструкции (in) или (в Visual Basic). IEnumerable EnumThe Enum type does not implement the IEnumerable or IEnumerable<T> interface, which would enable you to iterate members of a collection by using a foreach (in C#) or For Each (in Visual Basic) construct. Однако можно перечислить элементы одним из двух способов.However, you can enumerate members in either of two ways.

  • Можно вызвать GetNames метод, чтобы получить массив строк, содержащий имена членов перечисления.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. Затем для каждого элемента массива строк можно вызвать Parse метод, чтобы преобразовать строку в ее эквивалентное значение перечисления.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. Этот подход показан в приведенном ниже примере.The following example illustrates this approach.

    string[] names = Enum.GetNames(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    Array.Sort(names);
    foreach (var name in names) {
       ArrivalStatus status = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), name);
       Console.WriteLine("   {0} ({0:D})", status);
    }
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          Early (1)
    //          Late (-1)
    //          OnTime (0)
    //          Unknown (-3)      
    
    Dim names() As String = [Enum].GetNames(GetType(ArrivalStatus))
    Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
    Array.Sort(names)
    For Each name In names
       Dim status As ArrivalStatus = CType([Enum].Parse(GetType(ArrivalStatus), name),
                                     ArrivalStatus)
       Console.WriteLine("   {0} ({0:D})", status)
    Next
    ' The example displays the following output:
    '       Members of ArrivalStatus:
    '          Early (1)
    '          Late (-1)
    '          OnTime (0)
    '          Unknown (-3)      
    
  • GetValues Метод можно вызвать для получения массива, содержащего базовые значения в перечислении.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. Затем для каждого элемента массива можно вызвать ToObject метод для преобразования целого числа в эквивалентное ему значение перечисления.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. Этот подход показан в приведенном ниже примере.The following example illustrates this approach.

    var values = Enum.GetValues(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    foreach (ArrivalStatus status in values) {
       Console.WriteLine("   {0} ({0:D})", status);
    }                                       
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    Dim values = [Enum].GetValues(GetType(ArrivalStatus))
    Console.WriteLine("Members of {0}:", GetType(ArrivalStatus).Name)
    For Each value In values
       Dim status As ArrivalStatus = CType([Enum].ToObject(GetType(ArrivalStatus), value),
                                           ArrivalStatus)
       Console.WriteLine("   {0} ({0:D})", status)
    Next                                       
    ' The example displays the following output:
    '       Members of ArrivalStatus:
    '          OnTime (0)
    '          Early (1)
    '          Unknown (-3)
    '          Late (-1)
    

Неисключительные члены и атрибут FlagsNon-exclusive members and the Flags attribute

Одним из распространенных способов использования перечисления является представление набора взаимно исключающих значений.One common use of an enumeration is to represent a set of mutually exclusive values. Например, ArrivalStatus экземпляр может иметь Earlyзначение, OnTimeили Late.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. Не имеет смысла, чтобы значение ArrivalStatus экземпляра отражало более одной константы перечисления.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

Однако в других случаях значение объекта перечисления может включать несколько членов перечисления, а каждый элемент представляет битовое поле в значении перечисления.In other cases, however, the value of an enumeration object can include multiple enumeration members, and each member represents a bit field in the enumeration value. FlagsAttribute Атрибут можно использовать, чтобы указать, что перечисление состоит из битовых полей.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Например, перечисление с Pets именем может использоваться для указания видов Pets в семье.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Его можно определить следующим образом.It can be defined as follows.

[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };

<Flags> Public Enum Pets As Integer
   None = 0
   Dog = 1
   Cat = 2
   Bird = 4
   Rodent = 8
   Reptile = 16
   Other = 32
End Enum

Затем можно использовать перечисление, как показано в следующем примере. PetsThe Pets enumeration can then be used as shown in the following example.

Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets);
// The example displays the following output:
//       Pets: Dog, Cat (3)      
Dim familyPets As Pets = Pets.Dog Or Pets.Cat
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets)
' The example displays the following output:
'       Pets: Dog, Cat (3)      

При определении побитового перечисления и применении FlagsAttribute атрибута следует использовать следующие рекомендации.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • FlagsAttribute Используйте настраиваемый атрибут для перечисления, только если для числового значения требуется выполнить побитовую операцию (and, OR, исключающее или).Use the FlagsAttribute custom attribute for an enumeration only if a bitwise operation (AND, OR, EXCLUSIVE OR) is to be performed on a numeric value.

  • Определите константы перечисления в степени двойки, то есть 1, 2, 4, 8 и т. д.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Это означает, что отдельные флаги в Объединенных константах перечисления не перекрываются.This means the individual flags in combined enumeration constants do not overlap.

  • Рассмотрите возможность создания перечислимой константы для часто используемых сочетаний флагов.Consider creating an enumerated constant for commonly used flag combinations. Например, если имеется перечисление, используемое для операций файлового ввода-вывода, содержащих перечислимые Read = 1 константы и Write = 2, рассмотрите возможность создания ReadWrite = Read OR Writeперечислимой Read константы, Write объединяющей и Метки.For example, if you have an enumeration used for file I/O operations that contains the enumerated constants Read = 1 and Write = 2, consider creating the enumerated constant ReadWrite = Read OR Write, which combines the Read and Write flags. Кроме того, побитовая операция OR, используемая для объединения флагов, может рассматриваться как расширенная концепция в некоторых обстоятельствах, которая не должна требоваться для простых задач.In addition, the bitwise OR operation used to combine the flags might be considered an advanced concept in some circumstances that should not be required for simple tasks.

  • Будьте внимательны при определении отрицательного числа в виде перечислимой константы, так как для множества положений флагов может быть задано значение 1, что может сделать код запутанным и рекомендовать ошибки кода.Use caution if you define a negative number as a flag enumerated constant because many flag positions might be set to 1, which might make your code confusing and encourage coding errors.

  • Чтобы проверить, установлен ли флаг в числовом значении, нужно вызвать метод экземпляра HasFlag , как показано в следующем примере.A convenient way to test whether a flag is set in a numeric value is to call the instance HasFlag method, as shown in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets.HasFlag(Pets.Dog))
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets.HasFlag(Pets.Dog) Then
       Console.WriteLine("The family has a dog.")
    End If
    ' The example displays the following output:
    '       The family has a dog.      
    

    Это эквивалентно выполнению побитовой операции и между числовым значением и константой, перечисленной по флагу, которая устанавливает все биты в числовом значении равными нулю, не соответствующим флагу, а затем проверяет, равен ли результат этой операции свойству отметить константу перечисления.It is equivalent to performing a bitwise AND operation between the numeric value and the flag enumerated constant, which sets all bits in the numeric value to zero that do not correspond to the flag, and then testing whether the result of that operation is equal to the flag enumerated constant. Это показано в следующем примере:This is illustrated in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if ((familyPets & Pets.Dog) == Pets.Dog)
       Console.WriteLine("The family has a dog.");
    // The example displays the following output:
    //       The family has a dog.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets And Pets.Dog = Pets.Dog Then
       Console.WriteLine("The family has a dog.")
    End If   
    ' The example displays the following output:
    '       The family has a dog.      
    
  • Используйте None в качестве имени константы с перечислимым флагом, значение которой равно нулю.Use None as the name of the flag enumerated constant whose value is zero. Нельзя использовать None перечислимую константу в побитовой операции и для проверки флага, так как результат всегда равен нулю.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. Однако можно выполнить логическое, а не побитовое сравнение числового значения и None перечислимой константы, чтобы определить, заданы ли какие-либо биты из числового значения.However, you can perform a logical, not a bitwise, comparison between the numeric value and the None enumerated constant to determine whether any bits in the numeric value are set. Это показано в следующем примере:This is illustrated in the following example.

    Pets familyPets = Pets.Dog | Pets.Cat;
    if (familyPets == Pets.None)
       Console.WriteLine("The family has no pets.");
    else
       Console.WriteLine("The family has pets.");   
    // The example displays the following output:
    //       The family has pets.      
    
    Dim familyPets As Pets = Pets.Dog Or Pets.Cat
    If familyPets = Pets.None Then
       Console.WriteLine("The family has no pets.")
    Else
       Console.WriteLine("The family has pets.")   
    End If
    ' The example displays the following output:
    '       The family has pets.      
    
  • Не определяйте значение перечисления исключительно для отражения состояния самого перечисления.Do not define an enumeration value solely to mirror the state of the enumeration itself. Например, не определяйте константу перечисления, которая только отмечает конец перечисления.For example, do not define an enumerated constant that merely marks the end of the enumeration. Если необходимо определить Последнее значение перечисления, проверьте это значение явным образом.If you need to determine the last value of the enumeration, check for that value explicitly. Кроме того, можно выполнить проверку диапазона для первой и последней перечислимой константы, если все значения в диапазоне допустимы.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

Добавление методов перечисленияAdding enumeration methods

Поскольку типы перечислений определяются языковой структурой enum ,C#например ( Enum ) и (Visual Basic), нельзя определить пользовательские методы для типа перечисления, отличного от методов, Enum унаследованных от класса.Because enumeration types are defined by language structures, such as enum (C#) and Enum (Visual Basic), you cannot define custom methods for an enumeration type other than those methods inherited from the Enum class. Однако методы расширения можно использовать для добавления функциональных возможностей к конкретному типу перечисления.However, you can use extension methods to add functionality to a particular enumeration type.

В следующем примере перечисление Grades содержит возможные буквенные оценки, которые учащийся может получить в классе.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. Метод расширения с именем Passing добавляется в тип Grades, чтобы каждый экземпляр этого типа "знал", проходной это балл или нет.An extension method named Passing is added to the Grades type so that each instance of that type now "knows" whether it represents a passing grade or not. Extensions Класс также содержит статическую переменную для чтения и записи, которая определяет минимальный уровень прохождения.The Extensions class also contains a static read-write variable that defines the minimum passing grade. Возвращаемое значение Passing метода расширения отражает текущее значение этой переменной.The return value of the Passing extension method reflects the current value of that variable.

using System;

// Define an enumeration to represent student grades.
public enum Grades { F = 0, D = 1, C = 2, B = 3, A = 4 };

// Define an extension method for the Grades enumeration.
public static class Extensions
{        
  public static Grades minPassing = Grades.D;

  public static bool Passing(this Grades grade)
  {
      return grade >= minPassing;
  }
}

class Example
{       
  static void Main()
  {
      Grades g1 = Grades.D;
      Grades g2 = Grades.F;
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");

      Extensions.minPassing = Grades.C;
      Console.WriteLine("\nRaising the bar!\n");
      Console.WriteLine("{0} {1} a passing grade.", g1, g1.Passing() ? "is" : "is not");
      Console.WriteLine("{0} {1} a passing grade.", g2, g2.Passing() ? "is" : "is not");
  }
}
// The exmaple displays the following output:
//       D is a passing grade.
//       F is not a passing grade.
//       
//       Raising the bar!
//       
//       D is not a passing grade.
//       F is not a passing grade.
Imports System.Runtime.CompilerServices

' Define an enumeration to represent student grades.
Public Enum Grades As Integer
   F = 0
   D = 1
   C = 2
   B = 3
   A = 4
End Enum   

' Define an extension method for the Grades enumeration.
Public Module Extensions
  Public minPassing As Grades = Grades.D
 
  <Extension>
  Public Function Passing(grade As Grades) As Boolean
     Return grade >= minPassing
  End Function
End Module

Public Module Example
  Public Sub Main()
      Dim g1 As Grades = Grades.D
      Dim g2 As Grades = Grades.F
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
      Console.WriteLine()
      
      Extensions.minPassing = Grades.C
      Console.WriteLine("Raising the bar!")
      Console.WriteLine()
      Console.WriteLine("{0} {1} a passing grade.", 
                        g1, If(g1.Passing(), "is", "is not"))
      Console.WriteLine("{0} {1} a passing grade.", 
                        g2, If(g2.Passing(), "is", "is not"))
  End Sub
End Module
' The exmaple displays the following output:
'       D is a passing grade.
'       F is not a passing grade.
'       
'       Raising the bar!
'       
'       D is not a passing grade.
'       F is not a passing grade.

Конструкторы

Enum()

Инициализирует новый экземпляр класса Enum.Initializes a new instance of the Enum class.

Методы

CompareTo(Object)

Сравнивает этот экземпляр с заданным объектом и возвращает значение, указывающее, как соотносятся значения этих объектов.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Возвращает значение, показывающее, равен ли данный экземпляр заданному объекту.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Преобразует указанное значение заданного перечислимого типа в эквивалентное строковое представление в соответствии с заданным форматом.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Возвращает хэш-код для значения данного экземпляра.Returns the hash code for the value of this instance.

GetName(Type, Object)

Возвращает имя константы с заданным значением из указанного перечисления.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Возвращает массив имен констант в указанном перечислении.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

(Унаследовано от Object)
GetTypeCode()

Возвращает код типа базового типа члена этого перечисления.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Возвращает базовый тип заданного перечисления.Returns the underlying type of the specified enumeration.

GetValues(Type)

Возвращает массив значений констант в указанном перечислении.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Определяет, установлены ли в текущем экземпляре одно или несколько битовых полей.Determines whether one or more bit fields are set in the current instance.

IsDefined(Type, Object)

Возвращает логическое значение, указывающее, существует ли заданное целочисленное значение или его имя в виде строки в заданном перечислении.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

(Унаследовано от Object)
Parse(Type, String)

Преобразует строковое представление имени или числового значения одной или нескольких перечислимых констант в эквивалентный перечислимый объект.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

Parse(Type, String, Boolean)

Преобразует строковое представление имени или числового значения одной или нескольких перечислимых констант в эквивалентный перечислимый объект.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Параметр указывает, учитывается ли в операции регистр.A parameter specifies whether the operation is case-insensitive.

Parse<TEnum>(String)
Parse<TEnum>(String, Boolean)
ToObject(Type, Byte)

Преобразует значение заданного 8-разрядного целого числа в член перечисления.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Преобразует значение заданного 16-разрядного знакового целого числа в член перечисления.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Преобразует значение заданного 32-разрядного знакового целого числа в член перечисления.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Преобразует значение заданного 64-разрядного знакового целого числа в член перечисления.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Преобразует заданный объект с целочисленным значением в член перечисления.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Преобразует значение заданного 8-разрядного знакового целого числа в член перечисления.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Преобразует значение заданного 16-разрядного целого числа без знака в член перечисления.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Преобразует значение заданного 32-разрядного целого числа без знака в член перечисления.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Преобразует значение заданного 64-разрядного целого числа без знака в член перечисления.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Преобразует значение этого экземпляра в эквивалентное ему строковое представление.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

Перегруженная версия метода является устаревшей, вместо нее следует использовать метод ToString().This method overload is obsolete; use ToString().

ToString(String)

Преобразует числовое значение этого экземпляра в эквивалентное ему строковое представление с использованием указанного формата.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

Эта перегрузка метода является устаревшей. Используйте ToString(String).This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)
TryParse(Type, String, Object)
TryParse<TEnum>(String, Boolean, TEnum)

Преобразует строковое представление имени или числового значения одной или нескольких перечислимых констант в эквивалентный перечислимый объект.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Параметр указывает, учитывается ли в операции регистр.A parameter specifies whether the operation is case-sensitive. Возвращаемое значение указывает, успешно ли выполнено преобразование.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Преобразует строковое представление имени или числового значения одной или нескольких перечислимых констант в эквивалентный перечислимый объект.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Возвращаемое значение указывает, успешно ли выполнено преобразование.The return value indicates whether the conversion succeeded.

Явные реализации интерфейса

IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider)

Преобразует текущее значение в логическое значение на основе его базового типа.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Преобразует текущее значение в 8-битовое целое число без знака на основе базового типа.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Преобразует текущее значение в символ Юникода на основе его базового типа.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Преобразует текущее значение в значение типа DateTime на основе его базового типа.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Преобразует текущее значение в значение типа Decimal на основе его базового типа.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Преобразует текущее значение объекта в число двойной точности с плавающей запятой на основе его базового типа.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Преобразует текущее значение в 16-битовое целое число со знаком на основе его базового типа.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Преобразует текущее значение в 32-битовое целое число со знаком на основе его базового типа.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Преобразует текущее значение в 64-битовое целое число со знаком на основе его базового типа.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Преобразует текущее значение в 8-битовое целое число со знаком на основе его базового типа.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Преобразует текущее значение в число с плавающей запятой одиночной точности на основе его базового типа.Converts the current value to a single-precision floating-point number based on the underlying type.

IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider)

Преобразует текущее значение к заданному типу на основе его базового типа.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Преобразует текущее значение в 16-битовое целое число без знака на основе его базового типа.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Преобразует текущее значение в 32-битовое целое число без знака на основе его базового типа.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Преобразует текущее значение в 64-битовое целое число без знака на основе его базового типа.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

Эта перегрузка метода является устаревшей. Используйте ToString(String).This method overload is obsolete; use ToString(String).

Применяется к

Потокобезопасность

Данный тип потокобезопасен.This type is thread safe.

Дополнительно