Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

FlagsAttribute-Klasse

 

Veröffentlicht: Oktober 2016

Gibt an, dass eine Enumeration als Bitfeld, d. h. als Gruppe von Flags, behandelt werden kann.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

System.Object
  System.Attribute
    System.FlagsAttribute

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

NameBeschreibung
System_CAPS_pubmethodFlagsAttribute()

Initialisiert eine neue Instanz der FlagsAttribute-Klasse.

NameBeschreibung
System_CAPS_pubpropertyTypeId

Ruft bei Implementierung in einer abgeleiteten Klasse einen eindeutigen Bezeichner für dieses Attribute ab.(Geerbt von „Attribute“.)

NameBeschreibung
System_CAPS_pubmethodEquals(Object)

Diese API unterstützt die Produkt Infrastruktur und sollte nicht direkt aus dem Code verwendet werden. Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.(Geerbt von „Attribute“.)

System_CAPS_protmethodFinalize()

Gibt einem Objekt Gelegenheit, Ressourcen freizugeben und andere Bereinigungen durchzuführen, bevor es von der Garbage Collection freigegeben wird. (Geerbt von „Object“.)

System_CAPS_pubmethodGetHashCode()

Gibt den Hashcode für diese Instanz zurück.(Geerbt von „Attribute“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodIsDefaultAttribute()

Gibt beim Überschreiben in einer abgeleiteten Klasse an, ob der Wert der Instanz der Standardwert für die abgeleitete Klasse ist.(Geerbt von „Attribute“.)

System_CAPS_pubmethodMatch(Object)

Ruft beim Überschreiben in einer abgeleiteten Klasse gibt einen Wert, der angibt, ob diese Instanz gleich ein angegebenen Objekt ist.(Geerbt von „Attribute“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_pubmethodToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.(Geerbt von „Object“.)

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

Ordnet eine Reihe von Namen einer entsprechenden Reihe von Dispatchbezeichnern zu.(Geerbt von „Attribute“.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfo(UInt32, UInt32, IntPtr)

Ruft die Typinformationen für ein Objekt ab, mit deren Hilfe die Typinformationen für eine Schnittstelle abgerufen werden können.(Geerbt von „Attribute“.)

System_CAPS_pubinterfaceSystem_CAPS_privmethod_Attribute.GetTypeInfoCount(UInt32)

Ruft die Anzahl der Schnittstellen mit Typinformationen ab, die von einem Objekt bereitgestellt werden (0 oder 1).(Geerbt von „Attribute“.)

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

Stellt den Zugriff auf von einem Objekt verfügbar gemachte Eigenschaften und Methoden bereit.(Geerbt von „Attribute“.)

Bitfelder dienen im Allgemeinen für Listen von Elementen, die kombiniert auftreten können, während Enumerationskonstanten im Allgemeinen für Listen sich gegenseitig ausschließende Elemente verwendet werden. Daher werden Bitfelder mit einer bitweisen OR-Operation zum Generieren nicht benannter Werte kombiniert werden, wohingegen Enumerationskonstanten entwickelt. Sprachen, die in der Verwendung von Bitfeldern, die im Gegensatz zu Enumerationskonstanten unterschiedlich sein.

AttributeUsageAttribute Diese Klasse angewendet wird und dessen Inherited Eigenschaft gibt false. Dieses Attribut kann nur auf Enumerationen angewendet werden.

  • Verwenden der FlagsAttribute benutzerdefiniertes Attribut für eine Enumeration nur, wenn eine bitweise Operation (AND, OR, EXCLUSIVE OR) ausgeführt wird, die auf einem numerischen Wert.

  • Definieren Sie Enumerationskonstanten in Potenzen von zwei, d. h. 1, 2, 4, 8 und So weiter. Dies bedeutet, dass die einzelnen Flags in kombinierten Enumerationskonstanten nicht überschneiden.

  • Sollten Sie eine Enumerationskonstante für häufig verwendete Flag-Kombinationen zu erstellen. Beispielsweise ist eine Enumeration für-e/a-Dateivorgänge enthält, die die Enumerationskonstanten Read = 1 und Write = 2, sollten Sie die Enumerationskonstante erstellen ReadWrite = Read OR Write, kombiniert die Read und Write Flags. Darüber hinaus kann die bitweise OR-Operation zum Kombinieren des Flags ein erweitertes Konzept in einigen Fällen angesehen, die nicht für einfache Aufgaben erforderlich sein soll.

  • Seien Sie vorsichtig, wenn Sie eine negative Zahl als eine Flagenumerationskonstante definieren, da viele Flagpositionen auf 1 festgelegt werden, der Code dadurch verwirrend wird und Codierungsfehler fördern kann.

  • Eine bequeme Möglichkeit zum Überprüfen, ob ein Flag in einem numerischen Wert festgelegt ist, führen Sie eine bitweise ist und -Operation zwischen dem numerischen Wert und dem Flagenumerationskonstante, die alle in den numerischen Wert 0 (null), die nicht dem Flag entsprechen, testen, ob das Ergebnis des Vorgangs die Enumerationskonstante Flag ist.

  • Mit None wie der Namen des Flags Konstante aufgelistet, deren Wert 0 (null) ist. Sie können keine der None Enumerationskonstante in eine bitweise AND-Operation für ein Flag zu testen, da das Ergebnis immer 0 (null) ist. Allerdings können Sie eine logische ausführen nicht bitweisen Vergleich zwischen dem numerischen Wert und die None Enumerationskonstante zu bestimmen, ob in dem numerischen Wert Bits festgelegt sind.

    Wenn Sie eine anstelle einer Flagenumeration erstellen, es lohnt sich immer noch zum Erstellen einer None Enumerationskonstante. Der Grund hierfür ist, dass standardmäßig der für die Enumeration verwendete Speicher mit 0 (null) initialisiert wird von der common Language Runtime. Daher, wenn Sie keine Konstante definieren, deren Wert 0 (null) ist, wird die Enumeration einen ungültigen Wert enthalten bei der Erstellung.

    Es ist ein offensichtlicher Standardfall muss die Anwendung darstellen, sollten eine Enumerationskonstante, deren Wert 0 (null), der Standard darstellen. Wenn kein solcher Fall vorhanden ist, sollten Sie eine Enumerationskonstante, die mit dem Wert 0 (null) ist den Fall, bedeutet dies, der von keiner anderen Enumerationskonstanten dargestellt wird.

  • Definieren Sie einen Enumerationswert ausschließlich, um den Zustand der Enumeration selbst zu spiegeln. Definieren Sie z. B. keine Enumerationskonstante, die lediglich das Ende der Enumeration kennzeichnet. Wenn Sie den letzten Wert der Enumeration bestimmen müssen, überprüfen Sie den Wert explizit. Darüber hinaus können Sie eine Überprüfung der Bereich für die ersten und letzten Enumerationskonstante ausführen, wenn alle Werte innerhalb des Bereichs gültig sind.

  • Geben Sie keine Enumerationskonstanten an, die für die zukünftige Verwendung reserviert sind.

  • Beim Definieren einer Methode oder Eigenschaft, die eine Enumerationskonstante als Wert akzeptiert, sollten Sie die Überprüfung des Werts. Der Grund ist, dass Sie einen numerischen Wert in den Enumerationstyp umwandeln können, selbst wenn diese numerische Wert in der Enumeration definiert ist.

Das folgende Beispiel veranschaulicht die Verwendung der FlagsAttribute Attribut, und zeigt die Auswirkung auf die ToString Methode der Verwendung von FlagsAttribute auf eine Enum Deklaration.

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

Das folgende Beispiel definiert zwei Enumerationen, die farbbezogene, SingleHue und MultiHue. Die zweite über die die FlagsAttribute -Attribut; Erstere nicht. Das Beispiel zeigt den Unterschied im Verhalten, wenn ein Bereich von ganzen Zahlen, z. B. ganze Zahlen, die keine zugrunde liegenden Typ der Enumeration darstellen werden umgewandelt, der Typ der Enumeration und deren zeichenfolgendarstellungen angezeigt. Beispielsweise Beachten Sie, dass 3 als dargestellt werden kann ein SingleHue bewertet werden, da 3 nicht den zugrunde liegenden Wert eines beliebigen ist SingleHue Member, während die FlagsAttribute Attribut macht die 3 wie dargestellt ein MultiHue Wert Black, Red.

using System;

[FlagsAttribute] public enum PhoneService
{
   None = 0,
   LandLine = 1,
   Cell = 2,
   Fax = 4,
   Internet = 8,
   Other = 16
}

public class Example
{
   public static void Main()
   {
      // Define three variables representing the types of phone service
      // in three households.
      var household1 = PhoneService.LandLine | PhoneService.Cell |
                       PhoneService.Internet;
      var household2 = PhoneService.None;
      var household3 = PhoneService.Cell | PhoneService.Internet;

      // Store the variables in an array for ease of access.
      PhoneService[] households = { household1, household2, household3 };

      // Which households have no service?
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has phone service: {1}",
                           ctr + 1,
                           households[ctr] == PhoneService.None ?
                               "No" : "Yes");
      Console.WriteLine();

      // Which households have cell phone service?
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has cell phone service: {1}",
                           ctr + 1,
                           (households[ctr] & PhoneService.Cell) == PhoneService.Cell ?
                              "Yes" : "No");
      Console.WriteLine();

      // Which households have cell phones and land lines?
      var cellAndLand = PhoneService.Cell | PhoneService.LandLine;
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has cell and land line service: {1}",
                           ctr + 1,
                           (households[ctr] & cellAndLand) == cellAndLand ?
                              "Yes" : "No");
      Console.WriteLine();

      // List all types of service of each household?//
      for (int ctr = 0; ctr < households.Length; ctr++)
         Console.WriteLine("Household {0} has: {1:G}",
                           ctr + 1, households[ctr]);
      Console.WriteLine();
   }
}
// The example displays the following output:
//    Household 1 has phone service: Yes
//    Household 2 has phone service: No
//    Household 3 has phone service: Yes
//
//    Household 1 has cell phone service: Yes
//    Household 2 has cell phone service: No
//    Household 3 has cell phone service: Yes
//
//    Household 1 has cell and land line service: Yes
//    Household 2 has cell and land line service: No
//    Household 3 has cell and land line service: No
//
//    Household 1 has: LandLine, Cell, Internet
//    Household 2 has: None
//    Household 3 has: Cell, Internet

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0
Windows Phone
Verfügbar seit 8.1

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: