Számbavételi típusok (C#-referencia)

Az enumerálási típus (vagy enumerálási típus) az alapul szolgáló integrál numerikus típus nevesített állandói által meghatározott értéktípus. Enumerálási típus meghatározásához használja a enum kulcsszót, és adja meg az enumerálási tagok nevét:

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Alapértelmezés szerint az enumerálási tagok társított állandó értékei típusuk int; nullával kezdődnek, és a definíció szövegsorrendje alapján eggyel növekednek. Bármely más integrál numerikus típust explicit módon megadhat enumerálási típus mögöttes típusaként. A társított állandó értékeket explicit módon is megadhatja, ahogy az alábbi példa is mutatja:

enum ErrorCode : ushort
{
    None = 0,
    Unknown = 1,
    ConnectionLost = 100,
    OutlierReading = 200
}

Az enumerálási típus definíciójában nem definiálhat metódust. Ha funkciókat szeretne hozzáadni egy enumerálási típushoz, hozzon létre egy bővítménytagot.

Az enumerálási típus E alapértelmezett értéke a kifejezés (E)0által előállított érték, még akkor is, ha a nulla nem rendelkezik a megfelelő enumerálási tagtal.

Implicit konverziók nulláról

A C# lehetővé teszi az implicit konverziót a literális értékről 0 bármely számtípusra, valamint nullával egyenlő értékekre const . Ez a viselkedés váratlan eredményekhez vezethet, ha egy szám nem tartalmaz nulla értékű tagot:

public enum GpioPort
{
    GpioA = 1,
    GpioB,
    GpioC,
    GpioD
}

public class ZeroConversionExample
{
    public static void Main()
    {
        // This compiles without warning but creates an invalid enum value
        GpioPort port1 = (GpioPort)0;
        Console.WriteLine($"port1: {port1}"); // Output: port1: 0

        // This also compiles due to implicit conversion from zero
        GpioPort port2 = GetPort(0);
        Console.WriteLine($"port2: {port2}"); // Output: port2: 0

        // Check if the enum value is valid
        bool isValid1 = Enum.IsDefined(typeof(GpioPort), port1);
        bool isValid2 = Enum.IsDefined(typeof(GpioPort), port2);
        Console.WriteLine($"port1 is valid: {isValid1}"); // Output: port1 is valid: False
        Console.WriteLine($"port2 is valid: {isValid2}"); // Output: port2 is valid: False

        // Safer approach - validate enum values
        if (Enum.IsDefined(typeof(GpioPort), 0))
        {
            GpioPort safePort = (GpioPort)0;
        }
        else
        {
            Console.WriteLine("Value 0 is not a valid GpioPort");
            // Handle the invalid case appropriately
        }
    }

    public static GpioPort GetPort(GpioPort port)
    {
        return port;
    }
}

Az előző példában mindkettő port1 , és port2 hozzá van rendelve az értékhez 0, de GpioPort nem rendelkezik ezzel az értékkel. A Enum.IsDefined metódus megerősíti, hogy ezek érvénytelen enumerálási értékek.

Ez az implicit átalakítás azért létezik, mert a 0 bites minta az alapértelmezett az összes struktúratípushoz, beleértve az összes enumerálási típust is. Azonban hibákat okozhat a kódban. A problémák elkerülése érdekében:

• Szinte mindig meg kell határoznia egy értéket 0 tartalmazó tagot a számaiban.
• Számtípusokból való konvertáláskor az enumerálási értékek ellenőrzésére használható Enum.IsDefined .
• Legyen óvatos, ha szám típusúra implicit módon konvertálható numerikus paramétereket használ.

Enumerálási típussal egy kölcsönösen kizáró értékkészletből vagy választási lehetőségek kombinációjából származó választási lehetőségeket jelölhet. A választási lehetőségek kombinációjának megjelenítéséhez definiáljon egy enumerálási típust bitjelölőkként.

Számbavételi típusok bitjelölőként

Ha azt szeretné, hogy az enumerálási típus a választási lehetőségek kombinációját jelölje, adja meg az enumerálási tagokat ezekhez a választási lehetőségekhez, hogy az egyéni választás egy bit mező legyen. Vagyis az enumerációs tagok társított értékei legyenek kettő hatványai. Ezután használhatja a bitenkénti logikai operátorokat | , vagy & kombinálhatja a választási lehetőségeket, vagy metszheti a választási lehetőségek kombinációit. Annak jelzéséhez, hogy egy enumerálási típus bitmezőket deklarál, alkalmazza rá a Flags attribútumot. Ahogy az alábbi példa is mutatja, az enumerálási típus definíciójában néhány tipikus kombináció is szerepelhet.

[Flags]
public enum Days
{
    None      = 0b_0000_0000,  // 0
    Monday    = 0b_0000_0001,  // 1
    Tuesday   = 0b_0000_0010,  // 2
    Wednesday = 0b_0000_0100,  // 4
    Thursday  = 0b_0000_1000,  // 8
    Friday    = 0b_0001_0000,  // 16
    Saturday  = 0b_0010_0000,  // 32
    Sunday    = 0b_0100_0000,  // 64
    Weekend   = Saturday | Sunday
}

public class FlagsEnumExample
{
    public static void Main()
    {
        Days meetingDays = Days.Monday | Days.Wednesday | Days.Friday;
        Console.WriteLine(meetingDays);
        // Output:
        // Monday, Wednesday, Friday

        Days workingFromHomeDays = Days.Thursday | Days.Friday;
        Console.WriteLine($"Join a meeting by phone on {meetingDays & workingFromHomeDays}");
        // Output:
        // Join a meeting by phone on Friday

        bool isMeetingOnTuesday = (meetingDays & Days.Tuesday) == Days.Tuesday;
        Console.WriteLine($"Is there a meeting on Tuesday: {isMeetingOnTuesday}");
        // Output:
        // Is there a meeting on Tuesday: False

        var a = (Days)37;
        Console.WriteLine(a);
        // Output:
        // Monday, Wednesday, Saturday
    }
}

További információkért és példákért tekintse meg az System.FlagsAttribute API referenciaoldalát, a nem kizárólagos tagokat és azSystem.Enum API referencialap Flags attribútum szakaszát.

A System.Enum típus és az enum kényszer

A System.Enum típus az összes enumerálási típus absztrakt alaposztálya. Számos módszert biztosít az enumerálási típussal és értékeivel kapcsolatos információk lekéréséhez. További információkért és példákért tekintse meg az API referenciaoldalát System.Enum .

Az alaposztály-kényszerben (más néven System.Enum) megadhatja, hogy a típusparaméter enumerálási típus-e. Bármely enumerálási típus is megfelel a struct korlátozásnak, amely azt határozza meg, hogy egy típusparaméter nem null értékű értéktípus.

Konverziók

Bármely enumerálási típus esetében explicit konverziók léteznek az enumerálási típus és annak mögöttes integráltípusa között. Ha az enumerációs értéket konvertálja az alaptípusához, az eredmény az enumerációs taghoz társított integrálérték lesz.

public enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

public class EnumConversionExample
{
    public static void Main()
    {
        Season a = Season.Autumn;
        Console.WriteLine($"Integral value of {a} is {(int)a}");  // output: Integral value of Autumn is 2

        var b = (Season)1;
        Console.WriteLine(b);  // output: Summer

        var c = (Season)4;
        Console.WriteLine(c);  // output: 4
    }
}

Enum.IsDefined A metódussal meghatározhatja, hogy egy enumerálási típus tartalmaz-e egy adott társított értékkel rendelkező enumerálási tagot.

Minden enumerálási típus esetében léteznek dobozolási és kicsomagolási konverziók a System.Enum típusra és a típusból.

C# nyelvspecifikáció

További információt a C# nyelvspecifikációjának alábbi szakaszaiban talál:

• Felsorolási típusok
• Kijelölt értékek és műveletek
• Logikai operátorok számbavétele
• Enumerálási összehasonlító operátorok
• Explicit felsorolási konverziók
• Implicit felsorolásos konverziók

Lásd még

• Számbavételi formátum sztringjei
• Tervezési irányelvek – Enum design
• Tervezési irányelvek – Enumerálási konvenciók
• switch kifejezés
• switch nyilatkozat