Delen via

Opsommingstypen (C#-verwijzing)

Een opsommingstype (of enumtype) is een waardetype dat is gedefinieerd door een set benoemde constanten van het onderliggende integrale numerieke type. Als u een opsommingstype wilt definiëren, gebruikt u het enum trefwoord en geeft u de namen van enum-leden op:

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Standaard zijn de bijbehorende constante waarden van enum-leden van het type int. Ze beginnen met nul en nemen één toe na de definitietekstvolgorde. U kunt elk ander integraal numeriek type expliciet opgeven als een onderliggend type van een opsommingstype. U kunt ook expliciet de bijbehorende constantewaarden opgeven, zoals in het volgende voorbeeld wordt weergegeven:

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

U kunt geen methode definiëren binnen de definitie van een opsommingstype. Als u functionaliteit wilt toevoegen aan een opsommingstype, maakt u een extensielid.

De standaardwaarde van een opsommingstype E is de waarde die wordt geproduceerd door de expressie (E)0, zelfs als nul niet het bijbehorende enumlid heeft.

Impliciete conversies van nul

C# staat impliciete conversies van de letterlijke waarde 0 toe aan elk enumtype en van const waarden die gelijk zijn aan nul. Dit gedrag kan leiden tot onverwachte resultaten wanneer een enum geen lid bevat met de waarde nul:

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;
    }
}

In het voorgaande voorbeeld krijgen beide port1 en port2 de waarde 0toegewezen, maar GpioPort heeft geen lid met die waarde. De Enum.IsDefined methode bevestigt dat dit ongeldige enumwaarden zijn.

Deze impliciete conversie bestaat omdat het 0-bits patroon de standaardwaarde is voor alle structtypen, inclusief alle enumtypen. Het kan echter fouten in uw code introduceren. Ga als volgt te werk om deze problemen te voorkomen:

  • Definieer bijna altijd een lid met waarde 0 in uw opsommingen.
  • Gebruik Enum.IsDefined dit om opsommingswaarden te valideren bij het converteren van numerieke typen.
  • Wees voorzichtig bij het gebruik van numerieke parameters die impliciet kunnen worden geconverteerd naar enum-typen.

Gebruik een opsommingstype om een keuze te vertegenwoordigen uit een set wederzijds exclusieve waarden of een combinatie van keuzes. Als u een combinatie van keuzes wilt weergeven, definieert u een opsommingstype als bitvlagken.

Opsommingstypen als bitvlaggen

Als u wilt dat een opsommingstype een combinatie van keuzes vertegenwoordigt, definieert u opsommingsleden voor deze keuzes, zodat een afzonderlijke keuze een bitveld is. Dat wil gezegd: gebruik de bijbehorende waarden van die enumleden als de bevoegdheden van twee. Gebruik vervolgens de bitsgewijze logische operatoren | of & om keuzen of kruisingscombinaties van keuzen te combineren. Als u wilt aangeven dat een opsommingstype bitvelden declareert, past u het kenmerk Vlaggen hierop toe. Zoals in het volgende voorbeeld wordt weergegeven, kunt u ook enkele typische combinaties opnemen in de definitie van een opsommingstype.

[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
    }
}

Zie de System.FlagsAttributeAPI-referentiepagina en de niet-exclusieve leden en de sectie Flags-kenmerken van de System.Enum API-referentiepagina voor meer informatie en voorbeelden.

Het type System.Enum enum-beperking

Het System.Enum type is de abstracte basisklasse van alle opsommingstypen. Het biedt veel methoden om informatie op te halen over een opsommingstype en de bijbehorende waarden. Zie de System.Enum API-referentiepagina voor meer informatie en voorbeelden.

U kunt in een basisklassebeperking (ook wel de System.Enum genoemd) gebruiken om op te geven dat een typeparameter een opsommingstype is. Elk opsommingstype voldoet ook aan de struct beperking, die wordt gebruikt om op te geven dat een typeparameter een niet-null-waardetype is.

Conversies

Voor elk opsommingstype bestaan expliciete conversies tussen het opsommingstype en het onderliggende integrale type. Als u een enum-waarde naar het onderliggende type cast, is het resultaat de bijbehorende gehele waarde van een enum-lid.

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
    }
}

Gebruik de Enum.IsDefined methode om te bepalen of een opsommingstype een opsommingslid met een bepaalde gekoppelde waarde bevat.

Voor elk opsommingstype, boksen en uitpakken conversies van en naar het System.Enum type bestaan respectievelijk.

C#-taalspecificatie

Zie de volgende secties van de C#-taalspecificatie voor meer informatie:

Zie ook

  • Last updated on