C# Language
enum

introduzione

Sintassi

• enum Colors {Red, Green, Blue} // Dichiarazione Enum
• enum Colori: byte {rosso, verde, blu} // Dichiarazione con tipo specifico
• enum Colors {Red = 23, Green = 45, Blue = 12} // Dichiarazione con valori definiti
• Colors.Red // Accede a un elemento di un Enum
• int value = (int) Colors.Red // Ottieni il valore int di un elemento enum
• Colors color = (Colors) intValue // Ottieni un elemento enum da int

Osservazioni

Ottieni tutti i valori dei membri di un enum

enum MyEnum
{
    One,
    Two,
    Three
}

foreach(MyEnum e in Enum.GetValues(typeof(MyEnum)))
    Console.WriteLine(e);

Questo stamperà:

One
Two
Three

Enum come bandiere

Il FlagsAttribute può essere applicato a un enum che modifica il comportamento di ToString() in modo che corrisponda alla natura dell'enum:

[Flags]
enum MyEnum
{
    //None = 0, can be used but not combined in bitwise operations
    FlagA = 1,
    FlagB = 2,
    FlagC = 4,
    FlagD = 8  
    //you must use powers of two or combinations of powers of two 
    //for bitwise operations to work
}

var twoFlags = MyEnum.FlagA | MyEnum.FlagB;

// This will enumerate all the flags in the variable: "FlagA, FlagB".
Console.WriteLine(twoFlags);

Poiché FlagsAttribute si basa sulle costanti di enumerazione per essere poteri di due (o le loro combinazioni) ei valori enum sono in definitiva valori numerici, si è limitati dalla dimensione del tipo numerico sottostante. Il più grande tipo numerico disponibile che è possibile utilizzare è UInt64 , che consente di specificare 64 costanti enum flag distinte (non combinate). La parola chiave enum imposta automaticamente il tipo sottostante int , che è Int32 . Il compilatore consentirà la dichiarazione di valori più ampi di 32 bit. Quelli si avvolgeranno senza avviso e generano due o più membri enum dello stesso valore. Pertanto, se un enum è pensato per contenere un set di bit di oltre 32 flag, è necessario specificare esplicitamente un tipo più grande:

public enum BigEnum : ulong
{
    BigValue = 1 << 63
}

Sebbene i flag siano spesso solo un singolo bit, possono essere combinati in "set" denominati per un utilizzo più semplice.

[Flags]
enum FlagsEnum
{
    None = 0,
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
       
    Default = Option1 | Option3,
    All = Option1 | Option2 | Option3,
}

Per evitare di compitare i valori decimali delle potenze di due, l' operatore di spostamento a sinistra (<<) può anche essere usato per dichiarare lo stesso enum

[Flags]
enum FlagsEnum
{
    None = 0,
    Option1 = 1 << 0,
    Option2 = 1 << 1,
    Option3 = 1 << 2,
       
    Default = Option1 | Option3,
    All = Option1 | Option2 | Option3,
}

A partire da C # 7.0, possono essere usati anche i letterali binari .

Per verificare se il valore della variabile enum ha un determinato flag impostato, è possibile utilizzare il metodo HasFlag . Diciamo che abbiamo

[Flags]
enum MyEnum
{
    One = 1,
    Two = 2,
    Three = 4
}

E un value

var value = MyEnum.One | MyEnum.Two;

Con HasFlag possiamo controllare se uno qualsiasi dei flag è impostato

if(value.HasFlag(MyEnum.One))
    Console.WriteLine("Enum has One");

if(value.HasFlag(MyEnum.Two))
    Console.WriteLine("Enum has Two");

if(value.HasFlag(MyEnum.Three))
    Console.WriteLine("Enum has Three");

Inoltre possiamo scorrere tutti i valori di enum per ottenere tutti i flag impostati

var type = typeof(MyEnum);
var names = Enum.GetNames(type);

foreach (var name in names)
{
    var item = (MyEnum)Enum.Parse(type, name);

    if (value.HasFlag(item))
        Console.WriteLine("Enum has " + name);
}

O

foreach(MyEnum flagToCheck in Enum.GetValues(typeof(MyEnum)))
{
    if(value.HasFlag(flagToCheck))
    {
         Console.WriteLine("Enum has " + flagToCheck);
    }
}

Tutti e tre gli esempi stamperanno:

Enum has One
Enum has Two

Prova i valori enum in stile flags con logica bit a bit

Un valore enum in stile flags deve essere testato con logica bit a bit perché potrebbe non corrispondere a nessun singolo valore.

[Flags]
enum FlagsEnum
{
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
    Option2And3 = Option2 | Option3;

    Default = Option1 | Option3,
}

Il valore Default è in realtà una combinazione di altri due uniti con un OR bit a bit. Quindi per testare la presenza di un flag dobbiamo usare un AND bit a bit.

var value = FlagsEnum.Default;

bool isOption2And3Set = (value & FlagsEnum.Option2And3) == FlagsEnum.Option2And3;

Assert.True(isOption2And3Set);

Enum per corda e schiena

public enum DayOfWeek
{
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday
}

    
// Enum to string
string thursday = DayOfWeek.Thursday.ToString(); // "Thursday"

string seventhDay = Enum.GetName(typeof(DayOfWeek), 6); // "Saturday"

string monday = Enum.GetName(typeof(DayOfWeek), DayOfWeek.Monday); // "Monday"


// String to enum (.NET 4.0+ only - see below for alternative syntax for earlier .NET versions)
DayOfWeek tuesday;
Enum.TryParse("Tuesday", out tuesday); // DayOfWeek.Tuesday

DayOfWeek sunday;
bool matchFound1 = Enum.TryParse("SUNDAY", out sunday); // Returns false (case-sensitive match)

DayOfWeek wednesday;
bool matchFound2 = Enum.TryParse("WEDNESDAY", true, out wednesday); // Returns true; DayOfWeek.Wednesday (case-insensitive match)


// String to enum (all .NET versions)
DayOfWeek friday = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), "Friday"); // DayOfWeek.Friday

DayOfWeek caturday = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), "Caturady"); // Thows ArgumentException

// All names of an enum type as strings
string[] weekdays = Enum.GetNames(typeof(DayOfWeek));

Valore predefinito per enum == ZERO

Il valore predefinito per un enum è zero . Se un enum non definisce un oggetto con un valore pari a zero, il suo valore predefinito sarà zero.

public class Program
{        
    enum EnumExample
    {
        one = 1,
        two = 2
    }
    
    public void Main()
    {              
        var e = default(EnumExample);
        
        if (e == EnumExample.one)
            Console.WriteLine("defaults to one");
        else
            Console.WriteLine("Unknown");    
    }    
}

Esempio: https://dotnetfiddle.net/l5Rwie

Nozioni di base su Enum

Da MSDN :

Un tipo di enumerazione (chiamato anche enumerazione o enumerazione) fornisce un modo efficace per definire un insieme di costanti integrali con nome che possono essere assegnate a una variabile .

Essenzialmente, un enum è un tipo che consente solo un insieme di opzioni finite e ogni opzione corrisponde a un numero. Per impostazione predefinita, tali numeri aumentano nell'ordine in cui i valori sono dichiarati, a partire da zero. Ad esempio, si potrebbe dichiarare un enum per i giorni della settimana:

public enum Day
{
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday
}

Quell'enum potrebbe essere usato così:

// Define variables with values corresponding to specific days
Day myFavoriteDay = Day.Friday;
Day myLeastFavoriteDay = Day.Monday;

// Get the int that corresponds to myFavoriteDay
// Friday is number 4
int myFavoriteDayIndex = (int)myFavoriteDay;

// Get the day that represents number 5
Day dayFive = (Day)5;

Per impostazione predefinita, il tipo sottostante di ciascun elemento enum è int , ma possono essere utilizzati anche byte , sbyte , short , ushort , uint , long e ulong . Se si utilizza un tipo diverso da int , è necessario specificare il tipo utilizzando i due punti dopo il nome dell'enumerazione:

public enum Day : byte 
{
    // same as before 
}

I numeri dopo il nome ora sono byte anziché interi. È possibile ottenere il tipo sottostante dell'enumerazione come segue:

Enum.GetUnderlyingType(typeof(Days)));

Produzione:

System.Byte

Demo: .NET violino

Manipolazione bit a bit tramite enumerazione

Il FlagsAttribute deve essere utilizzato ogni volta che l'enumerable rappresenta una raccolta di flag, piuttosto che un singolo valore. Il valore numerico assegnato a ciascun valore enumerato aiuta a manipolare le enumerazioni utilizzando operatori bit a bit.

Esempio 1: con [bandiere]

[Flags]
enum Colors
{
    Red=1,
    Blue=2,
    Green=4,
    Yellow=8
}

var color = Colors.Red | Colors.Blue;
Console.WriteLine(color.ToString());

stampa rosso, blu

Esempio 2: senza [bandiere]

enum Colors
{
    Red=1,
    Blue=2,
    Green=4,
    Yellow=8
}
var color = Colors.Red | Colors.Blue;
Console.WriteLine(color.ToString());

stampa 3

Usando la notazione << per le bandiere

L'operatore di spostamento a sinistra ( << ) può essere utilizzato nelle dichiarazioni flag enum per garantire che ogni flag abbia esattamente un 1 nella rappresentazione binaria, come dovrebbero essere le bandiere.

Questo aiuta anche a migliorare la leggibilità di enumerazioni di grandi dimensioni con un sacco di bandiere in esse.

[Flags]
public enum MyEnum 
{
    None  = 0,
    Flag1 = 1 << 0,
    Flag2 = 1 << 1,
    Flag3 = 1 << 2,
    Flag4 = 1 << 3,
    Flag5 = 1 << 4,
    ...
    Flag31 = 1 << 30
}

Ora è ovvio che MyEnum contiene solo flag appropriati e non roba disordinata come Flag30 = 1073741822 (o 1111111111111111111111111111111110 in binario) che è inappropriato.

Aggiunta di ulteriori informazioni di descrizione a un valore enum

In alcuni casi è possibile aggiungere una descrizione aggiuntiva a un valore enum, ad esempio quando il valore enum è meno leggibile di quello che si potrebbe desiderare di visualizzare all'utente. In questi casi è possibile utilizzare la classe System.ComponentModel.DescriptionAttribute .

Per esempio:

public enum PossibleResults
{
    [Description("Success")]
    OK = 1,
    [Description("File not found")]
    FileNotFound = 2,
    [Description("Access denied")]
    AccessDenied = 3
}

Ora, se vuoi restituire la descrizione di un valore enum specifico, puoi fare quanto segue:

public static string GetDescriptionAttribute(PossibleResults result)
{
        return ((DescriptionAttribute)Attribute.GetCustomAttribute((result.GetType().GetField(result.ToString())), typeof(DescriptionAttribute))).Description;
}

static void Main(string[] args)
{
    PossibleResults result = PossibleResults.FileNotFound;
    Console.WriteLine(result); // Prints "FileNotFound"
    Console.WriteLine(GetDescriptionAttribute(result)); // Prints "File not found"
}

Questo può anche essere facilmente trasformato in un metodo di estensione per tutte le enumerazioni:

static class EnumExtensions
{
    public static string GetDescription(this Enum enumValue)
    {
        return ((DescriptionAttribute)Attribute.GetCustomAttribute((enumValue.GetType().GetField(enumValue.ToString())), typeof(DescriptionAttribute))).Description;
    }
}

E quindi facilmente utilizzabile in questo modo: Console.WriteLine(result.GetDescription());

Aggiungi e rimuovi i valori dall'enumerazione contrassegnata

Questo codice è per aggiungere e rimuovere un valore da un'istanza enum contrassegnata:

[Flags]
public enum MyEnum
{
    Flag1 = 1 << 0,
    Flag2 = 1 << 1,
    Flag3 = 1 << 2
}

var value = MyEnum.Flag1;

// set additional value
value |= MyEnum.Flag2;  //value is now Flag1, Flag2
value |= MyEnum.Flag3;  //value is now Flag1, Flag2, Flag3

// remove flag
value &= ~MyEnum.Flag2; //value is now Flag1, Flag3    

Le enumerazioni possono avere valori inaspettati

Poiché un enum può essere lanciato su e dal suo tipo integrale sottostante, il valore potrebbe non rientrare nell'intervallo di valori indicato nella definizione del tipo enum.

Sebbene il tipo di DaysOfWeek seguente DaysOfWeek abbia solo 7 valori definiti, può comunque contenere qualsiasi valore int .

public enum DaysOfWeek
{
    Monday = 1,
    Tuesday = 2,
    Wednesday = 3,
    Thursday = 4,
    Friday = 5,
    Saturday = 6,
    Sunday = 7
}

DaysOfWeek d = (DaysOfWeek)31;
Console.WriteLine(d); // prints 31

DaysOFWeek s = DaysOfWeek.Sunday;
s++; // No error

Attualmente non esiste un modo per definire un enum che non abbia questo comportamento.

Tuttavia, i valori di enum non definiti possono essere rilevati utilizzando il metodo Enum.IsDefined . Per esempio,

DaysOfWeek d = (DaysOfWeek)31;
Console.WriteLine(Enum.IsDefined(typeof(DaysOfWeek),d)); // prints False