System.Enum sınıfı

Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.

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 bildirilmemişse kullanılır Int32 . Enum , .NET'teki tüm numaralandırmalar için temel sınıftır. Numaralandırma türleri C# içindeki anahtar sözcüğü, EnumVisual Basic'teki ...End Enum yapısı ve F# dilindeki type anahtar sözcük tarafından enum 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 ve değerin örneğini oluşturmak için yöntemler sağlar.

Bir numaralandırmayı bit alanı olarak da değerlendirebilirsiniz. Daha fazla bilgi için Özel olmayan üyeler ve Flags özniteliği bölümüne ve FlagsAttributebölümüne bakın.

Numaralandırma türü oluşturma

Programlama dilleri genellikle adlandırılmış sabitlerden 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 Enumdevralmadığını; devralma ilişkisinin derleyici tarafından örtük olarak işlendiğini unutmayın.

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

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

Public Enum ArrivalStatus1 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ü örneği oluşturma

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

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 Example1
    Public Sub Main()
        Dim status As ArrivalStatus1 = ArrivalStatus1.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:

• Belirli bir programlama dilinin özelliklerini kullanarak (C# dilinde olduğu gibi) veya bir tamsayı değerini numaralandırma değerine dönüştürerek (Visual Basic'te olduğu 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 ArrivalStatus2 = CType(1, ArrivalStatus2)
  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 örnekte numaralandırma örneğinin temel alınan değeri 0'dır. Ancak bu, numaralandırmadaki 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 ArrivalStatus2()
  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 integral değerini numaralandırma türüne dönüştürmek için yöntemini çağırarak ToObject . Daha fazla bilgi için Dönüştürmeleri 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 bir 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 numaralandırılmış sabit kullanmayı göz önünde bulundurun.

• Gelecekte kullanmak üzere ayrılmış numaralandırılmış sabitler 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, bu sayısal değer numaralandırmada tanımlanmamış olsa bile numaralandırma türüne sayısal bir değer atamanızdır.

Sabitleri bit alanları olan numaralandırma türleri için ek en iyi yöntemler, Özel olmayan üyeler ve Flags özniteliği bölümünde listelenir.

Numaralandırmalarla işlem gerçekleştirme

Numaralandırma 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 birçok yönteme ek olarak bu yöntemlerin çoğuna yönelik araştırma yapılır.

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

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

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 ArrivalStatus2 = CType(value3, ArrivalStatus2)

Dim value4 As Integer = CInt(status3)

sınıfı, Enum 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 ArrivalStatus2 = CType(ArrivalStatus2.ToObject(GetType(ArrivalStatus2), number), ArrivalStatus2)

Bir tamsayıyı numaralandırma değerine dönüştürürken, numaralandırmanın gerçekten ü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 class Example3
{
    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 ArrivalStatus4 As Integer
    Unknown = -3
    Late = -1
    OnTime = 0
    Early = 1
End Enum

Module Example4
    Public Sub Main()
        Dim values() As Integer = {-3, -1, 0, 1, 5, Int32.MaxValue}
        For Each value In values
            Dim status As ArrivalStatus4
            If [Enum].IsDefined(GetType(ArrivalStatus4), value) Then
                status = CType(value, ArrivalStatus4)
            Else
                status = ArrivalStatus4.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 tamsayı 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 ConvertToInt32yöntemlerini kullanmanız gerekir. Aşağıdaki örnekte, bir numaralandırma değerini temel alınan türüne Convert.ChangeType dönüştürmek için yöntemiyle birlikte yöntemini nasıl kullanabileceğiniz GetUnderlyingType gösterilmektedir. Bu örnekte, derleme zamanında sabit listesi için temel alınan türün 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 ArrivalStatus5 = ArrivalStatus5.Early
Dim number = Convert.ChangeType(status, [Enum].GetUnderlyingType(GetType(ArrivalStatus5)))
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 (Visual Basic'te) uygun numaralandırma türüne dönüştürmeniz 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 ArrivalStatus8 = CType([Enum].Parse(GetType(ArrivalStatus8), number), ArrivalStatus8)
    If Not [Enum].IsDefined(GetType(ArrivalStatus8), status1) Then status1 = ArrivalStatus8.Unknown
    Console.WriteLine("Converted '{0}' to {1}", number, status1)
Catch e As FormatException
    Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus8 value.",
                   number)
End Try

Dim status2 As ArrivalStatus8
If [Enum].TryParse(Of ArrivalStatus8)(name, status2) Then
    If Not [Enum].IsDefined(GetType(ArrivalStatus8), status2) Then status2 = ArrivalStatus8.Unknown
    Console.WriteLine("Converted '{0}' to {1}", name, status2)
Else
    Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus8 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 çağırarak 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 nasıl temsil edilir tam yolunu 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 ArrivalStatus6 = ArrivalStatus6.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 üyelerini yineleme

Türü Enum veya arabirimini IEnumerable uygulamaz. Bu, (C#'da), (F#'da) for..in veya For Each (Visual Basic'te) yapısı kullanarak foreach bir koleksiyonun üyelerini IEnumerable<T> yinelemenizi sağlar. 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(ArrivalStatus7))
  Console.WriteLine("Members of {0}:", GetType(ArrivalStatus7).Name)
  Array.Sort(names)
  For Each name In names
      Dim status As ArrivalStatus7 = CType([Enum].Parse(GetType(ArrivalStatus7), name),
                                 ArrivalStatus7)
      Console.WriteLine("   {0} ({0:D})", status)
  Next
  ' The example displays the following output:
  '       Members of ArrivalStatus7:
  '          Early (1)
  '          Late (-1)
  '          OnTime (0)
  '          Unknown (-3)
  

• Numaralandırmadaki GetValues temel değerleri içeren bir diziyi 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(ArrivalStatus7))
  Console.WriteLine("Members of {0}:", GetType(ArrivalStatus7).Name)
  For Each value In values
      Dim status As ArrivalStatus7 = CType([Enum].ToObject(GetType(ArrivalStatus7), value),
                                       ArrivalStatus7)
      Console.WriteLine("   {0} ({0:D})", status)
  Next
  ' The example displays the following output:
  '       Members of ArrivalStatus7:
  '          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 sabit listesi 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 numaralandırma 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 numaralandırma tanımlanırken ve özniteliği uygulanırken FlagsAttribute aşağıdaki en iyi yöntemler kullanılmalıdır.

• FlagsAttribute Numaralandırma 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, yani 1, 2, 4, 8 vb. güçlerinde 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 numaralandırılmış sabit oluşturmayı göz önünde bulundurun. Örneğin, ve sabitlerini içeren dosya G/Ç işlemleri için kullanılan bir numaralandırmanız varsa ve WriteWrite = 2bayraklarını Read = 1Read birleştiren numaralandırılmış sabiti ReadWrite = Read OR Writeoluş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 bayrmaya karşılık gelen sıfır olarak 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 numaralandırılmış bayrak 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.
  

• Numaralandırma değerini yalnızca numaralandırmanın durumunu yansıtacak şekilde 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ıktaki 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öntemler dışında bir numaralandırma türü için özel yöntemler tanımlayamazsınızEnum. 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 , en düşük geçiş notunu tanımlayan statik bir okuma-yazma değişkeni de 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 Example8
{
    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.

Örnekler

Aşağıdaki örnek, adlandırılmış değerleri temsil etmek için bir numaralandırma ve adlandırılmış bit alanlarını temsil eden başka bir numaralandırma kullanmayı gösterir.

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