Enum Sınıf

Tanım

Numaralandırmalar için temel sınıf sağlar.Provides the base class for enumerations.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
[System.Serializable]
public abstract class Enum : 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
Devralma
Türetilmiş
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek, adlandırılmış değerleri ve adlandırılmış bit alanlarını temsil eden başka bir numaralandırmayı göstermek için bir numaralandırma kullanmayı gösterir.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 

Açıklamalar

Sabit listesi, temel alınan türü herhangi bir integral türü olan adlandırılmış sabitler kümesidir.An enumeration is a set of named constants whose underlying type is any integral type. Açıkça bildirilmemiş bir tür yoksa Int32 kullanılır.If no underlying type is explicitly declared, Int32 is used. Enum, .NET Framework tüm Numaralandırmalar için temel sınıftır.Enum is the base class for all enumerations in the .NET Framework. Numaralandırma türleri, içindeki C# enum anahtar sözcüğü ve Visual Basic içinde Enum...End Enum yapısı tarafından tanımlanır.Enumeration types are defined by the enum keyword in C# and the Enum...End Enum construct in Visual Basic.

Enum, bu sınıfın örneklerini karşılaştırmak, bir örneğin değerini dize gösterimine dönüştürmek, bir sayının dize gösterimini bu sınıfın örneğine dönüştürmek ve belirtilen bir numaralandırma ve değerin bir örneğini oluşturmak için yöntemler sağlar.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.

Bir numaralandırmayı bir bit alanı olarak da kullanabilirsiniz.You can also treat an enumeration as a bit field. Daha fazla bilgi için, özel olmayan üyeler ve Flags özniteliği bölümüne ve FlagsAttribute konusuna bakın.For more information, see the Non-Exclusive Members and the Flags Attribute section and the FlagsAttribute topic.

Bu konuda:In this topic:

Sabit listesi türü oluşturma Creating an enumeration type
Sabit listesi türünü örnekleme Instantiating an enumeration type
Numaralandırma en iyi uygulamaları Enumeration best practices
Numaralandırmalar Işlemler gerçekleştiriliyorPerforming operations with enumerations
Dönüşümler gerçekleştiriliyorPerforming conversions
Numaralandırma değerlerini ayrıştırmaParsing enumeration values
Numaralandırma değerlerini biçimlendirmeFormatting enumeration values
Sabit listesi üyelerini yinelemeIterating enumeration members
Dışlayıcı olmayan üyeler ve Flags özniteliğiNon-exclusive members and the Flags attribute
Numaralandırma yöntemleri eklemeAdding enumeration methods

Sabit listesi türü oluşturmaCreating an enumeration type

Programlama dilleri genellikle bir dizi adlandırılmış sabitten ve bunların değerlerinden oluşan bir numaralandırma bildirmek için sözdizimi sağlar.Programming languages typically provide syntax to declare an enumeration that consists of a set of named constants and their values. Aşağıdaki örnek, tarafından C# kullanılan ve bir numaralandırma tanımlamak için Visual Basic söz dizimini gösterir.The following example illustrates the syntax used by C# and Visual Basic to define an enumeration. Üç üyeye sahip ArrivalStatus adlı bir sabit listesi oluşturur: ArrivalStatus.Early, ArrivalStatus.OnTimeve ArrivalStatus.Late.It creates an enumeration named ArrivalStatus that has three members: ArrivalStatus.Early, ArrivalStatus.OnTime, and ArrivalStatus.Late. Her iki durumda da, numaralandırmanın açıkça Enumbir şekilde devralma olduğunu unutmayın. devralma ilişkisi, derleyici tarafından örtük olarak işlenir.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

Uyarı

Temel türü İntegral olmayan veya Charolan bir numaralandırma türü oluşturmanız gerekir.You should never create an enumeration type whose underlying type is non-integral or Char. Yansıma kullanarak böyle bir numaralandırma türü oluşturabilseniz de, sonuçta elde edilen türü kullanan Yöntem çağrıları güvenilir değildir ve ek durumlar da oluşturabilir.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.

Sabit listesi türünü örneklemeInstantiating an enumeration type

Diğer değer türlerini örnekleyerek, bir değişken bildirerek ve numaralandırmanın sabitlerinden birini ona atayarak, bir sabit listesi türü örneğini oluşturabilirsiniz.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. Aşağıdaki örnek, değeri ArrivalStatus.OnTimeolan bir ArrivalStatus örnekleyen.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)

Ayrıca, aşağıdaki yollarla bir numaralandırma değeri örneği oluşturabilirsiniz:You can also instantiate an enumeration value in the following ways:

  • Belirli bir programlama dilinin özelliklerini (içinde C#olduğu gibi) veya dönüştürmek için (Visual Basic olarak) bir numaralandırma değerine bir tamsayı değeri kullanarak.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. Aşağıdaki örnek, değeri bu şekilde ArrivalStatus.Early olan bir ArrivalStatus nesnesi oluşturur.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)
    
  • Örtük parametresiz oluşturucuyu çağırarak.By calling its implicit parameterless constructor. Aşağıdaki örnekte gösterildiği gibi, bu durumda numaralandırma örneğinin temel alınan değeri 0 ' dır.As the following example shows, in this case the underlying value of the enumeration instance is 0. Ancak, bu, Numaralandırmadaki geçerli bir sabitin değeri değildir.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 veya TryParse yöntemini çağırarak, Numaralandırmadaki bir sabit adını içeren bir dizeyi ayrıştırarak.By calling the Parse or TryParse method to parse a string that contains the name of a constant in the enumeration. Daha fazla bilgi için bkz. numaralandırma değerlerini ayrıştırma bölümü.For more information, see the Parsing Enumeration Values section.

  • Bir integral değeri bir numaralandırma türüne dönüştürmek için ToObject yöntemini çağırarak.By calling the ToObject method to convert an integral value to an enumeration type. Daha fazla bilgi için dönüşümler gerçekleştiriliyor bölümüne bakın.For more information, see the Performing Conversions section.

Numaralandırma en iyi uygulamalarıEnumeration best practices

Numaralandırma türlerini tanımlarken aşağıdaki en iyi yöntemleri kullanmanızı öneririz:We recommend that you use the following best practices when you define enumeration types:

  • Değeri 0 olan bir numaralandırma üyesi tanımlamadıysanız, numaralandırılmış bir None sabiti oluşturmayı düşünün.If you have not defined an enumeration member whose value is 0, consider creating a None enumerated constant. Varsayılan olarak, numaralandırma için kullanılan bellek ortak dil çalışma zamanı tarafından sıfır olarak başlatılır.By default, the memory used for the enumeration is initialized to zero by the common language runtime. Sonuç olarak, değeri sıfır olan bir sabit tanımlamadıysanız, sabit listesi oluşturulduğunda geçersiz bir değer içerir.Consequently, if you do not define a constant whose value is zero, the enumeration will contain an illegal value when it is created.

  • Uygulamanızın temsil etmesi gereken belirgin bir varsayılan durum varsa, bu değeri temsil etmek için sıfır olan numaralandırılmış bir sabiti kullanmayı düşünün.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. Varsayılan bir durum yoksa, numaralandırılmış bir sabit değeri, Diğer numaralandırılan sabitlerden herhangi biri tarafından temsil edilmeyen durumu belirtmek için sıfır olan bir sabit kullanmayı düşünün.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.

  • Gelecekte kullanılmak üzere ayrılmış numaralandırılmış sabitleri belirtmeyin.Do not specify enumerated constants that are reserved for future use.

  • Değer olarak numaralandırılmış bir sabiti alan bir yöntem veya özellik tanımladığınızda, değeri doğrulamayı düşünün.When you define a method or property that takes an enumerated constant as a value, consider validating the value. Bunun nedeni, sayısal değer numaralandırmada tanımlanmasa bile, sayısal bir değeri numaralandırma türüne çevirebilirsiniz.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.

Sabitleri bit alanları olan sabit listesi türleri için ek en iyi uygulamalar, özel olmayan üyeler ve Flags özniteliği bölümünde listelenmiştir.Additional best practices for enumeration types whose constants are bit fields are listed in the Non-Exclusive Members and the Flags Attribute section.

Numaralandırmalar ile işlem gerçekleştirmePerforming operations with enumerations

Bir numaralandırma oluştururken yeni yöntemler tanımlayamazsınız.You cannot define new methods when you are creating an enumeration. Ancak, bir numaralandırma türü Enum sınıfından bir dizi statik ve örnek yöntemi devralır.However, an enumeration type inherits a complete set of static and instance methods from the Enum class. Aşağıdaki bölümler, numaralandırma değerleriyle çalışırken yaygın olarak kullanılan birkaç diğer yönteme ek olarak bu yöntemlerin büyük bir bölümünü anketine sağlar.The following sections survey most of these methods, in addition to several other methods that are commonly used when working with enumeration values.

Dönüşümler gerçekleştiriliyorPerforming conversions

Atama (ın C#) veya dönüştürme (Visual Basic) işleci kullanarak bir numaralandırma üyesi ve temel alınan türü arasında dönüştürme yapabilirsiniz.You can convert between an enumeration member and its underlying type by using a casting (in C#) or conversion (in Visual Basic) operator. Aşağıdaki örnek, hem bir tamsayının hem de bir sabit listesi değerinden bir tamsayıya bir tamsayıya dönüştürme gerçekleştirmek için atama veya dönüştürme işleçlerini kullanır.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 sınıfı, herhangi bir integral türünün değerini bir numaralandırma değerine dönüştüren bir ToObject yöntemi de içerir.The Enum class also includes a ToObject method that converts a value of any integral type to an enumeration value. Aşağıdaki örnek, bir Int32 ArrivalStatus değerine dönüştürmek için ToObject(Type, Int32) yöntemini kullanır.The following example uses the ToObject(Type, Int32) method to convert an Int32 to an ArrivalStatus value. ToObject, Objecttüründe bir değer döndürdüğünden, bir atama ya da dönüştürme işlecinin kullanımını yine de nesneyi numaralandırma türüne dönüştürmek için gerekli olabileceğini unutmayın.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)

Bir tamsayıyı bir numaralandırma değerine dönüştürürken, gerçekte numaralandırmanın bir üyesi olmayan bir değer atamak mümkündür.When converting an integer to an enumeration value, it is possible to assign a value that is not actually a member of the enumeration. Bunu engellemek için, dönüştürme işlemini gerçekleştirmeden önce tamsayıyı IsDefined yöntemine geçirebilirsiniz.To prevent this, you can pass the integer to the IsDefined method before performing the conversion. Aşağıdaki örnek, bir tamsayı değerleri dizisindeki öğelerin ArrivalStatus değerlere dönüştürülemeyeceğini anlamak için bu yöntemi kullanır.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 sınıfı, bir numaralandırma değerinden tamsayı türüne dönüştürmek için IConvertible arabiriminin açık arabirim uygulamalarını sağlasa da, bu dönüşümleri gerçekleştirmek için ToInt32gibi Convert sınıfının yöntemlerini kullanmanız gerekir.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. Aşağıdaki örnek, bir numaralandırma değerini temel türüne dönüştürmek için GetUnderlyingType yöntemini Convert.ChangeType yöntemi ile birlikte nasıl kullanabileceğinizi gösterir.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. Bu örneğin, derleme zamanında bilinmeye yönelik numaralandırmanın temel alınan türünü gerektirmediğini unutmayın.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

Numaralandırma değerlerini ayrıştırmaParsing enumeration values

Parse ve TryParse yöntemleri, bir numaralandırma değerinin dize gösterimini bu değere dönüştürmenize olanak sağlar.The Parse and TryParse methods allow you to convert the string representation of an enumeration value to that value. Dize temsili, bir sabit listesi sabitinin adı ya da temel alınan değeri olabilir.The string representation can be either the name or the underlying value of an enumeration constant. Ayrıştırma yöntemlerinin, dizeler numaralandırmanın temel alınan türünün bir değerine dönüştürülebileceğinden, belirli bir numaralandırmanın üyesi olmayan sayıların dize gösterimlerini başarıyla dönüştürdüğüne unutmayın.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. Bunu engellemek için, ayrıştırma yönteminin sonucunun geçerli bir sabit listesi değeri olduğundan emin olmak için IsDefined yöntemi çağrılabilir.To prevent this, the IsDefined method can be called to ensure that the result of the parsing method is a valid enumeration value. Örnekte bu yaklaşım gösterilmektedir ve hem Parse(Type, String) hem de Enum.TryParse<TEnum>(String, TEnum) yöntemlerine yapılan çağrılar gösterilmektedir.The example illustrates this approach and demonstrates calls to both the Parse(Type, String) and Enum.TryParse<TEnum>(String, TEnum) methods. Genel olmayan ayrıştırma yönteminin, uygun numaralandırma türüne (içinde C#) veya dönüştürmeniz gereken (Visual Basic) bir nesne döndürdüğünü unutmayın.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

Numaralandırma değerlerini biçimlendirmeFormatting enumeration values

Statik Format yönteminin yanı sıra örnek ToString yönteminin aşırı yüklerini çağırarak numaralandırma değerlerini dize temsillerine dönüştürebilirsiniz.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. Bir numaralandırma değerinin bir dize olarak temsil edildiği kesin yolu denetlemek için bir biçim dizesi kullanabilirsiniz.You can use a format string to control the precise way in which an enumeration value is represented as a string. Daha fazla bilgi için bkz. numaralandırma biçim dizeleri.For more information, see Enumeration Format Strings. Aşağıdaki örnek, ArrivalStatus numaralandırmasının bir üyesini dize temsillerine dönüştürmek için desteklenen numaralandırma biçim dizelerini ("G" veya "g", "D" veya "d", "X" veya "x" ve "f" ya da "f") kullanır.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

Sabit listesi üyelerini yinelemeIterating enumeration members

Enum türü IEnumerable veya IEnumerable<T> arabirimini uygulamaz; bu, bir koleksiyonun üyelerini bir foreach (ın C#) veya For Each (Visual Basic) yapısıyla yinelemenize olanak tanır.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. Ancak, üyeleri iki şekilde sıralayabilirsiniz.However, you can enumerate members in either of two ways.

  • Numaralandırma üyelerinin adlarını içeren bir dize dizisini almak için GetNames yöntemini çağırabilirsiniz.You can call the GetNames method to retrieve a string array containing the names of the enumeration members. Sonra, dize dizisinin her öğesi için, dizeyi eşdeğer numaralandırma değerine dönüştürmek üzere Parse yöntemini çağırabilirsiniz.Next, for each element of the string array, you can call the Parse method to convert the string to its equivalent enumeration value. Aşağıdaki örnek bu yaklaşımı gösterir.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)      
    
  • Numaralandırmadaki temel değerleri içeren bir diziyi almak için GetValues yöntemini çağırabilirsiniz.You can call the GetValues method to retrieve an array that contains the underlying values in the enumeration. Sonra, dizideki her öğe için, tamsayıyı eşdeğer numaralandırma değerine dönüştürmek üzere ToObject yöntemini çağırabilirsiniz.Next, for each element of the array, you can call the ToObject method to convert the integer to its equivalent enumeration value. Aşağıdaki örnek bu yaklaşımı gösterir.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)
    

Dışlayıcı olmayan üyeler ve Flags özniteliğiNon-exclusive members and the Flags attribute

Bir numaralandırmanın yaygın olarak kullanılması birbirini dışlayan değerlerin bir kümesini temsil etmektedir.One common use of an enumeration is to represent a set of mutually exclusive values. Örneğin, bir ArrivalStatus örneği Early, OnTimeveya Latebir değere sahip olabilir.For example, an ArrivalStatus instance can have a value of Early, OnTime, or Late. Bir ArrivalStatus örneğinin değerini birden fazla numaralandırma sabitini yansıtacak şekilde bir fikir vermez.It makes no sense for the value of an ArrivalStatus instance to reflect more than one enumeration constant.

Ancak, diğer durumlarda, bir numaralandırma nesnesinin değeri birden çok numaralandırma üyesi içerebilir ve her üye sabit listesi değerindeki bir bit alanını temsil eder.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 özniteliği, numaralandırmanın bit alanlarından oluştuğunu göstermek için kullanılabilir.The FlagsAttribute attribute can be used to indicate that the enumeration consists of bit fields. Örneğin, Pets adlı bir sabit listesi, bir evdeki evcil hayvan türlerini belirtmek için kullanılabilir.For example, an enumeration named Pets might be used to indicate the kinds of pets in a household. Bu, aşağıdaki şekilde tanımlanabilir.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 numaralandırması daha sonra aşağıdaki örnekte gösterildiği gibi kullanılabilir.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)      

Aşağıdaki en iyi yöntemler bit düzeyinde bir numaralandırma tanımlarken ve FlagsAttribute özniteliği uygulanırken kullanılmalıdır.The following best practices should be used when defining a bitwise enumeration and applying the FlagsAttribute attribute.

  • Bir numaralandırma için FlagsAttribute özel özniteliğini yalnızca bir sayısal değerde bit düzeyinde bir işlem (ve, ya da DıŞLAMALı veya) gerçekleştirilmesi durumunda kullanın.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.

  • Numaralandırma sabitlerini iki, 1, 2, 4, 8, vb. üslerinde tanımlayın.Define enumeration constants in powers of two, that is, 1, 2, 4, 8, and so on. Bu, Birleşik numaralandırma sabitlerinde bireysel bayrakların çakışmayacağı anlamına gelir.This means the individual flags in combined enumeration constants do not overlap.

  • Yaygın olarak kullanılan bayrak birleşimleri için numaralandırılmış bir sabit oluşturmayı düşünün.Consider creating an enumerated constant for commonly used flag combinations. Örneğin, numaralandırılmış sabitleri içeren dosya g/ç işlemleri için kullanılan bir sabit listesi varsa Read = 1 ve Write = 2, Read ve Write bayraklarını birleştiren numaralandırılmış sabit ReadWrite = Read OR Writeoluşturmayı düşünün.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. Ayrıca, bayrakları birleştirmek için kullanılan bit düzeyinde OR işlemi, basit görevler için gerekli olmaması gereken bazı koşullarda gelişmiş bir kavram olarak düşünülebilir.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.

  • Çok sayıda bayrak konumu 1 olarak ayarlanabileceğinden, kodunuzun kafa karıştırıcı ve kodlama hatalarını önerme biçiminde negatif bir sayı olarak sayıldıysanız dikkatli olun.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.

  • Aşağıdaki örnekte gösterildiği gibi, bir sayısal HasFlag değerde bir bayrağın ayarlanmış olup olmadığını test etmek için uygun bir yoldur.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.      
    

    Sayısal değer ve numaralandırılabilen bayrak arasında bir bit düzeyinde AND işlemi gerçekleştirmeye eşdeğerdir. Bu, sayısal değer içindeki tüm bitleri bayrağa karşılık gelen sıfıra, sonra da bu işlemin sonucunun şuna eşit olup olmadığını test ediyor. numaralandırılmış sabit bayrak.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. Bu, aşağıdaki örnekte gösterilmiştir.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.      
    
  • Değeri sıfır olan numaralandırılan sabit bayrak adı olarak None kullanın.Use None as the name of the flag enumerated constant whose value is zero. Sonuç her zaman sıfır olduğundan, bir bayrağı test etmek için, bir bit düzeyinde ve işlem için numaralandırılmış sabit None kullanamazsınız.You cannot use the None enumerated constant in a bitwise AND operation to test for a flag because the result is always zero. Bununla birlikte, sayısal değerde bir bit tabanlı değil, sayısal değer ve numaralandırılmış sabit None arasında bir karşılaştırma yapabilirsiniz.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. Bu, aşağıdaki örnekte gösterilmiştir.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.      
    
  • Yalnızca numaralandırmanın durumunu yansıtmak için bir numaralandırma değeri tanımlamayın.Do not define an enumeration value solely to mirror the state of the enumeration itself. Örneğin, yalnızca sabit listesinin sonunu işaretleyen numaralandırılmış bir sabit tanımlamayın.For example, do not define an enumerated constant that merely marks the end of the enumeration. Sabit listesinin son değerini belirlemeniz gerekiyorsa, bu değeri açık olarak denetleyin.If you need to determine the last value of the enumeration, check for that value explicitly. Ayrıca, Aralık içindeki tüm değerler geçerliyse, ilk ve son numaralandırılan sabit sabiti için bir Aralık denetimi yapabilirsiniz.In addition, you can perform a range check for the first and last enumerated constant if all values within the range are valid.

Numaralandırma yöntemleri eklemeAdding enumeration methods

Numaralandırma türleri enum (C#) ve Enum (Visual Basic) gibi dil yapıları tarafından tanımlandığından, Enum sınıfından devralınan yöntemlerin dışında bir numaralandırma türü için özel yöntemler tanımlayamazsınız.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. Ancak, belirli bir numaralandırma türüne işlevsellik eklemek için uzantı yöntemlerini kullanabilirsiniz.However, you can use extension methods to add functionality to a particular enumeration type.

Aşağıdaki örnekte Grades numaralandırması, bir öğrencinin bir sınıfta alabileceği olası harf çalışmalarını temsil eder.In the following example, the Grades enumeration represents the possible letter grades that a student may receive in a class. Passing adlı bir genişletme yöntemi Grades türüne eklenir, böylece bu türün her örneği, bir geçen sınıfı temsil edip etmediğini "bilir".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 sınıfı, en düşük geçen sınıfı tanımlayan statik bir okuma-yazma değişkeni de içerir.The Extensions class also contains a static read-write variable that defines the minimum passing grade. Passing uzantısı yönteminin dönüş değeri, bu değişkenin geçerli değerini yansıtır.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.

Oluşturucular

Enum()

Yeni bir örneğini başlatır Enum sınıfı.Initializes a new instance of the Enum class.

Yöntemler

CompareTo(Object)

Bu örneği belirtilen nesne ile karşılaştırır ve göreli değerlerin bir göstergesini döndürür.Compares this instance to a specified object and returns an indication of their relative values.

Equals(Object)

Bu örneğin, belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür.Returns a value indicating whether this instance is equal to a specified object.

Format(Type, Object, String)

Belirtilen bir numaralandırılmış türün belirtilen değerini, belirtilen biçime göre eşdeğer dize gösterimine dönüştürür.Converts the specified value of a specified enumerated type to its equivalent string representation according to the specified format.

GetHashCode()

Bu örneğin değeri için karma kodu döndürür.Returns the hash code for the value of this instance.

GetName(Type, Object)

Belirtilen sabit listesinden belirtilen değere sahip olan sabitin adını alır.Retrieves the name of the constant in the specified enumeration that has the specified value.

GetNames(Type)

Belirtilen bir Numaralandırmadaki sabitlerin adlarından oluşan bir diziyi alır.Retrieves an array of the names of the constants in a specified enumeration.

GetType()

Geçerli örneğin Type alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
GetTypeCode()

Bu numaralandırma üyesinin temel alınan türünün tür kodunu döndürür.Returns the type code of the underlying type of this enumeration member.

GetUnderlyingType(Type)

Belirtilen numaralandırmanın temel alınan türünü döndürür.Returns the underlying type of the specified enumeration.

GetValues(Type)

Belirtilen bir Numaralandırmadaki sabitlerin değerlerinin dizisini alır.Retrieves an array of the values of the constants in a specified enumeration.

HasFlag(Enum)

Geçerli örnekte bir veya daha fazla bit alanının ayarlanmış olup olmadığını belirler.Determines whether one or more bit fields are set in the current instance.

IsDefined(Type, Object)

Belirli bir tamsayı değerinin veya bunun adının bir dize olarak belirtilen bir numaralandırmada mevcut olup olmadığını belirten bir Boole değeri döndürür.Returns a Boolean telling whether a given integral value, or its name as a string, exists in a specified enumeration.

MemberwiseClone()

Geçerli Objectbasit bir kopyasını oluşturur.Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
Parse(Type, String)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin dize gösterimini numaralandırılmış eşdeğer bir nesneye dönüştürür.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)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin dize gösterimini numaralandırılmış eşdeğer bir nesneye dönüştürür.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Bir parametre, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir.A parameter specifies whether the operation is case-insensitive.

Parse<TEnum>(String)

TEnum tarafından belirtilen bir veya daha fazla numaralandırılmış sabit değerin dize gösterimini, eşdeğer bir numaralandırılmış nesneye dönüştürür.Converts the string representation of the name or numeric value of one or more enumerated constants specified by TEnum to an equivalent enumerated object.

Parse<TEnum>(String, Boolean)

TEnum tarafından belirtilen bir veya daha fazla numaralandırılmış sabit değerin dize gösterimini, eşdeğer bir numaralandırılmış nesneye dönüştürür.Converts the string representation of the name or numeric value of one or more enumerated constants specified by TEnum to an equivalent enumerated object. Bir parametre, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir.A parameter specifies whether the operation is case-insensitive.

ToObject(Type, Byte)

Belirtilen 8 bit işaretsiz tamsayıyı bir numaralandırma üyesine dönüştürür.Converts the specified 8-bit unsigned integer to an enumeration member.

ToObject(Type, Int16)

Belirtilen 16 bit işaretli tamsayıyı bir numaralandırma üyesine dönüştürür.Converts the specified 16-bit signed integer to an enumeration member.

ToObject(Type, Int32)

Belirtilen 32 bitlik işaretli tamsayıyı bir numaralandırma üyesine dönüştürür.Converts the specified 32-bit signed integer to an enumeration member.

ToObject(Type, Int64)

Belirtilen 64 bitlik işaretli tamsayıyı bir numaralandırma üyesine dönüştürür.Converts the specified 64-bit signed integer to an enumeration member.

ToObject(Type, Object)

Belirtilen nesneyi bir tamsayı değerine sahip bir numaralandırma üyesine dönüştürür.Converts the specified object with an integer value to an enumeration member.

ToObject(Type, SByte)

Belirtilen 8 bitlik işaretli tamsayı değerini bir numaralandırma üyesine dönüştürür.Converts the specified 8-bit signed integer value to an enumeration member.

ToObject(Type, UInt16)

Belirtilen 16 bit işaretsiz tamsayı değerini bir numaralandırma üyesine dönüştürür.Converts the specified 16-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt32)

