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. 列挙型は、C#のenumキーワードとVisual BasicのEnum...End Enum構造で定義します。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
非排他的メンバーと Flags 属性Non-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.EarlyArrivalStatus.OnTime、およびArrivalStatus.Lateの3つのメンバーを持つArrivalStatusという名前の列挙体を作成します。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

他の値型をインスタンス化する場合と同様に、列挙型をインスタンス化するには、変数を宣言し、列挙型の定数の 1 つを割り当てます。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.OnTimeであるArrivalStatusをインスタンス化する例を次に示します。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.Early値を持つArrivalStatusオブジェクトを作成します。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. 既定では、列挙体に使用されるメモリは、共通言語ランタイムによって 0 に初期化されます。By default, the memory used for the enumeration is initialized to zero by the common language runtime. その結果、値が 0 である定数を定義しなかった場合、列挙体の作成時に無効な値が含まれます。Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • アプリケーションで表現する必要がある明確な既定のケースがある場合は、それを表すために値が0である列挙定数を使用することを検討してください。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. 既定のケースが存在しない場合は、その他の列挙定数で表されないケースを指定するために、値が0である列挙定数を使用することを検討してください。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.

定数がビットフィールドである列挙型のその他のベストプラクティスについては、「非排他的メンバーとフラグ属性」セクションに記載されています。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#) または変換 ( 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) 、メソッドを使用して、Int32ArrivalStatus値に変換します。The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. ToObjectObject型の値を返すため、キャスト演算子または変換演算子が、オブジェクトを列挙型にキャストするために必要になる場合があることに注意してください。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インターフェイスの明示的なインターフェイス実装が用意されていますが、ToInt32などのConvertクラスのメソッドを使用して、これらの変換を実行することをお勧めします。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. 非ジェネリックの Parse メソッドは、適切な列挙型にキャスト (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 メソッドを呼び出すことによって列挙値を文字列形式に変換したり、インスタンス ToString メソッドのオーバーロードを呼び出したりすることができます。You 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

Enum型は、foreach(C#) またはFor Each(Visual Basic) 構造を使用してコレクションのメンバーを反復処理するための、IEnumerableまたはIEnumerable<T>インターフェイスを実装していません。The 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. ただし、次の 2 つの方法のいずれかでメンバーを列挙できます。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)
    

非排他的メンバーと Flags 属性Non-exclusive members and the Flags attribute

列挙型の一般的な用途の 1 つは、相互に排他的な値のセットを表すことです。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という名前の列挙体を使用して、家族のペットの種類を示すことができます。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

Pets列挙体は、次の例に示すように使用できます。The 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.

  • 数値に対してビットごとの演算 (AND、OR、EXCLUSIVE OR) を実行する場合にのみ、列挙体のFlagsAttributeカスタム属性を使用します。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 など、2 の累乗で列挙定数を定義します。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 = 1Write = 2を含むファイル I/O 操作に使用する列挙体がある場合、ReadWriteを組み合わせたReadWrite = Read OR 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.      
    

    これは、数値とフラグで列挙される定数の間でビットごとの AND 演算を実行することと同じです。この場合、数値のすべてのビットをフラグに対応しないゼロに設定し、その操作の結果がフラグ列挙定数と等しいかどうかをテストします。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.      
    
  • 値が 0 であるフラグ列挙定数の名前としてNoneを使用します。Use None as the name of the flag enumerated constant whose value is zero. ビットごとの and 演算では、結果が常に0であるため、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)

現在のインスタンスで 1 つ以上のビット フィールドが設定されているかどうかを判断します。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)

文字列形式での 1 つ以上の列挙定数の名前または数値を、等価の列挙オブジェクトに変換します。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)

文字列形式での 1 つ以上の列挙定数の名前または数値を、等価の列挙オブジェクトに変換します。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)

文字列形式での 1 つ以上の列挙定数の名前または数値を、等価の列挙オブジェクトに変換します。Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

TryParse(Type, String, Object)

文字列形式での 1 つ以上の列挙定数の名前または数値を、等価の列挙オブジェクトに変換します。Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object.

TryParse<TEnum>(String, Boolean, TEnum)

文字列形式での 1 つ以上の列挙定数の名前または数値を、等価の列挙オブジェクトに変換します。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)

文字列形式での 1 つ以上の列挙定数の名前または数値を、等価の列挙オブジェクトに変換します。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)

基になる型に基づいて、現在の値を Unicode 文字に変換します。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.

こちらもご覧ください