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. 자세한 내용은 참조는 비독점적 멤버 및 플래그 특성 섹션 및 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
비독점적 멤버 및 플래그 특성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 멤버가 세: ArrivalStatus.EarlyArrivalStatus.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. 리플렉션을 사용 하 여 이러한 열거형을 만들 수 있습니다, 있지만 메서드 호출 결과 유형을 사용 하는 신뢰할 수 없는 및 추가 예외를 throw 할 수 있습니다.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. 기본적으로 열거형에 사용 되는 메모리를 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. 때문에 합니다 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

합니다 ParseTryParse 메서드를 사용 하는 열거형 값의 문자열 표현을 해당 값으로 변환할 수 있습니다.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. Note는 제네릭이 아닌 구문 분석 메서드에서 캐스팅 (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 형식을 구현 하지 않습니다는 IEnumerable 또는 IEnumerable<T> 인터페이스를 사용 하 여 컬렉션의 멤버를 반복 하는 데 사용할 수는 foreach (C#의 경우)의 또는 For Each (Visual Basic)의 생성 합니다.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. 그러나 두 가지 방법 중 하나에서 멤버를 열거할 수 있습니다.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)
    

비독점적 멤버 및 플래그 특성Non-exclusive members and the Flags attribute

열거형의 일반적 용도 중 하나를 상호 배타적인 값의 집합을 나타내는 경우One common use of an enumeration is to represent a set of mutually exclusive values. 예를 들어를 ArrivalStatus 인스턴스는 값을 가질 수 있습니다 EarlyOnTime, 또는 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.

  • 사용 된 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 등에 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. 예를 들어, 파일 I/O 작업에 사용 되는 열거형을 사용 하는 경우 포함 하는 열거형된 상수 Read = 1 하 고 Write = 2, 열거 된 상수를 만드는 것이 좋습니다 ReadWrite = Read OR Write를 결합 하는 합니다 ReadWrite 플래그입니다.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.      
    

    플래그 열거형된 상수 플래그에 해당 하지 않는 0으로 숫자 값에서 모든 비트를 설정 하는 숫자 값 사이 비트 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.      
    
  • 사용 하 여 None 열거형 상수의 값이 0 인 플래그의 이름으로 합니다.Use None as the name of the flag enumerated constant whose value is zero. 사용할 수 없습니다는 None 결과 항상 0 때문에 플래그를 테스트 하려면 비트 AND 연산의 열거 된 상수입니다.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.

추가 정보