Belirtilen 32 bitlik işaretsiz tamsayı değerini bir numaralandırma üyesine dönüştürür.Converts the specified 32-bit unsigned integer value to an enumeration member.

ToObject(Type, UInt64)

Belirtilen 64 bitlik işaretsiz tamsayı değerini bir numaralandırma üyesine dönüştürür.Converts the specified 64-bit unsigned integer value to an enumeration member.

ToString()

Bu örneğinin değerini eşdeğer dize gösterimine dönüştürür.Converts the value of this instance to its equivalent string representation.

ToString(IFormatProvider)

Bu yöntem aşırı yüklemesi artık kullanılmıyor; ToString()kullanın.This method overload is obsolete; use ToString().

ToString(String)

Bu örneğin değerini, belirtilen biçimi kullanarak eşdeğer dize gösterimine dönüştürür.Converts the value of this instance to its equivalent string representation using the specified format.

ToString(String, IFormatProvider)

Bu yöntem aşırı yüklemesi artık kullanılmıyor; ToString(String)kullanın.This method overload is obsolete; use ToString(String).

TryParse(Type, String, Boolean, Object)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin dize gösterimini numaralandırılmış eşdeğer bir nesneye dönüştürür.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)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin dize gösterimini numaralandırılmış eşdeğer bir nesneye dönüştürür.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)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin dize gösterimini numaralandırılmış eşdeğer bir nesneye dönüştürür.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Bir parametre, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir.A parameter specifies whether the operation is case-sensitive. Dönüş değeri, dönüştürme işleminin başarılı olup olmadığını gösterir.The return value indicates whether the conversion succeeded.

TryParse<TEnum>(String, TEnum)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin dize gösterimini numaralandırılmış eşdeğer bir nesneye dönüştürür.Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. Dönüş değeri, dönüştürme işleminin başarılı olup olmadığını gösterir.The return value indicates whether the conversion succeeded.

Belirtik Arabirim Kullanımları

IConvertible.GetTypeCode()

Bu Enum örneğinin tür kodunu döndürür.Returns the type code of this Enum instance.

IConvertible.ToBoolean(IFormatProvider)

Geçerli değeri, temel alınan türe göre bir Boole değerine dönüştürür.Converts the current value to a Boolean value based on the underlying type.

IConvertible.ToByte(IFormatProvider)

Geçerli değeri, temel alınan türe göre 8 bit işaretsiz tamsayıya dönüştürür.Converts the current value to an 8-bit unsigned integer based on the underlying type.

IConvertible.ToChar(IFormatProvider)

Geçerli değeri, temel alınan türe göre bir Unicode karaktere dönüştürür.Converts the current value to a Unicode character based on the underlying type.

IConvertible.ToDateTime(IFormatProvider)

Geçerli değeri, temel alınan türe göre DateTime dönüştürür.Converts the current value to a DateTime based on the underlying type.

IConvertible.ToDecimal(IFormatProvider)

Geçerli değeri, temel alınan türe göre Decimal dönüştürür.Converts the current value to a Decimal based on the underlying type.

IConvertible.ToDouble(IFormatProvider)

Geçerli değeri, temel alınan türe göre çift duyarlıklı kayan noktalı sayıya dönüştürür.Converts the current value to a double-precision floating point number based on the underlying type.

IConvertible.ToInt16(IFormatProvider)

Geçerli değeri, temel alınan türe göre 16 bit işaretli bir tamsayıya dönüştürür.Converts the current value to a 16-bit signed integer based on the underlying type.

IConvertible.ToInt32(IFormatProvider)

Geçerli değeri, temel alınan türe göre 32 bit işaretli bir tamsayıya dönüştürür.Converts the current value to a 32-bit signed integer based on the underlying type.

IConvertible.ToInt64(IFormatProvider)

Geçerli değeri, temel alınan türe göre 64 bit işaretli bir tamsayıya dönüştürür.Converts the current value to a 64-bit signed integer based on the underlying type.

IConvertible.ToSByte(IFormatProvider)

Geçerli değeri, temel alınan türe göre 8 bit işaretli bir tamsayıya dönüştürür.Converts the current value to an 8-bit signed integer based on the underlying type.

IConvertible.ToSingle(IFormatProvider)

