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. Altta yatan herhangi bir veri tipi açıkça bildirilmemişse, Int32 kullanılır. Enum.NET'teki tüm numaralandırmalar için temel sınıftır. Numaralandırma türleri C# içindeki enum anahtar sözcüğü, Visual Basic'teki Enum...End Enum yapısı ve F# dilinde type anahtar sözcüğüyle 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 bir ö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 bakın ve FlagsAttribute.

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. üç üyesi olan ArrivalStatus adlı bir numaralandırma oluşturur: ArrivalStatus.Early, ArrivalStatus.OnTimeve ArrivalStatus.Late. Her durumda, enumerasyonun açıkça Enum'dan devralmadığını unutmayın; devralma ilişkisi derleyici tarafından örtük olarak ele alınır.

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 ilave istisnalar 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. Değeri ArrivalStatusolan bir ArrivalStatus.OnTime örneği aşağıdaki örnekte oluşturulur.

public class Example
{
   public static void Main()
   {
      ArrivalStatus status = ArrivalStatus.OnTime;
      Console.WriteLine($"Arrival Status: {status} ({status:D})");
   }
}
// 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 ArrivalStatus olan bir ArrivalStatus.Early nesnesi oluşturur.

  ArrivalStatus status2 = (ArrivalStatus)1;
  Console.WriteLine($"Arrival Status: {status2} ({status2:D})");
  // 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)
  

• Gizli 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: {status1} ({status1:D})");
  // 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 adını içeren bir dizeyi ayrıştırmak için Parse veya 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 ToObject yöntemini çağırarak. 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, None numaralandırılmış sabiti 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 hiçbiri tarafından temsil edilmeyen durumu 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ış 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 numaralandırma türü, Enum sınıfından eksiksiz bir statik ve örnek yöntemleri 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şlevi 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)

Enum sınıfı, herhangi bir tamsayı türündeki bir değeri numaralandırma değerine dönüştüren bir ToObject yöntemi de içerir. Aşağıdaki örnek, ToObject(Type, Int32)Int32 değerine dönüştürmek için ArrivalStatus yöntemini kullanır. ToObject Objecttüründe bir değer döndürdüğünden, nesneyi numaralandırma türüne atamak 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 ArrivalStatus değerlere dönüştürülip dönüştürülemeyeceğini belirlemek için 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 {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

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

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

ArrivalStatus status = ArrivalStatus.Early;
var number = Convert.ChangeType(status, Enum.GetUnderlyingType(typeof(ArrivalStatus)));
Console.WriteLine($"Converted {status} to {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 sabit listesi değerinin dize gösterimini bu değere dönüştürmenize olanak sağlar. Dize gösterimi, bir numaralandırma sabitinin adı veya temel 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, ayrıştırma yönteminin sonucunun geçerli bir numaralandırma değeri olduğundan emin olmak için IsDefined yöntemi çağrılabilir. Örnek bu yaklaşımı gösterir ve hem Parse(Type, String) hem de Enum.TryParse<TEnum>(String, TEnum) yöntemlerine yönelik çağrıları 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 '{number}' to {status1}");
}
catch (FormatException)
{
    Console.WriteLine($"Unable to convert '{number}' to an ArrivalStatus value.");
}

ArrivalStatus status2;
if (Enum.TryParse<ArrivalStatus>(name, out status2))
{
    if (!(Enum.IsDefined(typeof(ArrivalStatus), status2)))
        status2 = ArrivalStatus.Unknown;
    Console.WriteLine($"Converted '{name}' to {status2}");
}
else
{
    Console.WriteLine($"Unable to convert '{number}' to an ArrivalStatus value.");
}
// 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öntemini ç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, desteklenen numaralandırma biçimi dizelerinin her birini ("G" veya "g", "D" veya "d", "X" veya "x" ve "F" veya "f" ) kullanarak ArrivalStatus numaralandırmasının bir üyesini dize gösterimlerine dönüştürü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

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

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

  string[] names = Enum.GetNames(typeof(ArrivalStatus));
  Console.WriteLine($"Members of {typeof(ArrivalStatus).Name}:");
  Array.Sort(names);
  foreach (var name in names)
  {
      ArrivalStatus status = (ArrivalStatus)Enum.Parse(typeof(ArrivalStatus), name);
      Console.WriteLine($"   {status} ({status:D})");
  }
  // 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 temel değerleri içeren bir diziyi almak için GetValues yöntemini çağırabilirsiniz. Ardından, dizinin her öğesi için tamsayıyı eşdeğer numaralandırma değerine dönüştürmek için ToObject yöntemini çağırabilirsiniz. Aşağıdaki örnek bu yaklaşımı gösterir.

  var values = Enum.GetValues(typeof(ArrivalStatus));
  Console.WriteLine($"Members of {typeof(ArrivalStatus).Name}:");
  foreach (ArrivalStatus status in values)
  {
      Console.WriteLine($"   {status} ({status:D})");
  }
  // 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)
  

Ayrıcalıklı olmayan üyeler ve Bayraklar ö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ğinin değeri Early, OnTimeveya Lateolabilir. bir ArrivalStatus örneğinin 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 Pets adlı 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

Pets numaralandırması aşağıdaki örnekte gösterildiği gibi kullanılabilir.

Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine($"Pets: {familyPets:G} ({familyPets:D})");
// 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 FlagsAttribute özniteliği uygulanırken aşağıdaki en iyi yöntemler kullanılmalıdır.

• Numaralandırma için FlagsAttribute özel özniteliğini 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ş numaralandırma sabitlerindeki bireysel 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, Read = 1 ve Write = 2numaralandırılmış sabitleri içeren dosya G/Ç işlemleri için kullanılan bir numaralandırmanız varsa, ReadWrite = Read OR Write ve Read bayraklarını birleştiren numaralandırılmış sabit 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 örneği 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 sabiti arasında bit düzeyinde bir AND işlemi gerçekleştirmeye eşdeğerdir. Bu işlem, bayrağa karşılık gelmeyen tüm bitleri sayısal değer içinde sıfıra ayarlar ve ardından bu işlemin sonucunun bayrak 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 None kullanın. Sonuç her zaman sıfır olduğundan, bit düzeyinde VE işleminde bayrak test etmek için None numaralandırılmış sabitini kullanamazsınız. 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 enum (C#) ve Enum (Visual Basic) gibi dil yapıları tarafından tanımlandığından, Enum sınıfından devralınan yöntemler dışında 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, Grades numaralandırması bir öğrencinin sınıfta alabileceği olası harf notlarını temsil eder. Passing türüne Grades adlı bir uzantı yöntemi eklenir, böylece bu türün her örneği artık geçiş notunu temsil edip etmediğini "bilir". Extensions sınıfı, en düşük geçiş notunu tanımlayan statik bir okuma-yazma değişkeni de içerir. Passing uzantısı yönteminin 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($"{g1} {(g1.Passing() ? "is" : "is not")} a passing grade.");
        Console.WriteLine($"{g2} {(g2.Passing() ? "is" : "is not")} a passing grade.");

        Extensions.minPassing = Grades.C;
        Console.WriteLine("\nRaising the bar!\n");
        Console.WriteLine($"{g1} {(g1.Passing() ? "is" : "is not")} a passing grade.");
        Console.WriteLine($"{g2} {(g2.Passing() ? "is" : "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.

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: {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