System.Enum osztály

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

Az enumerálás nevesített állandók készlete, amelyek mögöttes típusa bármilyen integráltípus. Ha nincs explicit módon deklarált mögöttes típus, Int32 akkor a rendszer azt használja. Enum a .NET összes enumerálásának alaposztálya. Az enumerálási típusokat a enum C# kulcsszó, a EnumVisual Basic ...End Enum konstrukciója és az type F# kulcsszó határozza meg.

Enum Metódusokat biztosít az osztály példányainak összehasonlításához, egy példány értékének sztring-ábrázolásához, egy szám sztringképének az osztály egy példányává alakításához, valamint egy adott szám és érték példányának létrehozásához.

Az enumerálást bitmezőként is kezelheti. További információkért lásd a a nem kizárólagos tagok és a Flags attribútum szakaszt és FlagsAttribute.

Enumerálási típus létrehozása

A programozási nyelvek általában szintaxist biztosítanak az enumerálás deklarálásához, amely nevesített állandókból és azok értékeiből áll. Az alábbi példa a C#, az F# és a Visual Basic által az enumerálás definiálásához használt szintaxist mutatja be. Létrehoz egy enumerálást, ArrivalStatus amelynek három tagja van: ArrivalStatus.Early, ArrivalStatus.OnTimeés ArrivalStatus.Late. Kérjük, vegye figyelembe, hogy a felsorolás minden esetben nem öröklődik Enum explicit módon; a fordító implicit módon kezeli az öröklési kapcsolatot.

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

Figyelmeztetés

Soha ne hozzon létre olyan enumerálási típust, amelynek mögöttes típusa nem integrál vagy Char. Bár egy ilyen enumerálási típust tükrözéssel hozhat létre, az eredményül kapott típust használó metódushívások megbízhatatlanok, és további kivételeket is okozhatnak.

Egy felsorolási típus példányosítása

Az enumerálási típusokat ugyanúgy példányosíthatja, mint bármely más értéktípust: egy változó deklarálásával és az enumerálás egyik állandójának hozzárendelésével. Az alábbi példa egy ArrivalStatus példányt hoz létre, amelynek értéke ArrivalStatus.OnTime.

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)

Az enumerálási értékeket az alábbi módokon is létrehozhatja:

• Egy adott programozási nyelv funkcióinak használatával (a C#-hoz hasonlóan) vagy egy egész számérték enumerálási értékké alakításával (mint a Visual Basicben). Az alábbi példa létrehoz egy ArrivalStatus objektumot, amelynek az értéke ArrivalStatus.Early így áll be.

  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)
  

• Implicit paraméter nélküli konstruktor meghívásával. Ahogy az alábbi példa is mutatja, ebben az esetben az enumerálási példány mögöttes értéke 0. Ez azonban nem feltétlenül egy érvényes állandó értéke az enumerálásban.

  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)
  

• A felsorolásban egy konstans nevét tartalmazó sztring elemzéséhez hívja meg a Parse vagy a TryParse metódust. További információ: Az enumerálási értékek elemzése szakasz.

• Az integrálérték enumerálási típussá alakításához hívja meg a ToObject metódust. További információkért lásd a Konverziók végrehajtása szakaszt .

Ajánlott enumerálási eljárások

Az enumerálási típusok meghatározásakor az alábbi ajánlott eljárásokat javasoljuk:

• Ha nem definiált egy enumerációs tagot, amelynek értéke 0, fontolja meg egy None enumerált állandó létrehozását. Alapértelmezés szerint az enumeráláshoz használt memóriát a közös nyelvi futtatókörnyezet nullára inicializálja. Következésképpen, ha nem határoz meg olyan állandót, amelynek értéke nulla, az enumerálás érvénytelen értéket fog tartalmazni a létrehozáskor.

• Ha van egy nyilvánvaló alapértelmezett eset, amelyet az alkalmazásnak képviselnie kell, fontolja meg egy számba adott állandó használatát, amelynek értéke nulla. Ha nincs alapértelmezett eset, fontolja meg egy számbavételi állandó használatát, amelynek értéke nulla, és megadhatja azt az esetet, amelyet a többi számbavételi állandó nem jelöl.

• Ne adjon meg olyan számbavételi állandókat, amelyek jövőbeli használatra vannak fenntartva.

• Ha olyan metódust vagy tulajdonságot határoz meg, amely számba veszi az enumerált állandót értékként, fontolja meg az érték érvényesítését. Ennek az az oka, hogy numerikus értéket akkor is megadhat az enumerálási típushoz, ha a numerikus érték nincs definiálva az enumerálásban.

Az olyan enumerálási típusok további ajánlott eljárásai, amelyek állandói bitmezők, a nem kizárólagos tagok és a Flags attribútum szakaszban találhatók.

Műveletek végrehajtása enumerálásokkal

Enumerálás létrehozásakor nem definiálhat új metódusokat. Az enumerációs típus azonban a Enum osztályból örökli a teljes statikus és példánymetóduskészletet. Az alábbi szakaszok a legtöbb ilyen metódust áttekintik az enumerálási értékek használatakor gyakran használt metódusok mellett.

Átalakítások végrehajtása

Az enumerálási tag és annak mögöttes típusa közötti konvertálásra használhatunk kasztolási operátort C# és F# esetén, vagy konvertálási operátort a Visual Basicben. Az F#-ban a enum függvény is használható. Az alábbi példa típusátalakító vagy konverziós operátorokat használ az egész számból enumerációs értékre és enumerációs értékről egész számra történő átalakításhoz.

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)

Az Enum osztály tartalmaz egy metódust ToObject is, amely bármely integráltípus értékét enumerálási értékké alakítja. Az alábbi példa a ToObject(Type, Int32) metódus használatával konvertál egy Int32ArrivalStatus értéket. Vegye figyelembe, hogy mivel a ToObject függvény típusértéket Objectad vissza, előfordulhat, hogy egy öntvény- vagy átalakítási operátor használata továbbra is szükséges lehet ahhoz, hogy az objektumot az enumerálási típushoz lehessen adni.

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)

Egész szám enumerálási értékké alakításakor olyan érték rendelhető hozzá, amely valójában nem tagja az enumerálásnak. Ennek megakadályozása érdekében az egész számot átadhatja a metódusnak IsDefined, mielőtt végrehajtaná az átalakítást. Az alábbi példa ezzel a módszerrel határozza meg, hogy egy egész számból álló tömb elemei átalakíthatók-e értékekké ArrivalStatus .

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

Bár az Enum osztály explicit felületi implementációkat biztosít az interfészhez az IConvertible enumerálási értékből egy integrált típusba való konvertáláshoz, az osztály metódusait Convert kell használnia, például ToInt32az átalakítások végrehajtásához. Az alábbi példa bemutatja, hogyan használhatja a GetUnderlyingType metódust a metódussal együtt az Convert.ChangeType enumerálási érték alapul szolgáló típussá alakításához. Vegye figyelembe, hogy ez a példa nem követeli meg, hogy a számbavétel alapjául szolgáló típus a fordításkor ismert legyen.

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

Enumerálási értékek elemzése

A Parse és TryParse metódusok lehetővé teszik egy enumerációs érték sztring reprezentációjának konvertálását a konkrét értékre. A sztringábrázolás lehet egy enumerálási állandó neve vagy mögöttes értéke. Vegye figyelembe, hogy az elemzési metódusok sikeresen konvertálják az adott számsorba nem tartozó számok sztring-ábrázolását, ha a sztringek átalakíthatók az enumerálás alapjául szolgáló típus értékére. Ennek megakadályozása érdekében a IsDefined metódus meghívható annak biztosítására, hogy az elemzési módszer eredménye érvényes enumerálási érték legyen. A példa ezt a megközelítést szemlélteti, és bemutatja a Parse(Type, String) és Enum.TryParse<TEnum>(String, TEnum) metódusokra irányuló hívásokat. Vegye figyelembe, hogy a nem általános elemzési módszer egy olyan objektumot ad vissza, amelyet el kell vetítenie (C#-ban és F#-ban), vagy konvertálnia kell (a Visual Basicben) a megfelelő számbavételi típusra.

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

Számbavételi értékek formázása

Az enumerálási értékeket a statikus Format metódus meghívásával, valamint a példánymetódus ToString túlterheléseivel alakíthatja át sztringre. A formázási sztringgel pontosan szabályozhatja, hogy az enumerálási érték pontosan hogyan jelenik meg sztringként. További információ: Számbavételi formázási sztringek. Az alábbi példa a támogatott enumerálási formátum sztringjeinek ("G" vagy "g", "D" vagy "d", "X" vagy "x" és "F" vagy "f") használatával konvertálja az enumeráció egy tagját annak sztring reprezentációira.

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

Iteráljunk enumerációs tagokat

A Enum típus nem valósítja meg a IEnumerable vagy a IEnumerable<T> interfészt, ami lehetővé tenné, hogy egy foreach (C#-ban), for..in (F#-ban) vagy For Each (Visual Basic-ben) konstrukciót használva iterálja a gyűjtemény elemeit. A tagok számbavétele azonban kétféleképpen lehetséges.

• Meghívhatja a metódust egy GetNames sztringtömb lekérésére, amely tartalmazza az enumerálási tagok nevét. Ezután a sztringtömb minden eleméhez meghívhatja a Parse metódust, hogy a sztringet a megfelelő számbavételi értékké konvertálja. Az alábbi példa ezt a megközelítést szemlélteti.

  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)
  

• Meghívhatja a metódust egy GetValues olyan tömb lekérésére, amely az enumerálásban szereplő mögöttes értékeket tartalmazza. Ezután a tömb minden egyes eleméhez meghívhatja azt a ToObject metódust, amely az egész számot egyenértékű enumerálási értékké konvertálja. Az alábbi példa ezt a megközelítést szemlélteti.

  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)
  

Nem kizárólagos tagok és a 'Flags' attribútum

Az enumerálás egyik gyakori használata a kölcsönösen kizáró értékek halmazának ábrázolása. Például egy ArrivalStatus példány értéke Earlylehet , OnTimevagy Late. Nincs értelme, hogy egy ArrivalStatus példány értéke egynél több enumerálási állandót tükrözjön.

Más esetekben azonban az enumerálási objektumok értéke több enumerálási tagot is tartalmazhat, és minden tag egy bit mezőt jelöl az enumerálási értékben. Az FlagsAttribute attribútum azt jelzi, hogy az enumerálás bitmezőkből áll. Egy nevesített Pets számbavétel például arra használható, hogy jelezze a háziállatok típusát egy háztartásban. Ez a következőképpen határozható meg.

[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

Az Pets enumerálás ezután az alábbi példában látható módon használható.

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)

Bitenkénti számbavétel és az FlagsAttribute attribútum alkalmazásakor az alábbi ajánlott eljárásokat kell alkalmazni.

• A FlagsAttribute egyéni attribútumot csak akkor használja enumeráláshoz, ha bitenkénti műveletet (ÉS, VAGY, KIZÁRÓ VAGY) kell végrehajtani egy numerikus értéken.

• Definiálja az enumerálási állandókat két hatványban, azaz 1, 2, 4, 8 és így tovább. Ez azt jelenti, hogy a kombinált enumerálási állandók egyes jelzői nem fedik egymást.

• Érdemes lehet számba venni egy számba vett állandót a gyakran használt jelölőkombinációkhoz. Ha például fájl I/O-műveletekhez felsorolt konstansokat, például Read = 1 és Write = 2 használ, érdemes lehet létrehozni egy új felsorolt konstansot, amely egyesíti a ReadWrite = Read OR Write és Read jelzőket. Emellett a jelzők egyesítéséhez használt bitenkénti VAGY művelet bizonyos körülmények között speciális fogalomnak tekinthető, amely nem szükséges az egyszerű feladatokhoz.

• Körültekintően járjon el, ha negatív számot definiál számozott jelölőállandóként, mert számos jelölőpozíció 1 értékre állítható be, ami összezavarhatja a kódját, és kódolási hibákat ösztönözhet.

• A jelölő numerikus értékben való beállításának kényelmes módja a példány metódusának meghívása HasFlag , ahogyan az az alábbi példában is látható.

  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.
  

  Ez egyenértékű a numerikus érték és a számbavételi állandó közötti bitenkénti AND művelettel, amely nullára állítja a numerikus érték összes olyan bitét, amely nem felel meg a jelölőnek, majd teszteli, hogy a művelet eredménye megegyezik-e a számbavételi jelölő állandóval. Ezt az alábbi példában szemlélteti.

  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.
  

• Használja a None jelölőt a felsorolt konstans nevének, amelynek értéke nulla. A None felsorolt konstans nem használható bitenkénti ÉS műveletben zászló tesztelésére, mert az eredmény mindig nulla lesz. A numerikus érték és az None enumerált állandó közötti logikai és nem bitenkénti összehasonlítást azonban elvégezheti annak megállapításához, hogy a numerikus értékben lévő bitek be vannak-e állítva. Ezt az alábbi példában szemlélteti.

  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.
  

• Ne adjon meg enumerálási értéket kizárólag az enumerálás állapotának tükrözéséhez. Ne definiáljon például olyan számbavételi állandót, amely csupán az enumerálás végét jelöli. Ha meg kell határoznia az enumerálás utolsó értékét, ellenőrizze ezt az értéket explicit módon. Emellett az első és az utolsó számbavételi állandó tartományellenőrzését is elvégezheti, ha a tartományon belüli összes érték érvényes.

Enumerálási módszerek hozzáadása

Mivel az enumerálási típusok nyelvi struktúrák, például enum (C#) és Enum (Visual Basic) alapján vannak definiálva, az osztálytól Enum örökölt metódusoktól eltérő enumerálási típushoz nem definiálhat egyéni metódusokat. Bővítménymetelyekkel azonban funkciókat adhat hozzá egy adott enumerálási típushoz.

Az alábbi példában a Grades felsorolás azokat a lehetséges érdemjegyeket jelöli, amelyeket egy tanuló megkaphat egy tantárgyban. A(z) Passing nevű kiterjesztésmetódust hozzáadják a Grades típushoz, hogy az adott típus minden példánya "tudja", hogy jelöl-e egy átmenő osztályzatot vagy sem. Az Extensions osztály tartalmaz egy statikus írási-olvasási változót is, amely meghatározza a minimális átmenő osztályzatot. A bővítménymetódus visszatérési Passing értéke a változó aktuális értékét tükrözi.

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.

Példák

Az alábbi példa bemutatja az enumeráció használatát az elnevezett értékek reprezentálására, valamint egy másik enumeráció használatát az elnevezett bit mezők reprezentálására.

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