Geçerli değeri, temel alınan türe göre tek duyarlıklı kayan noktalı bir sayıya dönüştürür.Converts the current value to a single-precision floating-point number based on the underlying type.

IConvertible.ToString(IFormatProvider)

Bu yöntem aşırı yüklemesi artık kullanılmıyor; Bunun yerine ToString() kullanın.This method overload is obsolete; use ToString() instead.

IConvertible.ToType(Type, IFormatProvider)

Geçerli değeri, temel alınan türe göre belirtilen bir türe dönüştürür.Converts the current value to a specified type based on the underlying type.

IConvertible.ToUInt16(IFormatProvider)

Geçerli değeri, temel alınan türe göre 16 bit işaretsiz tamsayıya dönüştürür.Converts the current value to a 16-bit unsigned integer based on the underlying type.

IConvertible.ToUInt32(IFormatProvider)

Geçerli değeri, temel alınan türe göre 32 bitlik işaretsiz tamsayıya dönüştürür.Converts the current value to a 32-bit unsigned integer based on the underlying type.

IConvertible.ToUInt64(IFormatProvider)

Geçerli değeri, temel alınan türe göre 64 bitlik işaretsiz tamsayıya dönüştürür.Converts the current value to a 64-bit unsigned integer based on the underlying type.

IFormattable.ToString(String, IFormatProvider)

Bu yöntem aşırı yüklemesi artık kullanılmıyor; ToString(String)kullanın.This method overload is obsolete; use ToString(String).

Şunlara uygulanır

İş Parçacığı Güvenliği

Bu güvenli iş parçacığı türüdür.This type is thread safe.

Ayrıca bkz.