Enum Sınıf

Tanım

Numaralandırmalar için temel sınıfı sağlar.

public ref class Enum abstract : ValueType, IComparable, IConvertible, IFormattable
public ref class Enum abstract : ValueType, IComparable, IFormattable
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
[System.Serializable]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Enum : ValueType, IComparable, IConvertible, IFormattable
public abstract class Enum : ValueType, IComparable, IFormattable
type Enum = class
    inherit ValueType
    interface IComparable
    interface IConvertible
    interface IFormattable
[<System.Serializable>]
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
    interface IConvertible
type Enum = class
    inherit ValueType
    interface IComparable
    interface IFormattable
Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IConvertible, IFormattable
Public MustInherit Class Enum
Inherits ValueType
Implements IComparable, IFormattable
Devralma
Türetilmiş
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnekte, adlandırılmış değerleri temsil eden bir sabit listesi ve adlandırılmış bit alanlarını temsil eden başka bir numaralandırmanın kullanılması gösterilmektedir.

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

type Days =
    | Saturday = 0
    | Sunday = 1
    | Monday = 2
    | Tuesday = 3
    | Wednesday = 4
    | Thursday = 5
    | Friday = 6

type BoilingPoints =
    | Celsius = 100
    | Fahrenheit = 212

[<Flags>]
type Colors =
    | Red = 1
    | Green = 2
    | Blue = 4
    | Yellow = 8

let weekdays = typeof<Days>
let boiling = typeof<BoilingPoints>

printfn "The days of the week, and their corresponding values in the Days Enum are:"

for s in Enum.GetNames weekdays do
    printfn $"""{s,-11}= {Enum.Format(weekdays, Enum.Parse(weekdays, s), "d")}"""

printfn "\nEnums can also be created which have values that represent some meaningful amount."
printfn "The BoilingPoints Enum defines the following items, and corresponding values:"

for s in Enum.GetNames boiling do
    printfn $"""{s,-11}= {Enum.Format(boiling, Enum.Parse(boiling, s), "d")}"""

let myColors = Colors.Red ||| Colors.Blue ||| Colors.Yellow
printfn $"\nmyColors holds a combination of colors. Namely: {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

Numaralandırma, temel türü herhangi bir tam sayı türünde olan adlandırılmış sabitler kümesidir. Temel alınan hiçbir tür açıkça bildirilirse Int32 kullanılır. Enum.NET Framework tüm sabit listeleri için temel sınıftır. Numaralandırma türleri C# dilinde anahtar enum sözcük, EnumVisual Basic içindeki ...End Enum yapısı ve type F# dilinde anahtar sözcük ile tanımlanır.

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

Sabit listesini bit alanı olarak da değerlendirebilirsiniz. Daha fazla bilgi için Özel Olmayan Üyeler ve Flags Özniteliği bölümüne ve konusuna FlagsAttribute bakın.

Bu konuda:

Sabit listesi türü oluşturma Numaralandırma türü listeleme en iyi yöntemleri Numaralandırmalarla işlem gerçekleştirme Dönüştürmeleri gerçekleştirme Numaralandırma değerlerini ayrıştırma Numaralandırma değerlerini biçimlendirme Numaralandırma değerlerini biçimlendirme Numaralandırmaüyelerini yinelemeÖzel olmayan üyeler ve Flags özniteliği Numaralandırma yöntemleri ekleme

Numaralandırma türü oluşturma

Programlama dilleri genellikle bir dizi adlandırılmış sabit ve bunların değerlerinden oluşan bir sabit listesi bildirmek için söz dizimi sağlar. Aşağıdaki örnekte, numaralandırma tanımlamak için C#, F# ve Visual Basic tarafından kullanılan söz dizimi gösterilmektedir. adlı ArrivalStatus üç üyesi olan bir numaralandırma oluşturur: ArrivalStatus.Early, ArrivalStatus.OnTimeve ArrivalStatus.Late. Her durumda, numaralandırmanın açıkça öğesinden Enumdevralınmadığını; devralma ilişkisinin derleyici tarafından örtük olarak işlendiğini unutmayın.

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

Uyarı

Hiçbir zaman temel türü tam sayı olmayan veya Charolan bir numaralandırma türü oluşturmamalısınız. Yansıma kullanarak böyle bir numaralandırma türü oluşturabilmenize rağmen, sonuçta elde edilen türü kullanan yöntem çağrıları güvenilir değildir ve ek özel durumlar da oluşturabilir.

Numaralandırma türünün örneğini oluşturma

Bir değişken bildirerek ve sabit listesi sabitlerinden birini atayarak, diğer değer türlerinin örneğini oluştururken olduğu gibi bir numaralandırma türü örneği oluşturabilirsiniz. Aşağıdaki örnekte değeri ArrivalStatus.OnTimeolan bir ArrivalStatus örneği oluşturulur.

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)
let status = ArrivalStatus.OnTime
printfn $"Arrival Status: {status} ({status:D})"
// 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ğerinin örneğini oluşturabilirsiniz:

  • Belirli bir programlama dilinin özelliklerini kullanarak bir tamsayı değerini numaralandırma değerine dönüştürmek (C#'ta olduğu gibi) veya dönüştürmek (Visual Basic gibi). Aşağıdaki örnek, değeri bu şekilde olan ArrivalStatus.Early bir ArrivalStatus nesne oluşturur.

    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    let status2 = enum<ArrivalStatus> 1
    printfn $"Arrival Status: {status2} ({status2:D})"
    // 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şturucusunu çağırarak. Aşağıdaki örnekte gösterildiği gibi, bu durumda numaralandırma örneğinin temel değeri 0'dır. Ancak bu, sabit listesindeki geçerli bir sabitin değeri olmayabilir.

    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    let status1 = ArrivalStatus()
    printfn $"Arrival Status: {status1} ({status1:D})"
    // 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)
    
  • Sabit listesindeki bir sabitin Parse adını içeren bir dizeyi ayrıştırmak için or TryParse yöntemini çağırarak. Daha fazla bilgi için Numaralandırma Değerlerini Ayrıştırma bölümüne bakın.

  • Bir tamsayı değerini bir numaralandırma türüne dönüştürmek için yöntemini çağırarak ToObject . Daha fazla bilgi için Dönüştürme gerçekleştirme bölümüne bakın.

Numaralandırma en iyi yöntemleri

Numaralandırma türlerini tanımlarken aşağıdaki en iyi yöntemleri kullanmanızı öneririz:

  • Değeri 0 olan bir numaralandırma üyesi tanımlamadıysanız, numaralandırılmış sabit None oluşturmayı göz önünde bulundurun. Varsayılan olarak, numaralandırma için kullanılan bellek ortak dil çalışma zamanı tarafından sıfıra başlatılır. Sonuç olarak, değeri sıfır olan bir sabit tanımlamazsanız, sabit listesi oluşturulduğunda geçersiz bir değer içerir.

  • Uygulamanızın temsil etmek zorunda olduğu belirgin bir varsayılan durum varsa, bunu temsil etmek için değeri sıfır olan bir numaralandırılmış sabit kullanmayı göz önünde bulundurun. Varsayılan durum yoksa, diğer numaralandırılmış sabitlerden herhangi biri tarafından temsil edilmeyen büyük/küçük harf belirtmek için değeri sıfır olan bir numaralandırılmış sabit kullanmayı göz önünde bulundurun.

  • Gelecekte kullanmak üzere ayrılmış numaralandırılmış sabitleri belirtmeyin.

  • Numaralandırılmış sabiti değer olarak alan bir yöntem veya özellik tanımlarken, değeri doğrulamayı göz önünde bulundurun. Bunun nedeni, numaralandırmada bu sayısal değer tanımlanmamış olsa bile bir sayısal değeri numaralandırma türüne atamanızdır.

Sabitleri bit alanları olan numaralandırma türleri için ek en iyi yöntemler , Özel Olmayan Üyeler ve Bayraklar Özniteliği bölümünde listelenmiştir.

Numaralandırmalarla işlem gerçekleştirme

Sabit listesi oluştururken yeni yöntemler tanımlayamazsınız. Ancak, bir numaralandırma türü sınıfından tam bir statik ve örnek yöntemleri Enum kümesini devralır. Aşağıdaki bölümlerde, numaralandırma değerleriyle çalışırken yaygın olarak kullanılan diğer yöntemlere ek olarak bu yöntemlerin çoğu araştırılır.

Dönüştürmeleri gerçekleştirme

Numaralandırma üyesiyle temel türü arasında dönüştürme işlemi için bir atama (C# ve F# dilinde) veya dönüştürme (Visual Basic) işleci kullanabilirsiniz. F# dilinde enum işlev de kullanılır. Aşağıdaki örnek, hem bir tamsayıdan bir sabit listesi değerine hem de bir numaralandırma değerinden tamsayıya dönüştürmeler gerçekleştirmek için dönüştürme veya dönüştürme işleçlerini kullanır.

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

int value4 = (int) status3;
let value3 = 2
let status3 = enum<ArrivalStatus> value3

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

Dim value4 As Integer = CInt(status3)

sınıfı Enum ayrıca herhangi bir ToObject tamsayı türündeki bir değeri numaralandırma değerine dönüştüren bir yöntem de içerir. Aşağıdaki örnek, bir Int32 değerini bir ArrivalStatus değere dönüştürmek için yöntemini kullanırToObject(Type, Int32). türünde bir değer döndürdüğünden ToObject , nesnesini numaralandırma türüne Objectatamak için yine de bir atama veya dönüştürme işlecinin kullanılması gerekebileceğini unutmayın.

int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);
let number = -1
let arrived = ArrivalStatus.ToObject(typeof<ArrivalStatus>, number) :?> ArrivalStatus
Dim number As Integer = -1
Dim arrived As ArrivalStatus = CType(ArrivalStatus.ToObject(GetType(ArrivalStatus), number), ArrivalStatus)

Bir tamsayıyı numaralandırma değerine dönüştürürken, numaralandırmanın aslında üyesi olmayan bir değer atamak mümkündür. Bunu önlemek için dönüştürmeyi gerçekleştirmeden önce tamsayıyı IsDefined yöntemine geçirebilirsiniz. Aşağıdaki örnek, bir tamsayı değerleri dizisindeki öğelerin değerlere dönüştürülip dönüştürülemeyeceğini belirlemek için ArrivalStatus bu yöntemi kullanır.

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
open System

type ArrivalStatus =
    | Unknown = -3
    | Late = -1
    | OnTime = 0
    | Early = 1

let values = [ -3; -1; 0; 1; 5; Int32.MaxValue ]
for value in values do
    let status =
        if Enum.IsDefined(typeof<ArrivalStatus>, value) then
            enum value
        else
            ArrivalStatus.Unknown
    printfn $"Converted {value:N0} to {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

sınıfı, bir numaralandırma değerinden tam sayı türüne dönüştürmek için arabiriminin IConvertible açık arabirim uygulamalarını sağlasa Enum da, bu dönüştürmeleri gerçekleştirmek için sınıfın Convert ToInt32yöntemlerini kullanmanız gerekir. Aşağıdaki örnekte, bir numaralandırma değerini temel alınan türüne GetUnderlyingType dönüştürmek için yöntemiyle Convert.ChangeType birlikte yöntemini nasıl kullanabileceğiniz gösterilmektedir. Bu örnekte, numaralandırmanın temel alınan türünün derleme zamanında bilinmesi gerekmediğini unutmayın.

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
let status = ArrivalStatus.Early
let number = Convert.ChangeType(status, Enum.GetUnderlyingType typeof<ArrivalStatus>)
printfn $"Converted {status} to {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ırma

Parse ve TryParse yöntemleri, bir numaralandırma değerinin dize gösterimini bu değere dönüştürmenize olanak sağlar. Dize gösterimi, bir sabit listesi sabitinin adı veya temel alınan değeri olabilir. Ayrıştırma yöntemlerinin, dizeler sabit listesi temel türündeki bir değere dönüştürülebiliyorsa, belirli bir sabit listesi üyesi olmayan sayıların dize gösterimlerini başarıyla dönüştüreceğini unutmayın. Bunu önlemek için, IsDefined ayrıştırma yönteminin sonucunun geçerli bir numaralandırma değeri olduğundan emin olmak için yöntemi çağrılabilir. Örnek bu yaklaşımı gösterir ve hem ve Enum.TryParse<TEnum>(String, TEnum) yöntemlerine çağrıları Parse(Type, String) gösterir. Genel olmayan ayrıştırma yönteminin, atamanız (C# ve F# dilinde) veya uygun numaralandırma türüne dönüştürmeniz (Visual Basic) gerekebilecek bir nesne döndürdüğünü unutmayın.

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
let number = "-1"
let name = "Early"

try
    let status1 = Enum.Parse(typeof<ArrivalStatus>, number) :?> ArrivalStatus
    let status1 =
        if not (Enum.IsDefined(typeof<ArrivalStatus>, status1) ) then
            ArrivalStatus.Unknown
        else 
            status1
        
    printfn $"Converted '{number}' to {status1}"
with :? FormatException ->
    printfn $"Unable to convert '{number}' to an ArrivalStatus value."

match Enum.TryParse<ArrivalStatus> name with
| true, status2 ->
    let status2 = 
        if not (Enum.IsDefined(typeof<ArrivalStatus>, status2) ) then
            ArrivalStatus.Unknown
        else 
            status2
    printfn $"Converted '{name}' to {status2}"
| _ ->
    printfn $"Unable to convert '{number}' to an ArrivalStatus value."
// 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çimlendirme

Sabit listesi değerlerini, statik Format yöntemi ve örnek ToString yönteminin aşırı yüklemelerini çağırarak dize gösterimlerine dönüştürebilirsiniz. Bir numaralandırma değerinin dize olarak temsil edilebileceği kesin yolu denetlemek için bir biçim dizesi kullanabilirsiniz. Daha fazla bilgi için bkz. Numaralandırma Biçim Dizeleri. Aşağıdaki örnek, numaralandırmanın bir üyesini ArrivalStatus dize gösterimlerine dönüştürmek için desteklenen numaralandırma biçimi dizelerinin her birini ("G" veya "g", "D" veya "d", "X" veya "x" ve "F" veya "f" ) kullanır.

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
let formats = [ "G"; "F"; "D"; "X" ]
let status = ArrivalStatus.Late
for fmt in formats do
    printfn $"{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

Numaralandırma üyeleri yinelenme

türüEnum, bir koleksiyonun üyelerini IEnumerable (C#'da), (F# dilinde) for..in veya (Visual Basic içinde) yapısı kullanarak foreach yinelemenizi sağlayacak veya IEnumerable<T> For Each arabirimini uygulamaz. Ancak, üyeleri iki yoldan biriyle numaralandırabilirsiniz.

  • Numaralandırma üyelerinin adlarını içeren bir dize dizisi almak için yöntemini çağırabilirsiniz GetNames . Ardından, dize dizisinin her öğesi için dizeyi Parse eşdeğer numaralandırma değerine dönüştürmek için yöntemini çağırabilirsiniz. Aşağıdaki örnek bu yaklaşımı gösterir.

    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)
    
    let names = Enum.GetNames typeof<ArrivalStatus>
    printfn $"Members of {nameof ArrivalStatus}:"
    let names = Array.sort names
    for name in names do
        let status = Enum.Parse(typeof<ArrivalStatus>, name) :?> ArrivalStatus
        printfn $"   {status} ({status:D})"
    // 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 GetValues temel değerleri içeren bir dizi almak için yöntemini çağırabilirsiniz. Ardından, dizinin her öğesi için tamsayıyı ToObject eşdeğer numaralandırma değerine dönüştürmek için yöntemini çağırabilirsiniz. Aşağıdaki örnek bu yaklaşımı gösterir.

    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)
    
    let values = Enum.GetValues typeof<ArrivalStatus>
    printfn $"Members of {nameof ArrivalStatus}:"
    for status in values do
        printfn $"   {status} ({status:D})"
    // 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)
    

Özel olmayan üyeler ve Flags özniteliği

Numaralandırmanın yaygın kullanımlarından biri, birbirini dışlayan değerler kümesini temsil etmektir. Örneğin, bir ArrivalStatus örneğin değeri Early, OnTimeveya Lateolabilir. Bir ArrivalStatus örneğin değerinin birden fazla numaralandırma sabitini yansıtması mantıklı değildir.

Ancak diğer durumlarda, bir numaralandırma nesnesinin değeri birden çok numaralandırma üyesi içerebilir ve her üye sabit listesi değerinde bir bit alanını temsil eder. FlagsAttribute özniteliği, numaralandırmanın bit alanlarından oluştuğunun belirtilmesi için kullanılabilir. Örneğin, bir evdeki evcil hayvan türlerini belirtmek için adlı Pets bir numaralandırma kullanılabilir. Aşağıdaki gibi tanımlanabilir.

[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };
[<Flags>] 
type 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

Numaralandırma Pets daha sonra aşağıdaki örnekte gösterildiği gibi kullanılabilir.

Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets);
// The example displays the following output:
//       Pets: Dog, Cat (3)
let familyPets = Pets.Dog ||| Pets.Cat
printfn $"Pets: {familyPets:G} ({familyPets:D})"
// 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)

Bit düzeyinde bir numaralandırma tanımlarken ve özniteliğini uygularken FlagsAttribute aşağıdaki en iyi yöntemler kullanılmalıdır.

  • FlagsAttribute Sabit listesi için özel özniteliği yalnızca bit düzeyinde bir işlem (AND, OR, EXCLUSIVE OR) sayısal bir değer üzerinde gerçekleştirilecekse kullanın.

  • Numaralandırma sabitlerini iki kuvvette (1, 2, 4, 8 vb.) tanımlayın. Bu, birleştirilmiş sabit listesi sabitlerindeki tek tek bayrakların çakışmadığı anlamına gelir.

  • Yaygın olarak kullanılan bayrak bileşimleri için bir numaralandırılmış sabit oluşturmayı göz önünde bulundurun. Örneğin, ve numaralandırılmış sabitlerini içeren dosya G/Ç işlemleri için kullanılan bir numaralandırmanız varsa ve Write = 2``Write bayraklarını Read = 1 birleştiren numaralandırılmış sabitini ReadWrite = Read OR Write``Read oluşturmayı göz önünde bulundurun. Ayrıca, bayrakları birleştirmek için kullanılan bit düzeyinde OR işlemi, bazı durumlarda basit görevler için gerekli olmaması gereken gelişmiş bir kavram olarak kabul edilebilir.

  • Birçok bayrak konumu 1 olarak ayarlanabileceği için negatif bir sayıyı bayrak numaralandırılmış sabiti olarak tanımlarsanız dikkatli olun; bu durum kodunuzu kafa karıştırıcı hale getirebilir ve kodlama hatalarını teşvik edebilir.

  • Bir bayrağın sayısal bir değerde ayarlanıp ayarlanmadığını test etmenin kullanışlı bir yolu, aşağıdaki örnekte gösterildiği gibi örnek HasFlag yöntemini çağırmaktır.

    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.
    
    let familyPets = Pets.Dog ||| Pets.Cat
    if familyPets.HasFlag Pets.Dog then
        printfn "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 ile bayrak numaralandırılmış sabiti arasında bit düzeyinde AND işlemi gerçekleştirmeye eşdeğerdir. Bu işlem, sayısal değerdeki tüm bitleri, bayrakla eşleşmeyen sıfıra ayarlar ve ardından bu işlemin sonucunun bayrak numaralandırılmış sabitine eşit olup olmadığını test eder. Bu, aşağıdaki örnekte gösterilmiştir.

    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.
    
    let familyPets = Pets.Dog ||| Pets.Cat
    if (familyPets &&& Pets.Dog) = Pets.Dog then
        printfn "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 bayrak numaralandırılmış sabitinin adı olarak kullanın None . Sonuç her zaman sıfır olduğundan bir bayrağı test etmek için bit düzeyinde AND işleminde numaralandırılmış sabiti kullanamazsınız None . Ancak, sayısal değerdeki herhangi bir bitin ayarlanıp ayarlanmadığını belirlemek için sayısal değer ile None numaralandırılmış sabit arasında bit düzeyinde değil mantıksal bir karşılaştırma gerçekleştirebilirsiniz. Bu, aşağıdaki örnekte gösterilmiştir.

    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.
    
    let familyPets = Pets.Dog ||| Pets.Cat
    if familyPets = Pets.None then
        printfn "The family has no pets."
    else
        printfn "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. Örneğin, yalnızca numaralandırmanın sonunu işaretleyen bir numaralandırılmış sabit tanımlamayın. Numaralandırmanın son değerini belirlemeniz gerekiyorsa, bu değeri açıkça denetleyin. Ayrıca, aralık içindeki tüm değerler geçerliyse ilk ve son numaralandırılmış sabit için aralık denetimi gerçekleştirebilirsiniz.

Numaralandırma yöntemleri ekleme

Numaralandırma türleri (C#) ve Enum (Visual Basic) gibi enum dil yapıları tarafından tanımlandığından, sınıftan devralınan yöntemlerden Enum başka bir numaralandırma türü için özel yöntemler tanımlayamazsınız. Ancak, belirli bir numaralandırma türüne işlevsellik eklemek için uzantı yöntemlerini kullanabilirsiniz.

Aşağıdaki örnekte, numaralandırma bir Grades öğrencinin sınıfta alabileceği olası harf notlarını temsil eder. Türüne Grades adlı Passing bir uzantı yöntemi eklenir, böylece bu türün her örneği artık geçiş notunu temsil edip etmediğini "bilir". sınıfı Extensions ayrıca en düşük geçiş notunu tanımlayan statik bir okuma-yazma değişkeni içerir. Uzantı yönteminin Passing dönüş değeri, bu değişkenin geçerli değerini yansıtır.

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.
open System
open System.Runtime.CompilerServices
// Define an enumeration to represent student grades.
type Grades =
    | F = 0
    | D = 1
    | C = 2
    | B = 3
    | A = 4

let mutable minPassing = Grades.D

// Define an extension method for the Grades enumeration.
[<Extension>]
type Extensions =
    [<Extension>]
    static member Passing(grade) = grade >= minPassing

let g1 = Grades.D
let g2 = Grades.F
printfn $"""{g1} {if g1.Passing() then "is" else "is not"} a passing grade."""
printfn $"""{g2} {if g2.Passing() then "is" else "is not"} a passing grade."""

minPassing <- Grades.C
printfn "\nRaising the bar!\n"
printfn $"""{g1} {if g1.Passing() then "is" else "is not"} a passing grade."""
printfn $"""{g2} {if g2.Passing() then "is" else "is not"} a passing grade."""
// 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()

Enum sınıfının yeni bir örneğini başlatır.

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.

Equals(Object)

Bu örneğin, belirtilen bir nesneye eşit olup olmadığını gösteren bir değeri döndürür.

Format(Type, Object, String)

Belirtilen 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.

GetHashCode()

Bu örneğin değeri için karma kodu döndürür.

GetName(Type, Object)

Belirtilen sabit listesi içinde belirtilen değere sahip sabitin adını alır.

GetName<TEnum>(TEnum)

Belirtilen değere sahip belirtilen numaralandırma türündeki sabitin adını alır.

GetNames(Type)

Belirtilen sabit listesi içindeki sabitlerin adlarının dizisini alır.

GetNames<TEnum>()

Belirtilen sabit listesi türündeki sabitlerin adlarının dizisini alır.

GetType()

Type Geçerli örneğini alır.

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

Bu sabit listesi üyesinin temel alınan türünün tür kodunu döndürür.

GetUnderlyingType(Type)

Belirtilen sabit listesi için temel alınan türü döndürür.

GetValues(Type)

Belirtilen bir sabit listesi içindeki sabitlerin değerlerinin dizisini alır.

GetValues<TEnum>()

Belirtilen sabit listesi türündeki sabitlerin değerlerinin dizisini alır.

HasFlag(Enum)

Geçerli örnekte bir veya daha fazla bit alanının ayarlanıp ayarlanmayacağını belirler.

IsDefined(Type, Object)

Belirli bir tamsayı değerinin veya dize olarak adının belirtilen bir numaralandırmada var olup olmadığını belirten bir Boole değeri döndürür.

IsDefined<TEnum>(TEnum)

Belirli bir tamsayı değerinin veya dize olarak adının belirtilen bir numaralandırmada var olup olmadığını belirten bir boole değeri döndürür.

MemberwiseClone()

Geçerli Objectöğesinin sığ bir kopyasını oluşturur.

(Devralındığı yer: Object)
Parse(Type, ReadOnlySpan<Char>)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin karakter gösteriminin span değerini eşdeğer bir numaralandırılmış nesneye dönüştürür.

Parse(Type, ReadOnlySpan<Char>, Boolean)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin karakter gösteriminin span değerini eşdeğer bir numaralandırılmış nesneye dönüştürür. Parametresi, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir.

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.

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. Parametresi, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir.

Parse<TEnum>(ReadOnlySpan<Char>)

tarafından TEnum belirtilen bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin karakter gösteriminin aralığını eşdeğer bir numaralandırılmış nesneye dönüştürür.

Parse<TEnum>(ReadOnlySpan<Char>, Boolean)

tarafından TEnum belirtilen bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin karakter gösteriminin aralığını eşdeğer bir numaralandırılmış nesneye dönüştürür. Parametresi, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir.

Parse<TEnum>(String)

tarafından TEnum belirtilen bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin dize gösterimini eşdeğer bir numaralandırılmış nesneye dönüştürür.

Parse<TEnum>(String, Boolean)

tarafından TEnum belirtilen bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin dize gösterimini eşdeğer bir numaralandırılmış nesneye dönüştürür. Parametresi, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir.

ToObject(Type, Byte)

Belirtilen 8 bit işaretsiz tamsayıyı bir numaralandırma üyesine dönüştürür.

ToObject(Type, Int16)

Belirtilen 16 bit imzalı tamsayıyı bir numaralandırma üyesine dönüştürür.

ToObject(Type, Int32)

Belirtilen 32 bit imzalı tamsayıyı bir numaralandırma üyesine dönüştürür.

ToObject(Type, Int64)

Belirtilen 64 bit işaretli tamsayıyı bir numaralandırma üyesine dönüştürür.

ToObject(Type, Object)

Belirtilen nesneyi bir tamsayı değeriyle sabit listesi üyesine dönüştürür.

ToObject(Type, SByte)

Belirtilen 8 bit imzalı tamsayı değerini bir numaralandırma üyesine dönüştürür.

ToObject(Type, UInt16)

Belirtilen 16 bit işaretsiz tamsayı değerini bir numaralandırma üyesine dönüştürür.

ToObject(Type, UInt32)

Belirtilen 32 bit işaretsiz tamsayı değerini bir numaralandırma üyesine dönüştürür.

ToObject(Type, UInt64)

Belirtilen 64 bit işaretsiz tamsayı değerini bir numaralandırma üyesine dönüştürür.

ToString()

Bu örneğinin değerini eşdeğer dize gösterimine dönüştürür.

ToString(IFormatProvider)
Kullanımdan kalktı.
Kullanımdan kalktı.

Bu yöntem aşırı yüklemesi kullanımdan kaldırıldı; kullanın ToString().

ToString(String)

Belirtilen biçimi kullanarak bu örneğin değerini eşdeğer dize gösterimine dönüştürür.

ToString(String, IFormatProvider)
Kullanımdan kalktı.
Kullanımdan kalktı.

Bu yöntem aşırı yüklemesi kullanımdan kaldırıldı; kullanın ToString(String).

TryParse(Type, ReadOnlySpan<Char>, Boolean, Object)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin karakter gösteriminin span değerini eşdeğer bir numaralandırılmış nesneye dönüştürür. Parametresi, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir.

TryParse(Type, ReadOnlySpan<Char>, Object)

Bir veya daha fazla numaralandırılmış sabitin adının veya sayısal değerinin karakter gösteriminin span değerini eşdeğer bir numaralandırılmış nesneye dönüştürür.

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.

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.

TryParse<TEnum>(ReadOnlySpan<Char>, 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. Parametre, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir. Dönüş değeri, dönüştürme işleminin başarılı olup olmadığını gösterir.

TryParse<TEnum>(ReadOnlySpan<Char>, 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.

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. Parametre, işlemin büyük/küçük harfe duyarlı olup olmadığını belirtir. Dönüş değeri, dönüştürme işleminin başarılı olup olmadığını gösterir.

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. Dönüş değeri, dönüştürme işleminin başarılı olup olmadığını gösterir.

Belirtik Arabirim Kullanımları

IConvertible.GetTypeCode()

Bu Enum örneğin tür kodunu döndürür.

IConvertible.ToBoolean(IFormatProvider)

Temel alınan türe göre geçerli değeri Boole değerine dönüştürür.

IConvertible.ToByte(IFormatProvider)

Geçerli değeri, temel alınan türe göre 8 bit işaretsiz bir tamsayıya dönüştürür.

IConvertible.ToChar(IFormatProvider)

Geçerli değeri, temel alınan türe göre Unicode karakterine dönüştürür.

IConvertible.ToDateTime(IFormatProvider)

Geçerli değeri, temel alınan türe göre bir DateTime değerine dönüştürür.

IConvertible.ToDecimal(IFormatProvider)

Geçerli değeri, temel alınan türe göre bir Decimal değerine dönüştürür.

IConvertible.ToDouble(IFormatProvider)

Geçerli değeri, temel alınan türe göre çift duyarlıklı kayan nokta sayısına dönüştürür.

IConvertible.ToInt16(IFormatProvider)

Temel alınan türe göre geçerli değeri 16 bit imzalı tamsayıya dönüştürür.

IConvertible.ToInt32(IFormatProvider)

Temel alınan türe göre geçerli değeri 32 bit imzalı tamsayıya dönüştürür.

IConvertible.ToInt64(IFormatProvider)

Temel alınan türe göre geçerli değeri 64 bit imzalı bir tamsayıya dönüştürür.

IConvertible.ToSByte(IFormatProvider)

Temel alınan türe göre geçerli değeri 8 bit imzalı bir tamsayıya dönüştürür.

IConvertible.ToSingle(IFormatProvider)

Geçerli değeri, temel alınan türe göre tek duyarlıklı kayan noktalı sayıya dönüştürür.

IConvertible.ToString(IFormatProvider)
Kullanımdan kalktı.

Bu yöntem aşırı yüklemesi kullanımdan kaldırıldı; yerine kullanın ToString() .

IConvertible.ToType(Type, IFormatProvider)

Geçerli değeri, temel alınan türe göre belirtilen türe dönüştürür.

IConvertible.ToUInt16(IFormatProvider)

Temel alınan türü temel alarak geçerli değeri 16 bit işaretsiz tamsayıya dönüştürür.

IConvertible.ToUInt32(IFormatProvider)

Temel alınan türü temel alarak geçerli değeri 32 bit işaretsiz tamsayıya dönüştürür.

IConvertible.ToUInt64(IFormatProvider)

Temel alınan türü temel alarak geçerli değeri 64 bit işaretsiz tamsayıya dönüştürür.

IFormattable.ToString(String, IFormatProvider)
Kullanımdan kalktı.

Bu yöntem aşırı yüklemesi kullanımdan kaldırıldı; kullanın ToString(String).

Şunlara uygulanır

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

Bu güvenli iş parçacığı türüdür.

Ayrıca bkz.