Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe Enum

Fornisce la classe base per le enumerazioni.

Spazio dei nomi:  System
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public abstract class Enum : ValueType, 
	IComparable, IFormattable, IConvertible

Il tipo Enum espone i seguenti membri.

  NomeDescrizione
Metodo protettoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEnumInizializza una nuova istanza della classe Enum.
In alto

  NomeDescrizione
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompareToConfronta questa istanza a un oggetto specificato e restituisce un'indicazione dei valori relativi.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEqualsRestituisce un valore che indica se questa istanza è uguale a un oggetto specificato. (Esegue l'override di ValueType.Equals(Object)).
Metodo protettoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreFinalize Consente a un oggetto di provare a liberare risorse ed eseguire altre operazioni di pulizia prima che l'oggetto stesso venga reclamato dalla procedura di Garbage Collection. (Ereditato da Object)
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreFormatConverte il valore specificato di un determinato tipo enumerato nella rappresentazione in forma di stringa equivalente, secondo il formato specificato.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetHashCodeViene restituito il codice hash per il valore dell'istanza. (Esegue l'override di ValueType.GetHashCode()).
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetNameRestituisce il nome della costante nell'enumerazione del valore specificato.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetNamesRestituisce una matrice dei nomi delle costanti in una enumerazione specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkGetTypeCodeRestituisce l'oggetto TypeCode sottostante per l'istanza.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetUnderlyingTypeRestituisce il tipo sottostante dell'enumerazione specificata.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetValuesRestituisce una matrice dei valori delle costanti in una enumerazione specificata.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreHasFlagDetermina se uno o più campi di bit vengono impostati nell'istanza corrente.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIsDefinedIndica l'eventuale presenza di una costante di valore specificato in una determinata enumerazione.
Metodo protettoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreMemberwiseClone Crea una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object)
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreParse(Type, String)Converte la rappresentazione in forma di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreParse(Type, String, Boolean)Converte la rappresentazione in forma di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita senza distinzione tra maiuscole e minuscole.
Metodo pubblicoMembro staticoToObject(Type, Byte)Converte l'Unsigned Integer a 8 bit specificato in un membro di enumerazione.
Metodo pubblicoMembro staticoToObject(Type, Int16)Converte il Signed Integer a 16 bit specificato in un membro di enumerazione.
Metodo pubblicoMembro staticoToObject(Type, Int32)Converte il Signed Integer a 32 bit specificato in un membro di enumerazione.
Metodo pubblicoMembro staticoToObject(Type, Int64)Converte il Signed Integer a 64 bit specificato in un membro di enumerazione.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToObject(Type, Object)Converte l'oggetto specificato con un Integer in un membro di enumerazione.
Metodo pubblicoMembro staticoToObject(Type, SByte)Converte il valore del Signed Integer a 8 bit specificato in un membro di enumerazione.
Metodo pubblicoMembro staticoToObject(Type, UInt16)Converte il valore dell'Unsigned Integer a 16 bit specificato in un membro di enumerazione.
Metodo pubblicoMembro staticoToObject(Type, UInt32)Converte il valore dell'Unsigned Integer a 32 bit specificato in un membro di enumerazione.
Metodo pubblicoMembro staticoToObject(Type, UInt64)Converte il valore dell'Unsigned Integer a 64 bit specificato in un membro di enumerazione.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToString()Converte il valore dell'istanza corrente nell'equivalente rappresentazione in forma di stringa. (Esegue l'override di ValueType.ToString()).
Metodo pubblicoSupportato da XNA FrameworkToString(IFormatProvider) Obsoleta. Questo overload del metodo è obsoleto; utilizzare Enum.ToString().
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToString(String)Converte il valore dell'istanza corrente nella rappresentazione in forma di stringa equivalente, utilizzando il formato specificato.
Metodo pubblicoSupportato da XNA FrameworkToString(String, IFormatProvider) Obsoleta. Questo overload del metodo è obsoleto; utilizzare Enum.ToString(String).
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreTryParse<TEnum>(String, TEnum)Converte la rappresentazione in forma di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Il valore restituito indica se la conversione è stata eseguita correttamente.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreTryParse<TEnum>(String, Boolean, TEnum)Converte la rappresentazione in forma di stringa del nome o del valore numerico di una o più costanti enumerate in un oggetto enumerato equivalente. Un parametro specifica se l'operazione verrà eseguita con distinzione tra maiuscole e minuscole. Il valore restituito indica se la conversione è stata eseguita correttamente.
In alto

  NomeDescrizione
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToBooleanInfrastruttura. Converte il valore corrente in un valore booleano basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToByteInfrastruttura. Converte il valore corrente in un valore intero senza segno a 8 bit basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToCharInfrastruttura. Converte il valore corrente in un carattere Unicode basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDateTimeInfrastruttura. Converte il valore corrente in un oggetto DateTime basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDecimalInfrastruttura. Converte il valore corrente in un oggetto Decimal basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDoubleInfrastruttura. Converte il valore corrente in un numero in virgola mobile e precisione doppia basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt16Infrastruttura. Converte il valore corrente in un valore intero con segno a 16 bit basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt32Infrastruttura. Converte il valore corrente in un valore intero con segno a 32 bit basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt64Infrastruttura. Converte il valore corrente in un valore intero con segno a 64 bit basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToSByteInfrastruttura. Converte il valore corrente in un valore intero con segno a 8 bit basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToSingleInfrastruttura. Converte il valore corrente in un numero a virgola mobile e con precisione singola in base al tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToTypeInfrastruttura. Converte il valore corrente in un tipo specificato basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt16Infrastruttura. Converte il valore corrente in un valore intero senza segno a 16 bit basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt32Infrastruttura. Converte il valore corrente in un valore intero senza segno a 32 bit basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt64Infrastruttura. Converte il valore corrente in un valore intero senza segno a 64 bit basato sul tipo sottostante.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIFormattable.ToStringInfrastruttura. Obsoleta. Questo overload del metodo è obsoleto; utilizzare Enum.ToString(String).
In alto

Un'enumerazione è un set di costanti denominate il cui tipo sottostante è qualunque tipo integrale. Se non è specificato alcun tipo sottostante, verrà utilizzato Int32. Enum è la classe di base per tutte le enumerazioni in .NET Framework.

In Enum vengono forniti metodi per confrontare le istanze di questa classe, convertire il valore di un'istanza nella relativa rappresentazione di stringa, convertire la rappresentazione di stringa di un numero in un'istanza di questa classe e creare un'istanza di un'enumerazione e di un valore specificati.

È inoltre possibile utilizzare una enumerazione come un campo di bit. Per ulteriori informazioni, vedere la sezione relativa ai membri non esclusivi e all'attributo di flag e l'argomento FlagsAttribute.

Creazione di tipo di enumerazione

I linguaggi di programmazione sono in genere dotati di una sintassi, utilizzata per dichiarare un'enumerazione costituita da un set di costanti denominate e dai relativi valori. Nell'esempio seguente viene illustrata la sintassi utilizzata da C# e Visual Basic per definire un'enumerazione. Crea un'enumerazione denominata ArrivalStatus con tre membri, ovvero ArrivalStatus.Early, ArrivalStatus.OnTime e ArrivalStatus.Late. Si noti che in entrambi casi l'enumerazione non eredita in modo esplicito da Enum. La relazione di ereditarietà è gestita in modo implicito dal compilatore.


public enum ArrivalStatus { Late=-1, OnTime=0, Early=1 };


Nota di avvisoAttenzione

Non si deve mai creare un tipo di enumerazione il cui tipo sottostante è non integrale o Char. Anche se è possibile creare tale tipo di enumerazione tramite reflection, le chiamate al metodo che utilizzano il tipo risultante non sono affidabili e potrebbero generare eccezioni aggiuntive.

Creazione di un'istanza di un tipo di enumerazione

È possibile creare un'istanza di un tipo di enumerazione proprio come si crea un'istanza di qualsiasi altro tipo di valore, ossia dichiarando una variabile e assegnandole una delle costanti dell'enumerazione. Nell'esempio seguente viene creata un'istanza di un oggetto ArrivalStatus il cui valore è ArrivalStatus.OnTime.


public class Example
{
   public static void Main()
   {
      ArrivalStatus status = ArrivalStatus.OnTime;
      Console.WriteLine("Arrival Status: {0} ({0:D})", status);
   }
}
// The example displays the following output:
//       Arrival Status: OnTime (0)


È anche possibile creare un'istanza di un valore di enumerazione nei modi seguenti:

  • Tramite le funzionalità di un particolare linguaggio di programmazione per eseguire il cast (come in C#) o convertire (come in Visual Basic) un valore intero in un valore di enumerazione. Nell'esempio seguente viene creato un oggetto ArrivalStatus il cui valore è ArrivalStatus.Early.

    
    ArrivalStatus status2 = (ArrivalStatus) 1;
    Console.WriteLine("Arrival Status: {0} ({0:D})", status2);
    // The example displays the following output:
    //       Arrival Status: Early (1)
    
    
    
  • Tramite la chiamata al relativo costruttore predefinito. Come mostra l'esempio seguente, in questo caso il valore sottostante dell'istanza dell'enumerazione è 0. Tuttavia, questo non è necessariamente il valore di una costante valida nell'enumerazione.

    
    ArrivalStatus status1 = new ArrivalStatus();
    Console.WriteLine("Arrival Status: {0} ({0:D})", status1);
    // The example displays the following output:
    //       Arrival Status: OnTime (0)
    
    
    
  • Chiamando il metodo Parse o TryParse per analizzare una stringa che contiene il nome di una costante nell'enumerazione. Per ulteriori informazioni, vedere la sezione relativa all'analisi di valori di enumerazione.

  • Chiamando il metodo ToObject per convertire un valore integrale in un tipo di enumerazione. Per ulteriori informazioni, vedere la sezione relativa all'esecuzione di conversioni.

Procedure consigliate per l'enumerazione

Si consiglia di utilizzare le procedure consigliate seguenti quando si definiscono i tipi di enumerazione:

  • Se non è stato definito un membro di enumerazione il cui valore è 0, considerare la creazione di una costante enumerata None. Per impostazione predefinita, la memoria utilizzata per l'enumerazione viene inizializzata su zero da Common Language Runtime. Di conseguenza, se non si definisce una costante il cui valore è zero, l'enumerazione conterrà un valore non valido quando verrà creata.

  • Se l'applicazione deve rappresentare un caso predefinito ovvio, è consigliabile utilizzare una costante enumerata il cui valore è zero per rappresentarlo. Se non sono presenti casi predefiniti, è preferibile utilizzare una costante enumerata il cui valore è zero per specificare il caso non rappresentato da nessuna delle altre costanti enumerate.

  • Non specificare le costanti enumerate riservate per utilizzi futuri.

  • Quando si definisce un metodo o una proprietà che accetta una costante enumerata come valore, è consigliabile convalidare il valore perché è possibile eseguire il cast di un valore numerico sul tipo di enumerazione anche se tale valore numerico non è definito nell'enumerazione.

Procedure consigliate aggiuntive per tipi di enumerazione le cui costanti sono campi di bit vengono elencate nella sezione relativa ai membri non esclusivi e all'attributo di flag.

Esecuzione di operazioni con enumerazioni

Non è possibile definire nuovi metodi quando si crea un'enumerazione. Tuttavia, un tipo di enumerazione eredita un set completo di metodi statici e di istanza dalla classe Enum. Nelle sezioni seguenti viene eseguito un sondaggio sulla maggior parte di questi metodi, oltre a molti altri metodi che sono di uso comune quando si utilizzano valori di enumerazione.

1zt1ybx4.collapse_all(it-it,VS.110).gifEsecuzione di conversioni

È possibile convertire un membro di enumerazione e il relativo tipo sottostante tramite un operatore di cast (in C#) o di conversione (in Visual Basic). Nell'esempio seguente vengono utilizzati casting o operatori di conversione per eseguire le conversioni da un Integer a un valore di enumerazione e da un valore di enumerazione a un Integer.


int value3 = 2;
ArrivalStatus status3 = (ArrivalStatus) value3;

int value4 = (int) status3;


La classe Enum include anche un metodo ToObject che converte un valore di un tipo integrale in un valore di enumerazione. Nell'esempio riportato di seguito viene utilizzato il metodo ToObject(Type, Int32) per convertire Int32 in un valore ArrivalStatus. Si noti che, poiché ToObject restituisce un valore di tipo Object, l'utilizzo di un operatore di cast o di conversione potrebbe ancora essere necessario per convertire l'oggetto al tipo di enumerazione.


int number = -1;
ArrivalStatus arrived = (ArrivalStatus) ArrivalStatus.ToObject(typeof(ArrivalStatus), number);


Quando si converte un Integer in un valore di enumerazione, è possibile assegnare un valore che non è effettivamente un membro dell'enumerazione. Per evitare che ciò si verifichi, è possibile passare l'Integer al metodo IsDefined prima di eseguire la conversione. Nell'esempio seguente viene utilizzato questo metodo per determinare se è possibile convertire gli elementi in una matrice di valori Integer in valori ArrivalStatus.


using System;

public enum ArrivalStatus { Unknown=-3, Late=-1, OnTime=0, Early=1 };

public class Example
{
   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 {0:N0} to {1}", value, 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


Anche se la classe Enum fornisce implementazioni esplicite dell'interfaccia IConvertible per la conversione da un valore di enumerazione a un tipo integrale, è necessario utilizzare i metodi della classe Convert, ad esempio ToInt32, per eseguire queste conversioni. Nell'esempio seguente viene illustrato come è possibile utilizzare il metodo GetUnderlyingType insieme al metodo Convert.ChangeType per convertire un valore di enumerazione nel tipo sottostante. Si noti che in questo esempio non è necessario che il tipo sottostante dell'enumerazione sia noto in fase di compilazione.


ArrivalStatus status = ArrivalStatus.Early;
var number = Convert.ChangeType(status, Enum.GetUnderlyingType(typeof(ArrivalStatus)));
Console.WriteLine("Converted {0} to {1}", status, number);
// The example displays the following output:
//       Converted Early to 1


1zt1ybx4.collapse_all(it-it,VS.110).gifAnalisi di valori di enumerazione

I metodi Parse e TryParse consentono la conversione della rappresentazione di stringa di un valore di enumerazione per tale valore. La rappresentazione in forma di stringa può essere il nome o il valore sottostante di una costante di enumerazione. Si noti che i metodi di analisi convertiranno correttamente rappresentazioni di stringa di numeri che non sono membri di una particolare enumerazione se le stringhe possono essere convertite in un valore del tipo sottostante dell'enumerazione. Per evitare che ciò si verifichi, è possibile chiamare il metodo IsDefined per assicurarsi che il risultato del metodo di analisi sia un valore di enumerazione valido. Nell'esempio viene illustrato questo approccio e vengono dimostrate le chiamate a entrambi i metodi Parse(Type, String) e Enum.TryParse<TEnum>(String, TEnum). Si noti che il metodo di analisi non generico restituisce un oggetto di cui può essere necessario eseguire il cast (in C#) o che è necessario convertire (in Visual Basic) nel tipo di enumerazione appropriato.


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 '{0}' to {1}", number, status1);
}
catch (FormatException) {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}   

ArrivalStatus status2;
if (Enum.TryParse<ArrivalStatus>(name, out status2)) {
   if (!(Enum.IsDefined(typeof(ArrivalStatus), status2)))
      status2 = ArrivalStatus.Unknown;
   Console.WriteLine("Converted '{0}' to {1}", name, status2);
}
else {
   Console.WriteLine("Unable to convert '{0}' to an ArrivalStatus value.", 
                     number);
}
// The example displays the following output:
//       Converted '-1' to Late
//       Converted 'Early' to Early


1zt1ybx4.collapse_all(it-it,VS.110).gifFormattazione di valori di enumerazione

È possibile convertire i valori di enumerazione in relative rappresentazioni di stringa chiamando il metodo statico Format, come gli overload del metodo ToString dell'istanza. È possibile utilizzare una stringa di formato per controllare esattamente il modo secondo cui un valore di enumerazione viene rappresentato come una stringa. Per ulteriori informazioni, vedere Stringhe di formato di enumerazione. Nell'esempio seguente viene utilizzata ogni stringa di formato dell'enumerazione supportata per convertire un membro dell'enumerazione ArrivalStatus nelle rappresentazioni di stringa.


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


1zt1ybx4.collapse_all(it-it,VS.110).gifScorrere i membri di enumerazione

Il tipo Enum non implementa l'interfaccia IEnumerable o IEnumerable<T> che consentirebbe di iterare i membri di un insieme tramite un costrutto foreach (in C#) o For Each (in Visual Basic). È tuttavia possibile enumerare membri in due modi.

  • È possibile chiamare il metodo GetNames per recuperare una matrice di stringhe che contiene i nomi dei membri di enumerazione. Successivamente, per ogni elemento della stringa, è possibile chiamare il metodo Parse per convertire la stringa nel valore di enumerazione equivalente. Questo approccio viene illustrato nell'esempio seguente:

    
    string[] names = Enum.GetNames(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    Array.Sort(names);
    foreach (var name in names) {
       ArrivalStatus status = (ArrivalStatus) Enum.Parse(typeof(ArrivalStatus), name);
       Console.WriteLine("   {0} ({0:D})", status);
    }
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          Early (1)
    //          Late (-1)
    //          OnTime (0)
    //          Unknown (-3)      
    
    
    
  • È possibile chiamare il metodo GetValues per recuperare una matrice che contiene i valori sottostanti nell'enumerazione. Successivamente, per ogni elemento della matrice, è possibile chiamare il metodo ToObject per convertire il valore intero nel valore di enumerazione equivalente. Questo approccio viene illustrato nell'esempio seguente:

    
    var values = Enum.GetValues(typeof(ArrivalStatus));
    Console.WriteLine("Members of {0}:", typeof(ArrivalStatus).Name);
    foreach (var value in values) {
       ArrivalStatus status = (ArrivalStatus) Enum.ToObject(typeof(ArrivalStatus), value);
       Console.WriteLine("   {0} ({0:D})", status);
    }                                       
    // The example displays the following output:
    //       Members of ArrivalStatus:
    //          OnTime (0)
    //          Early (1)
    //          Unknown (-3)
    //          Late (-1)
    
    
    

Membri non esclusivi e attributo di flag

Un utilizzo comune di un'enumerazione consiste nel rappresentare un set di valori che si escludono a vicenda. Ad esempio, un'istanza di ArrivalStatus può disporre di un valore Early, OnTime o Late. Per il valore di un'istanza di ArrivalStatus non è sensato riflettere più di una costante dell'enumerazione.

In altri casi, tuttavia, il valore di un oggetto enumerazione può includere più membri di enumerazione e ogni membro rappresenta un campo di bit nel valore di enumerazione. L'attributo FlagsAttribute può essere utilizzato per indicare che l'enumerazione è costituita da campi di bit. Ad esempio, un'enumerazione denominata Pets potrebbe essere utilizzata per indicare i tipi di animali domestici in una famiglia. Può essere definito nel modo indicato di seguito.


[Flags] public enum Pets { None=0, Dog=1, Cat=2, Bird=4, Rodent=8,
                           Reptile=16, Other=32 };



L'enumerazione Pets può esser quindi utilizzata come illustrato nell'esempio riportato di seguito.


Pets familyPets = Pets.Dog | Pets.Cat;
Console.WriteLine("Pets: {0:G} ({0:D})", familyPets);
// The example displays the following output:
//       Pets: Dog, Cat (3)      


Le procedure consigliate seguenti devono essere utilizzate quando si definisce un'enumerazione bit per bit e si applica l'attributo FlagsAttribute.

  • Utilizzare l'attributo personalizzato FlagsAttribute per un'enumerazione solo se è necessario eseguire un'operazione bit per bit (AND, OR, EXCLUSIVE OR) su un valore numerico.

  • Definire le costanti di enumerazione come potenze di due, ossia 1, 2, 4, 8 e così via. Questo significa che i singoli flag nelle costanti di enumerazione combinate non si sovrappongono.

  • È consigliabile creare una costante enumerata per le combinazioni di flag più comuni. Se ad esempio si utilizza un'enumerazione per le operazioni di I/O sui file che contiene le costanti enumerate Read = 1 e Write = 2, creare la costante enumerata ReadWrite = Read OR Write, che unisce i flag Read e Write. L'operazione OR bit per bit utilizzata per unire i flag costituisce una funzionalità avanzata che non dovrebbe essere richiesta per attività semplici, ma solo in determinate circostanze.

  • Prestare attenzione se si definisce un numero negativo come costante enumerata di flag, perché molte posizioni di flag potrebbero essere impostate su 1, creando confusione nel codice e favorendo gli errori.

  • Un modo conveniente per testare se un flag viene impostato in un valore numerico consiste nel chiamare il HasFlag dell'istanza, come mostrato nell'esempio seguente.

    
    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.      
    
    
    

    È equivalente a eseguire un'operazione AND bit per bit tra il valore numerico e la costante enumerata di flag, che imposta su zero tutti i bit del valore numerico che non corrispondono al flag, quindi a verificare se il risultato dell'operazione è uguale alla costante enumerata di flag. Tale situazione è illustrata nell'esempio seguente.

    
    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.      
    
    
    
  • Utilizzare None come nome della costante enumerata di flag il cui valore è zero. Non è possibile utilizzare la costante enumerata None in un'operazione AND bit per bit per verificare un flag, perché il risultato è sempre pari a zero. È tuttavia possibile eseguire un confronto logico, non bit per bit, tra il valore numerico e la costante enumerata None per determinare se alcuni bit del valore numerico sono impostati. Tale situazione è illustrata nell'esempio seguente.

    
    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.      
    
    
    
  • Non definire un valore di enumerazione al solo scopo di rispecchiare lo stato dell'enumerazione stessa. Ad esempio, non definire una costante di enumerazione che si limita a contrassegnare la fine dell'enumerazione. Se è necessario determinare l'ultimo valore dell'enumerazione, controllare in modo esplicito tale valore. È inoltre possibile effettuare un controllo di intervallo della prima e dell'ultima costante enumerata se tutti i valori dell''intervallo sono validi.

Nell'esempio seguente viene illustrato l'utilizzo di un'enumerazione per la rappresentazione di valori denominati e di un'altra enumerazione per la rappresentazione di campi di bit denominati.


using System;

public class EnumTest {
    enum Days { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday };
    enum BoilingPoints { Celsius = 100, Fahrenheit = 212 };
    [FlagsAttribute]
    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: {0}", myColors);
    }
}


.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Questo tipo è thread-safe.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft