Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe FlagsAttribute

 

Indica che un'enumerazione può essere gestita come un campo di bit, ovvero un set di flag.

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


[SerializableAttribute]
[AttributeUsageAttribute(AttributeTargets.Enum, Inherited = false)]
[ComVisibleAttribute(true)]
public class FlagsAttribute : Attribute

NomeDescrizione
System_CAPS_pubmethodFlagsAttribute()

Inizializza una nuova istanza della classe FlagsAttribute.

NomeDescrizione
System_CAPS_pubpropertyTypeId

Quando implementato in una classe derivata, ottiene un identificatore univoco per questo Attribute. (Ereditato da Attribute.)

NomeDescrizione
System_CAPS_pubmethodEquals(Object)

Questa API supporta l'infrastruttura di prodotto e non deve essere usata direttamente dal codice. Restituisce un valore che indica se questa istanza è uguale ad un oggetto specificato. (Ereditato da Attribute.)

System_CAPS_protmethodFinalize()

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.)

System_CAPS_pubmethodGetHashCode()

Restituisce il codice hash per questa istanza. (Ereditato da Attribute.)

System_CAPS_pubmethodGetType()

Ottiene il Type dell'istanza corrente. (Ereditato da Object.)

System_CAPS_pubmethodIsDefaultAttribute()

Quando viene eseguito l'override in una classe derivata, indica se il valore di questa istanza è il valore predefinito per la classe derivata. (Ereditato da Attribute.)

System_CAPS_pubmethodMatch(Object)

Quando viene eseguito l'override in una classe derivata, restituisce un valore che indica se questa istanza equivale a un oggetto specificato. (Ereditato da Attribute.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object.)

System_CAPS_pubmethodToString()

Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object.)

NomeDescrizione
System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetIDsOfNames(Guid, IntPtr, UInt32, UInt32, IntPtr)

Esegue il mapping di un set di nomi a un corrispondente set di identificatori di dispatch. (Ereditato da Attribute.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Recupera le informazioni sui tipi per un oggetto, che possono essere utilizzate per ottenere informazioni sul tipo per un'interfaccia. (Ereditato da Attribute.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfoCount(UInt32)

Recupera il numero di interfacce di informazioni sui tipi che un oggetto fornisce (0 o 1). (Ereditato da Attribute.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.Invoke(UInt32, Guid, UInt32, Int16, IntPtr, IntPtr, IntPtr, IntPtr)

Fornisce l'accesso alle proprietà ed ai metodi esposti da un oggetto. (Ereditato da Attribute.)

Campi di bit vengono generalmente utilizzati per gli elenchi di elementi che possono ricorrere in combinazioni, mentre costanti di enumerazione sono in genere utilizzati per elenchi di elementi si escludono a vicenda.Di conseguenza, i campi di bit sono progettati per essere combinati con un'operazione OR bit per bit per generare valori senza nome, mentre non lo sono costanti enumerate.Linguaggi di variano l'utilizzo di campi di bit rispetto alle costanti di enumerazione.

AttributeUsageAttribute viene applicato a questa classe e il relativo Inherited proprietà specifica false.Questo attributo può essere applicato solo alle enumerazioni.

  • Utilizzare il FlagsAttribute attributo personalizzato per un'enumerazione solo se è un'operazione OR bit per bit (AND, OR esclusivo o) deve essere eseguita su un valore numerico.

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

  • È consigliabile creare una costante enumerata per combinazioni di flag comunemente utilizzati.Ad esempio, se si dispone di un'enumerazione utilizzata per le operazioni dei / o file che contiene le costanti enumerate Read = 1 e Write = 2, creare la costante enumerata ReadWrite = Read OR Write, che combina la Read e Write flag.Inoltre, l'operazione OR bit per bit utilizzato per combinare i flag può essere considerata un concetto avanzato in alcune circostanze non era necessaria per eseguire semplici operazioni.

  • Prestare attenzione se si definisce un numero negativo come costante enumerata di flag poiché molte posizioni di flag potrebbero essere impostati su 1, che potrebbe rendere il codice confusione e favorendo gli errori.

  • Un modo pratico per verificare se un flag è impostato in un valore numerico per eseguire un bit per bit e operazione tra il valore numerico e la costante enumerata di flag, che imposta il valore numerico da zero che non corrispondono al flag di tutti i bit, quindi verificare se il risultato di tale operazione è uguale alla costante enumerata di flag.

  • Utilizzare None come nome del flag enumerata costante il cui valore è zero.Non è possibile utilizzare il None costante enumerata in un'operazione AND bit per bit per verificare un flag perché il risultato è sempre zero.Tuttavia, è possibile eseguire la logica, non un confronto bit per bit tra il valore numerico e None costante enumerata per determinare se sono impostati tutti i bit del valore numerico.

    Se si crea un'enumerazione di valori anziché un'enumerazione di flag, è comunque utile per creare un None costante enumerata.Il motivo è che 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 viene creato.

    Se esiste un caso predefinito ovvio che deve rappresentare l'applicazione, è consigliabile utilizzare una costante enumerata il cui valore è zero per rappresentare il valore predefinito.Se non esiste alcun caso predefinito, prendere in considerazione l'utilizzo di una costante enumerata il cui valore è zero che indica il caso in cui non è rappresentato da una delle costanti enumerate.

  • Non definire un valore di enumerazione esclusivamente per rispecchiare lo stato dell'enumerazione stessa.Ad esempio, si definisce una costante enumerata che contrassegna semplicemente la fine dell'enumerazione.Se è necessario determinare l'ultimo valore dell'enumerazione, controllare in modo esplicito tale valore.Inoltre, è possibile eseguire un controllo dell'intervallo per la costante enumerata e il cognome se tutti i valori all'interno dell'intervallo sono validi.

  • Non specificare costanti enumerate riservate per utilizzi futuri.

  • Quando si definisce un metodo o proprietà che accetta una costante enumerata come valore, considerare la convalida del valore.Il motivo è che, anche se tale valore numerico non è definito nell'enumerazione, è possibile impostare un valore numerico al tipo di enumerazione.

Esempio di codice seguente viene illustrato l'utilizzo del FlagsAttribute dell'attributo e viene illustrato l'effetto sul ToString metodo che utilizza FlagsAttribute su un Enum dichiarazione.

using System;

class Example
{
   // Define an Enum without FlagsAttribute.
   enum SingleHue : short
   {
      None = 0,
      Black = 1,
      Red = 2,
      Green = 4,
      Blue = 8
   };

   // Define an Enum with FlagsAttribute.
   [FlagsAttribute] 
   enum MultiHue : short
   {
      None = 0,
      Black = 1,
      Red = 2,
      Green = 4,
      Blue = 8
   };

   static void Main( )
   {
      // Display all possible combinations of values.
      Console.WriteLine( 
           "All possible combinations of values without FlagsAttribute:");
      for(int val = 0; val <= 16; val++ )
         Console.WriteLine( "{0,3} - {1:G}", val, (SingleHue)val);

      // Display all combinations of values, and invalid values.
      Console.WriteLine( 
           "\nAll possible combinations of values with FlagsAttribute:");
      for( int val = 0; val <= 16; val++ )
         Console.WriteLine( "{0,3} - {1:G}", val, (MultiHue)val);
   } 
} 
// The example displays the following output:
//       All possible combinations of values without FlagsAttribute:
//         0 - None
//         1 - Black
//         2 - Red
//         3 - 3
//         4 - Green
//         5 - 5
//         6 - 6
//         7 - 7
//         8 - Blue
//         9 - 9
//        10 - 10
//        11 - 11
//        12 - 12
//        13 - 13
//        14 - 14
//        15 - 15
//        16 - 16
//       
//       All possible combinations of values with FlagsAttribute:
//         0 - None
//         1 - Black
//         2 - Red
//         3 - Black, Red
//         4 - Green
//         5 - Black, Green
//         6 - Red, Green
//         7 - Black, Red, Green
//         8 - Blue
//         9 - Black, Blue
//        10 - Red, Blue
//        11 - Black, Red, Blue
//        12 - Green, Blue
//        13 - Black, Green, Blue
//        14 - Red, Green, Blue
//        15 - Black, Red, Green, Blue
//        16 - 16

Universal Windows Platform
Disponibile da 4.5
.NET Framework
Disponibile da 1.1
Portable Class Library
Supportato in: portable .NET platforms
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1

Eventuali membri pubblici statici (Shared in Visual Basic) di questo tipo sono thread-safe. I membri di istanza non sono garantiti come thread-safe.

Torna all'inizio
Mostra: