Was bedeutet der [Flags] Enum-Attribut bedeuten, der in C#?

Question

Von Zeit zu Zeit sehe ich ein enum wie folgt:

[Flags]
public enum Options 
{
    None    = 0,
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
    Option4 = 8
}

Ich verstehe nicht, was genau die [Flags]-Attribut besitzt.

Jemand eine gute Erklärung oder ein Beispiel posten könnte?

Answer 1

Die [Flags] Attribut sollte immer verwendet werden, wenn die enumerable-ist eine Sammlung von möglichen Werten statt auf einen einzelnen Wert.Solche Sammlungen werden oft mit bit-Operatoren, zum Beispiel:

var allowedColors = MyColor.Red | MyColor.Green | MyColor.Blue;

Beachten Sie, dass die [Flags] Attribut nicht aktivieren Sie diese, indem Sie sich - alle es tut, ist, ermöglichen eine schöne Darstellung der .ToString() Methode:

enum Suits { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }
[Flags] enum SuitsFlags { Spades = 1, Clubs = 2, Diamonds = 4, Hearts = 8 }

...

var str1 = (Suits.Spades | Suits.Diamonds).ToString();
           // "5"
var str2 = (SuitsFlags.Spades | SuitsFlags.Diamonds).ToString();
           // "Spades, Diamonds"

Es ist auch wichtig zu beachten, dass [Flags] nicht automatisch stellen Sie die enum-Werte Potenzen von zwei.Unterlassen Sie die numerischen Werte der enum wird nicht funktionieren, wie man erwarten könnte, dass in bitweise Operationen, da standardmäßig die Werte beginnen bei 0 und die Schrittweite.

Falschen Erklärung:

[Flags]
public enum MyColors
{
    Yellow,  // 0
    Green,   // 1
    Red,     // 2
    Blue     // 3
}

Die Werte, falls deklariert diese Weise, Gelb = 0, Grün = 1, Rot = 2, Blau = 3.Dies wird es nutzlos wie Fahnen.

Hier ist ein Beispiel für eine korrekte Deklaration:

[Flags]
public enum MyColors
{
    Yellow = 1,
    Green = 2,
    Red = 4,
    Blue = 8
}

Zum abrufen der eindeutigen Werte in Ihrer Eigenschaft, die man machen kann, dieser:

if (myProperties.AllowedColors.HasFlag(MyColor.Yellow))
{
    // Yellow is allowed...
}

oder vor .NET 4:

if((myProperties.AllowedColors & MyColor.Yellow) == MyColor.Yellow)
{
    // Yellow is allowed...
}

if((myProperties.AllowedColors & MyColor.Green) == MyColor.Green)
{
    // Green is allowed...
}    

Unter der Decke

Dies funktioniert, weil Sie verwendete Potenzen von zwei, in Ihrer Aufzählung.Unter der Decke, Ihr enumeration Werte wie folgt Aussehen in binären Einsen und Nullen:

 Yellow: 00000001
 Green:  00000010
 Red:    00000100
 Blue:   00001000

Ähnlich, nachdem Sie sich gesetzt haben, Ihre Immobilie AllowedColors Rot, Grün und Blau mit dem binären bitweisen ODER | operator AllowedColors sieht aus wie diese:

myProperties.AllowedColors: 00001110

Also, wenn Sie den Wert abrufen, die Sie tatsächlich durchführen bitweise UND-Verknüpfung & auf die Werte:

myProperties.AllowedColors: 00001110
             MyColor.Green: 00000010
             -----------------------
                            00000010 // Hey, this is the same as MyColor.Green!

Die None = 0 Wert

Und bezüglich der Verwendung von 0 in Ihrer Aufzählung, Zitat aus MSDN:

[Flags]
public enum MyColors
{
    None = 0,
    ....
}

Verwenden Sie None als der name des flag-Enum-Konstante, deren Wert gleich null ist. Sie können nicht verwenden, die Keine Enum-Konstante in einer bitweisen UND-operation zu testen, für eine fahne denn das Ergebnis ist immer null. Allerdings können Sie ein logisches, nicht ein bitweiser Vergleich zwischen dem numerischen Wert und Keine Enum-Konstante zu bestimmen, ob alle bits in die numerische Wert eingestellt sind.

Finden Sie mehr info über das flags-Attribut und dessen Nutzung zu msdn und Gestaltung von Fahnen auf msdn

Answer 2

Sie können dies auch tun,

[Flags]
public enum MyEnum
{
    None   = 0,
    First  = 1 << 0,
    Second = 1 << 1,
    Third  = 1 << 2,
    Fourth = 1 << 3
}

Ich finde das bit-shifting einfacher als die Eingabe 4,8,16,32 und so auf.Es hat keine Auswirkungen auf Ihren code, denn es ist alles fertig bei der Kompilierung

Answer 3

Kombinieren Antworten https://stackoverflow.com/a/8462/1037948 (Erklärung über bit-shifting) und https://stackoverflow.com/a/9117/1037948 (mit Kombinationen in der Erklärung) können Sie bit-shift vorherigen Werte anstatt mit zahlen.Nicht unbedingt empfehlen, aber nur darauf aus, die Sie können.

Anstatt:

[Flags]
public enum Options : byte
{
    None    = 0,
    One     = 1 << 0,   // 1
    Two     = 1 << 1,   // 2
    Three   = 1 << 2,   // 4
    Four    = 1 << 3,   // 8

    // combinations
    OneAndTwo = One | Two,
    OneTwoAndThree = One | Two | Three,
}

Sie können erklären,

[Flags]
public enum Options : byte
{
    None    = 0,
    One     = 1 << 0,       // 1
    // now that value 1 is available, start shifting from there
    Two     = One << 1,     // 2
    Three   = Two << 1,     // 4
    Four    = Three << 1,   // 8

    // same combinations
    OneAndTwo = One | Two,
    OneTwoAndThree = One | Two | Three,
}

---

Bestätigen Sie mit LinqPad:

foreach(var e in Enum.GetValues(typeof(Options))) {
    string.Format("{0} = {1}", e.ToString(), (byte)e).Dump();
}

Ergebnisse in:

None = 0
One = 1
Two = 2
OneAndTwo = 3
Three = 4
OneTwoAndThree = 7
Four = 8

Answer 4

Im folgenden finden Sie ein Beispiel, das zeigt die Erklärung und die mögliche Verwendung:

namespace Flags
{
    class Program
    {
        [Flags]
        public enum MyFlags : short
        {
            Foo = 0x1,
            Bar = 0x2,
            Baz = 0x4
        }

        static void Main(string[] args)
        {
            MyFlags fooBar = MyFlags.Foo | MyFlags.Bar;

            if ((fooBar & MyFlags.Foo) == MyFlags.Foo)
            {
                Console.WriteLine("Item has Foo flag set");
            }
        }
    }
}

Answer 5

Ich vor kurzem gefragt über etwas ähnliches.

Wenn Sie die use-flags können Sie eine Erweiterungsmethode, um enums zu machen überprüfen die enthaltenen Flaggen einfacher (siehe post für Details)

Dies können Sie tun:

[Flags]
public enum PossibleOptions : byte
{
    None = 0,
    OptionOne = 1,
    OptionTwo = 2,
    OptionThree = 4,
    OptionFour = 8,

    //combinations can be in the enum too
    OptionOneAndTwo = OptionOne | OptionTwo,
    OptionOneTwoAndThree = OptionOne | OptionTwo | OptionThree,
    ...
}

Dann können Sie tun:

PossibleOptions opt = PossibleOptions.OptionOneTwoAndThree 

if( opt.IsSet( PossibleOptions.OptionOne ) ) {
    //optionOne is one of those set
}

Ich finde diese leichter zu Lesen als die meisten Möglichkeiten, zu überprüfen, die enthalten Fahnen.

Answer 6

In Erweiterung zu der akzeptierten Antwort in C#7 die enum-flags kann geschrieben werden mit binäre Literale:

[Flags]
public enum MyColors
{
    None   = 0b0000,
    Yellow = 0b0001,
    Green  = 0b0010,
    Red    = 0b0100,
    Blue   = 0b1000
}

Ich denke, diese Darstellung macht deutlich, wie die Flaggen der Arbeit unter der Decke.

Answer 7

@Nidonocu

Zum hinzufügen einer anderen Flagge zu einem vorhandenen Satz von Werten verwenden Sie die-ODER-Zuweisungsoperator.

Mode = Mode.Read;
//Add Mode.Write
Mode |= Mode.Write;
Assert.True(((Mode & Mode.Write) == Mode.Write)
  && ((Mode & Mode.Read) == Mode.Read)));

Answer 8

Hinzufügen Mode.Write:

Mode = Mode | Mode.Write;

Answer 9

Es gibt etwas allzu ausführlich, um mich über die if ((x & y) == y)... konstruieren, besonders wenn x UND y sind die beiden zusammengesetzten Gruppen von flags und Sie möchten nur wissen, ob es alle überlappen.

In diesem Fall, alles, was Sie wirklich wissen müssen wenn es ein nicht-null-Wert[1] nachdem Sie bitmasked.

[1] Siehe Jaime Kommentar.Wenn wir authentisch bitmasking, wir würd muss nur schauen, dass das Ergebnis positiv war.Aber da enums kann negativ sein, auch, seltsamerweise, wenn kombiniert mit die [Flags] Attribut, es ist der defensive auf den code für != 0 anstatt > 0.

Building off of @andnil setup...

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BitFlagPlay
{
    class Program
    {
        [Flags]
        public enum MyColor
        {
            Yellow = 0x01,
            Green = 0x02,
            Red = 0x04,
            Blue = 0x08
        }

        static void Main(string[] args)
        {
            var myColor = MyColor.Yellow | MyColor.Blue;
            var acceptableColors = MyColor.Yellow | MyColor.Red;

            Console.WriteLine((myColor & MyColor.Blue) != 0);     // True
            Console.WriteLine((myColor & MyColor.Red) != 0);      // False                
            Console.WriteLine((myColor & acceptableColors) != 0); // True
            // ... though only Yellow is shared.

            Console.WriteLine((myColor & MyColor.Green) != 0);    // Wait a minute... ;^D

            Console.Read();
        }
    }
}

Answer 10

Flags-ermöglicht die Verwendung bitmasking in Ihrem Aufzählung.Diese können Sie kombinieren, enumeration Werte, unter Beibehaltung welche angegeben sind.

[Flags]
public enum DashboardItemPresentationProperties : long
{
    None = 0,
    HideCollapse = 1,
    HideDelete = 2,
    HideEdit = 4,
    HideOpenInNewWindow = 8,
    HideResetSource = 16,
    HideMenu = 32
}

Answer 11

Beim arbeiten mit flags, die ich oft erklären, Keine zusätzlichen und Alle Gegenstände, die.Diese sind hilfreich, um zu überprüfen, ob alle flags gesetzt sind oder kein flag gesetzt ist.

[Flags] 
enum SuitsFlags { 

    None =     0,

    Spades =   1 << 0, 
    Clubs =    1 << 1, 
    Diamonds = 1 << 2, 
    Hearts =   1 << 3,

    All =      ~(~0 << 4)

}

Verwendung:

Spades | Clubs | Diamonds | Hearts == All  // true
Spades & Clubs == None  // true