Condividi tramite

Enumerazioni C#

Suggerimento

Novità dello sviluppo di software? Iniziare prima con le esercitazioni introduttive . Si incontreranno le enumerazioni una volta che è necessario rappresentare un set fisso di scelte nel tuo codice.

Esperienza in un'altra lingua? Le enumerazioni C# funzionano in modo simile alle enumerazioni in Java o C++, con supporto aggiuntivo per i flag di bit e il pattern matching. Scorrere i flag e le sezioni dell'espressione switch alla ricerca di modelli specifici di C#.

Un tipo di enumerazione (o enumerazione) definisce un set di costanti denominate supportate da un valore intero. Usare enumerazioni quando un valore deve essere uno di un set fisso di opzioni, ad esempio giorni della settimana, codici di stato HTTP, livelli di log o indicazioni stradali. Le enumerazioni rendono il codice più leggibile e meno soggetto a errori rispetto alle costanti integer non elaborate perché il compilatore applica i valori denominati.

Dichiarare un'enumerazione

Definire un'enumerazione con la enum parola chiave seguita dal nome del tipo e dai relativi membri:

enum Season
{
    Spring,
    Summer,
    Autumn,
    Winter
}

Per impostazione predefinita, il tipo sottostante è int, e i valori iniziano a partire da 0, incrementando di uno. Season.Spring è 0, Season.Summer è 1, e così via.

Specificare un tipo sottostante e valori espliciti

È possibile scegliere un tipo integrale diverso e assegnare valori espliciti per controllare la rappresentazione numerica:

enum HttpStatus : ushort
{
    OK = 200,
    NotFound = 404,
    InternalServerError = 500
}

Usare valori espliciti quando i numeri hanno un significato esterno, ad esempio codici di stato HTTP o identificatori di protocollo. Il tipo sottostante può essere qualsiasi tipo integrale ad eccezione chardi . Usare byte, short, ushortint, uint, , longo ulong.

Usare enumerazioni nelle espressioni switch

Le enumerazioni funzionano naturalmente con switch espressioni e criteri di ricerca. Il compilatore avvisa se non si gestiscono tutti i membri, che consente di evitare bug quando si aggiunge un nuovo valore in un secondo momento:

static string DescribeSeason(Season season) => season switch
{
    Season.Spring => "Flowers bloom and temperatures rise.",
    Season.Summer => "Long days and warm weather.",
    Season.Autumn => "Leaves change color and fall.",
    Season.Winter => "Short days and cold temperatures.",
    _ => throw new ArgumentOutOfRangeException(nameof(season))
};

var today = Season.Autumn;
Console.WriteLine(DescribeSeason(today));

Il criterio di eliminazione (_) gestisce qualsiasi valore non elencato in modo esplicito. Poiché il tipo sottostante di un'enumerazione è un numero intero, una variabile può contenere un valore che non corrisponde ad alcun membro denominato. Ad esempio, (Season)99 è valido in fase di esecuzione. Il criterio di eliminazione garantisce che l'espressione switch gestisca tali valori imprevisti in modo sicuro. Pattern matching è una funzionalità di C# che testa un valore rispetto a una forma o condizione. In questo esempio, ognuno case controlla se l'enumerazione corrisponde a un membro specifico. Le espressioni switch sono una delle varie forme di pattern matching. Per altre informazioni sui criteri di ricerca, vedere Criteri di ricerca.

Flag di bit

Quando un'enumerazione rappresenta una combinazione di scelte anziché una singola scelta, definire ogni membro come potenza di due e applicare il FlagsAttribute:

[Flags]
enum FileAccess
{
    None = 0,
    Read = 1,
    Write = 2,
    Execute = 4,
    ReadWrite = Read | Write,
    All = Read | Write | Execute
}

Combinare i valori usando l'operatore | e testare i singoli flag usando HasFlag:

var permissions = FileAccess.Read | FileAccess.Write;

Console.WriteLine(permissions);                          // ReadWrite
Console.WriteLine(permissions.HasFlag(FileAccess.Read)); // True
Console.WriteLine(permissions.HasFlag(FileAccess.Execute)); // False

L'attributo [Flags] influisce anche su ToString(). Visualizza i valori combinati come nomi delimitati da virgole (ad esempio Read, Write) invece di un numero non elaborato. Per altre informazioni, vedere System.FlagsAttribute.

Eseguire la conversione tra enumerazioni e numeri interi

Le espressioni cast esplicite converteno tra un'enumerazione e il relativo tipo integer sottostante. Un cast esplicito usa la (Type)value sintassi per indicare al compilatore che si intende eseguire la conversione:

var status = HttpStatus.NotFound;
ushort code = (ushort)status;
Console.WriteLine($"Status: {status} ({code})"); // Status: NotFound (404)

var fromCode = (HttpStatus)200;
Console.WriteLine(fromCode); // OK

Tenere presente che il cast di un numero intero a un enum non convalida se il valore corrisponde a un membro definito. Usare Enum.IsDefined per verificare la validità quando si accetta l'input numerico da origini esterne.

Analizzare le stringhe e scorrere i valori

La Enum classe base fornisce metodi per l'analisi delle stringhe e l'iterazione su tutti i valori definiti:

// Parse a string to an enum value:
var parsed = Enum.Parse<Season>("Winter");
Console.WriteLine(parsed); // Winter

// Try to parse safely. It returns false only when the input can't be parsed. Call Enum.IsDefined to validate named members:
if (Enum.TryParse<Season>("Monsoon", out var unknown))
{
    Console.WriteLine(unknown);
}
else
{
    Console.WriteLine("'Monsoon' is not a valid Season"); // 'Monsoon' is not a valid Season
}

// Iterate over all values in an enum:
foreach (var season in Enum.GetValues<Season>())
{
    Console.WriteLine($"{season} = {(int)season}");
}
// Spring = 0
// Summer = 1
// Autumn = 2
// Winter = 3

Usare Enum.TryParse<TEnum>(String, Boolean, TEnum) anziché Enum.Parse<TEnum>(String) quando l'input potrebbe non essere valido. Restituisce false anziché generare un'eccezione.

Vedere anche

  • Last updated on