FlagsAttribute Osztály

Definíció

Névtér:

System

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

FlagsAttribute.cs

Azt jelzi, hogy az enumerálás bitmezőként kezelhető; vagyis zászlók halmaza.

public ref class FlagsAttribute : Attribute

[System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)]
public class FlagsAttribute : Attribute

[<System.AttributeUsage(System.AttributeTargets.Enum, Inherited=false)>]
type FlagsAttribute = class
    inherit Attribute

Public Class FlagsAttribute
Inherits Attribute

Öröklődés

Object

Attribute

FlagsAttribute

Attribútumok

AttributeUsageAttribute

Példák

Az alábbi példa szemlélteti a FlagsAttribute attribútum használatát, és bemutatja, hogy ez milyen hatással van a ToString metódusra, amikor FlagsAttribute van használatban egy Enum deklarációban.

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.
   [Flags]
   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

open System

// Define an Enum without FlagsAttribute.
type SingleHue =
    | None = 0
    | Black = 1
    | Red = 2
    | Green = 4
    | Blue = 8

// Define an Enum with FlagsAttribute.
[<Flags>]
type MultiHue =
    | None = 0
    | Black = 1
    | Red = 2
    | Green = 4
    | Blue = 8

// Display all possible combinations of values.
printfn "All possible combinations of values without FlagsAttribute:"
for i = 0 to 16 do
    printfn $"{i,3} - {enum<SingleHue> i:G}"

// Display all combinations of values, and invalid values.
printfn "\nAll possible combinations of values with FlagsAttribute:"
for i = 0 to 16 do
    printfn $"{i,3} - {enum<MultiHue> i:G}"

// 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

Module Example
   ' Define an Enum without FlagsAttribute.
   Enum SingleHue As Short
      None = 0
      Black = 1
      Red = 2
      Green = 4
      Blue = 8
   End Enum

   ' Define an Enum with FlagsAttribute.
   <Flags()> 
   Enum MultiHue As Short
      None = 0
      Black = 1
      Red = 2
      Green = 4
      Blue = 8
   End Enum

   Sub Main()
      ' Display all possible combinations of values.
      Console.WriteLine(
           "All possible combinations of values without FlagsAttribute:")
      For val As Integer = 0 To 16
         Console.WriteLine("{0,3} - {1:G}", val, CType(val, SingleHue))
     Next 
     Console.WriteLine()
     
     ' Display all combinations of values, and invalid values.
     Console.WriteLine( 
          "All possible combinations of values with FlagsAttribute:")
     For val As Integer = 0 To 16
        Console.WriteLine( "{0,3} - {1:G}", val, CType(val, MultiHue))
     Next 
   End Sub 
End Module 
' 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

Az előző példa két, színnel kapcsolatos enumerációt határoz meg: SingleHue és MultiHue. Az utóbbi rendelkezik az FlagsAttribute attribútummal, az előbbi nem. A példa azt mutatja be, hogy mi a különbség a viselkedésben, amikor egy egész szám tartományát, beleértve azokat az egész számokat is, amelyek nem képviselik az enumerációs típus mögöttes értékeit, az enumerációs típusra vetítik át, és azok sztringreprezentációit megjelenítik. Vegye figyelembe például, hogy a 3 nem jelölhető értékként SingleHue , mert a 3 nem egy SingleHue tag mögöttes értéke, míg az FlagsAttribute attribútum lehetővé teszi a 3 értékként MultiHue való megjelenítését Black, Red.

Az alábbi példa egy másik enumerálást határoz meg az FlagsAttribute attribútummal, és bemutatja, hogyan használható bitenkénti logikai és egyenlőségi operátorok annak meghatározására, hogy egy vagy több bitmező enumerálási értékben van-e beállítva. Ezt a Enum.HasFlag módszert is használhatja, de ez nem jelenik meg ebben a példában.

using System;

[Flags]
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

open System

[<Flags>]
type PhoneService =
    | None = 0
    | LandLine = 1
    | Cell = 2
    | Fax = 4
    | Internet = 8
    | Other = 16

// Define three variables representing the types of phone service
// in three households.
let household1 = 
    PhoneService.LandLine ||| PhoneService.Cell ||| PhoneService.Internet

let household2 = 
    PhoneService.None

let household3 = 
    PhoneService.Cell ||| PhoneService.Internet

// Store the variables in a list for ease of access.
let households =
    [ household1; household2; household3 ]

// Which households have no service?
for i = 0 to households.Length - 1 do
    printfn $"""Household {i + 1} has phone service: {if households[i] = PhoneService.None then "No" else "Yes"}"""
printfn ""

// Which households have cell phone service?
for i = 0 to households.Length - 1 do
    printfn $"""Household {i + 1} has cell phone service: {if households[i] &&& PhoneService.Cell = PhoneService.Cell then "Yes" else "No"}"""
printfn ""

// Which households have cell phones and land lines?
let cellAndLand = 
    PhoneService.Cell ||| PhoneService.LandLine

for i = 0 to households.Length - 1 do
    printfn $"""Household {i + 1} has cell and land line service: {if households[i] &&& cellAndLand = cellAndLand then "Yes" else "No"}"""
printfn ""

// List all types of service of each household?//
for i = 0 to households.Length - 1 do
    printfn $"Household {i + 1} has: {households[i]:G}"

// 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

<Flags()>
Public Enum PhoneService As Integer
   None = 0
   LandLine = 1
   Cell = 2
   Fax = 4
   Internet = 8
   Other = 16
End Enum

Module Example1
   Public Sub Main()
      ' Define three variables representing the types of phone service
      ' in three households.
      Dim household1 As PhoneService = PhoneService.LandLine Or
                                       PhoneService.Cell Or
                                       PhoneService.Internet
      Dim household2 As PhoneService = PhoneService.None
      Dim household3 As PhoneService = PhoneService.Cell Or
                                       PhoneService.Internet

      ' Store the variables in an array for ease of access.
      Dim households() As PhoneService = { household1, household2,
                                           household3 }

      ' Which households have no service?
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has phone service: {1}",
                           ctr + 1,
                           If(households(ctr) = PhoneService.None,
                              "No", "Yes"))
      Next
      Console.WriteLine()
      
      ' Which households have cell phone service?
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has cell phone service: {1}",
                           ctr + 1,
                           If((households(ctr) And PhoneService.Cell) = PhoneService.Cell,
                              "Yes", "No"))
      Next
      Console.WriteLine()
      
      ' Which households have cell phones and land lines?
      Dim cellAndLand As PhoneService = PhoneService.Cell Or PhoneService.LandLine
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has cell and land line service: {1}",
                           ctr + 1,
                           If((households(ctr) And cellAndLand) = cellAndLand,
                              "Yes", "No"))
      Next
      Console.WriteLine()
      
      ' List all types of service of each household?'
      For ctr As Integer = 0 To households.Length - 1
         Console.WriteLine("Household {0} has: {1:G}",
                           ctr + 1, households(ctr))
      Next
      Console.WriteLine()
   End Sub
End Module
' 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

Megjegyzések

Az FlagsAttribute attribútum azt jelzi, hogy az enumerálás bitmezőként, azaz jelzők halmazaként kezelhető.

A bitmezőket általában olyan elemek listáihoz használják, amelyek együttesen fordulhatnak elő, míg az enumerálási állandókat általában a kölcsönösen kizáró elemek listáihoz használják. A bitmezők ezért úgy vannak kialakítva, hogy bitenkénti OR művelettel kombinálva névtelen értékeket generáljanak, míg a számba vett állandók nem. A nyelvek az enumerálási állandókhoz képest eltérőek a bitmezők használatában.

A FlagsAttribute attribútumai

A(z) AttributeUsageAttribute erre az osztályra van alkalmazva, és a Inherited tulajdonság határozza meg a false értéket. Ez az attribútum csak enumerálásokra alkalmazható.

A FlagsAttribute és az enumerálás irányelvei

• A FlagsAttribute egyéni attribútumot csak akkor használja enumeráláshoz, ha bitenkénti műveletet (ÉS, VAGY, KIZÁRÓ VAGY) kell végrehajtani egy numerikus értéken.

• Definiálja az enumerálási állandókat két hatványban, azaz 1, 2, 4, 8 és így tovább. Ez azt jelenti, hogy a kombinált enumerálási állandók egyes jelzői nem fedik egymást.

• Érdemes lehet számba venni egy számba vett állandót a gyakran használt jelölőkombinációkhoz. Ha például fájl I/O-műveletekhez felsorolt konstansokat, például Read = 1 és Write = 2 használ, érdemes lehet létrehozni egy új felsorolt konstansot, amely egyesíti a ReadWrite = Read OR Write és Read jelzőket. Emellett a jelzők egyesítéséhez használt bitenkénti VAGY művelet bizonyos körülmények között speciális fogalomnak tekinthető, amely nem szükséges az egyszerű feladatokhoz.

• Körültekintően járjon el, ha negatív számot definiál számozott jelölőállandóként, mert számos jelölőpozíció 1 értékre állítható be, ami összezavarhatja a kódját, és kódolási hibákat ösztönözhet.

• Kényelmes módszer annak ellenőrzésére, hogy egy jelölő numerikus értékben van-e beállítva, ha bitenkénti ÉS műveletet hajt végre a numerikus érték és a számjel számbavételi állandója között, amely nullára állítja a numerikus érték minden olyan bitét, amely nem felel meg a jelölőnek, majd tesztelje, hogy a művelet eredménye egyenlő-e a jelölő számbavételi állandóval.

• Használja a None jelölőt a felsorolt konstans nevének, amelynek értéke nulla. A None felsorolt konstans nem használható bitenkénti ÉS műveletben zászló tesztelésére, mert az eredmény mindig nulla lesz. A numerikus érték és az None enumerált állandó közötti logikai és nem bitenkénti összehasonlítást azonban elvégezheti annak megállapításához, hogy a numerikus értékben lévő bitek be vannak-e állítva.

  Ha a jelzők számbavétele helyett érték számbavételt hoz létre, akkor is érdemes számbavételi állandót None létrehozni. Ennek az az oka, hogy alapértelmezés szerint az enumeráláshoz használt memória nullára van inicializálva a közös nyelvi futtatókörnyezet által. Következésképpen, ha nem határoz meg olyan állandót, amelynek értéke nulla, az enumerálás érvénytelen értéket fog tartalmazni a létrehozáskor.

  Ha van egy nyilvánvaló alapértelmezett eset, amelyet az alkalmazásnak képviselnie kell, fontolja meg egy számbavételi állandó használatát, amelynek értéke nulla az alapértelmezett érték megjelenítéséhez. Ha nincs alapértelmezett eset, érdemes lehet olyan számbavételi állandót használni, amelynek értéke nulla, ami azt az esetet jelenti, amelyet a többi számbavételi állandó nem jelöl.

• Ne adjon meg enumerálási értéket kizárólag az enumerálás állapotának tükrözéséhez. Ne definiáljon például olyan számbavételi állandót, amely csupán az enumerálás végét jelöli. Ha meg kell határoznia az enumerálás utolsó értékét, ellenőrizze ezt az értéket explicit módon. Emellett az első és az utolsó számbavételi állandó tartományellenőrzését is elvégezheti, ha a tartományon belüli összes érték érvényes.

• Ne adjon meg olyan számbavételi állandókat, amelyek jövőbeli használatra vannak fenntartva.

• Ha olyan metódust vagy tulajdonságot határoz meg, amely számba veszi az enumerált állandót értékként, fontolja meg az érték érvényesítését. Ennek az az oka, hogy numerikus értéket akkor is megadhat az enumerálási típushoz, ha a numerikus érték nincs definiálva az enumerálásban.

Konstruktorok

Name	Description
FlagsAttribute()	Inicializálja a FlagsAttribute osztály új példányát.

Tulajdonságok

Name	Description
TypeId	Ha származtatott osztályban implementálják, ehhez egy egyedi azonosítót Attributekap. (Öröklődés forrása Attribute)

Metódusok

Name	Description
Equals(Object)	Olyan értéket ad vissza, amely jelzi, hogy ez a példány egyenlő-e egy adott objektummal. (Öröklődés forrása Attribute)
GetHashCode()	A példány kivonatkódját adja vissza. (Öröklődés forrása Attribute)
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
IsDefaultAttribute()	Ha egy származtatott osztályban felül van bírálva, azt jelzi, hogy a példány értéke-e a származtatott osztály alapértelmezett értéke. (Öröklődés forrása Attribute)
Match(Object)	Származtatott osztály felülírásakor egy olyan értéket ad vissza, amely jelzi, hogy ez a példány egy adott objektummal egyenlő-e. (Öröklődés forrása Attribute)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)