Come verificare se sono stati impostati flag di una combinazione di flag?

Diciamo che ho questo enum:

[Flags]
enum Letters
{
     A = 1,
     B = 2,
     C = 4,
     AB = A | B,
     All = A | B | C,
}

Per verificare se, ad esempio, ABè impostato, posso farlo:

if((letter & Letters.AB) == Letters.AB)

Esiste un modo più semplice per verificare se una delle flag di una costante di flag combinata è impostata rispetto alla seguente?

if((letter & Letters.A) == Letters.A || (letter & Letters.B) == Letters.B)

Potresti ad esempio scambiare il &con qualcosa?

Non troppo stabile quando si tratta di cose binarie come questa ...

Se vuoi sapere se la lettera ha una delle lettere in AB, devi usare l' operatore AND . Qualcosa di simile a:

if ((letter & Letters.AB) != 0)
{
    // Some flag (A,B or both) is enabled
}
else
{
    // None of them are enabled
}

In .NET 4 è possibile utilizzare il metodo Enum.HasFlag :

using System;

[Flags] public enum Pet {
   None = 0,
   Dog = 1,
   Cat = 2,
   Bird = 4,
   Rabbit = 8,
   Other = 16
}

public class Example
{
   public static void Main()
   {
      // Define three families: one without pets, one with dog + cat and one with a dog only
      Pet[] petsInFamilies = { Pet.None, Pet.Dog | Pet.Cat, Pet.Dog };
      int familiesWithoutPets = 0;
      int familiesWithDog = 0;

      foreach (Pet petsInFamily in petsInFamilies)
      {
         // Count families that have no pets. 
         if (petsInFamily.Equals(Pet.None))
            familiesWithoutPets++;
         // Of families with pets, count families that have a dog. 
         else if (petsInFamily.HasFlag(Pet.Dog))
            familiesWithDog++;
      }
      Console.WriteLine("{0} of {1} families in the sample have no pets.", 
                        familiesWithoutPets, petsInFamilies.Length);   
      Console.WriteLine("{0} of {1} families in the sample have a dog.", 
                        familiesWithDog, petsInFamilies.Length);   
   }
}

L'esempio mostra il seguente output:

//       1 of 3 families in the sample have no pets. 
//       2 of 3 families in the sample have a dog.

Uso metodi di estensione per scrivere cose del genere:

if (letter.IsFlagSet(Letter.AB))
    ...

Ecco il codice:

public static class EnumExtensions
{
    private static void CheckIsEnum<T>(bool withFlags)
    {
        if (!typeof(T).IsEnum)
            throw new ArgumentException(string.Format("Type '{0}' is not an enum", typeof(T).FullName));
        if (withFlags && !Attribute.IsDefined(typeof(T), typeof(FlagsAttribute)))
            throw new ArgumentException(string.Format("Type '{0}' doesn't have the 'Flags' attribute", typeof(T).FullName));
    }

    public static bool IsFlagSet<T>(this T value, T flag) where T : struct
    {
        CheckIsEnum<T>(true);
        long lValue = Convert.ToInt64(value);
        long lFlag = Convert.ToInt64(flag);
        return (lValue & lFlag) != 0;
    }

    public static IEnumerable<T> GetFlags<T>(this T value) where T : struct
    {
        CheckIsEnum<T>(true);
        foreach (T flag in Enum.GetValues(typeof(T)).Cast<T>())
        {
            if (value.IsFlagSet(flag))
                yield return flag;
        }
    }

    public static T SetFlags<T>(this T value, T flags, bool on) where T : struct
    {
        CheckIsEnum<T>(true);
        long lValue = Convert.ToInt64(value);
        long lFlag = Convert.ToInt64(flags);
        if (on)
        {
            lValue |= lFlag;
        }
        else
        {
            lValue &= (~lFlag);
        }
        return (T)Enum.ToObject(typeof(T), lValue);
    }

    public static T SetFlags<T>(this T value, T flags) where T : struct
    {
        return value.SetFlags(flags, true);
    }

    public static T ClearFlags<T>(this T value, T flags) where T : struct
    {
        return value.SetFlags(flags, false);
    }

    public static T CombineFlags<T>(this IEnumerable<T> flags) where T : struct
    {
        CheckIsEnum<T>(true);
        long lValue = 0;
        foreach (T flag in flags)
        {
            long lFlag = Convert.ToInt64(flag);
            lValue |= lFlag;
        }
        return (T)Enum.ToObject(typeof(T), lValue);
    }

    public static string GetDescription<T>(this T value) where T : struct
    {
        CheckIsEnum<T>(false);
        string name = Enum.GetName(typeof(T), value);
        if (name != null)
        {
            FieldInfo field = typeof(T).GetField(name);
            if (field != null)
            {
                DescriptionAttribute attr = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) as DescriptionAttribute;
                if (attr != null)
                {
                    return attr.Description;
                }
            }
        }
        return null;
    }
}

Esiste il metodo HasFlag in .NET 4 o versioni successive.

if(letter.HasFlag(Letters.AB))
{
}

Se è possibile utilizzare .NET 4 o versioni successive rispetto al metodo HasFlag ()

esempi

letter.HasFlag(Letters.A | Letters.B) // both A and B must be set

uguale a

letter.HasFlag(Letters.AB)

Se ti dà davvero fastidio, puoi scrivere una funzione del genere:

public bool IsSet(Letters value, Letters flag)
{
    return (value & flag) == flag;
}

if (IsSet(letter, Letters.A))
{
   // ...
}

// If you want to check if BOTH Letters.A and Letters.B are set:
if (IsSet(letter, Letters.A & Letters.B))
{
   // ...
}

// If you want an OR, I'm afraid you will have to be more verbose:
if (IsSet(letter, Letters.A) || IsSet(letter, Letters.B))
{
   // ...
}

Per verificare se, ad esempio, è impostato AB, posso farlo:

if ((letter & Letters.AB) == Letters.AB)

Esiste un modo più semplice per verificare se una delle flag di una costante di flag combinata è impostata rispetto alla seguente?

Ciò controlla che siano impostati sia A che B e ignora se sono impostati altri flag.

if((letter & Letters.A) == Letters.A || (letter & Letters.B) == Letters.B)

Questo controlla che sia impostato A o B e ignora se sono impostati o meno altri flag.

Questo può essere semplificato per:

if(letter & Letters.AB)

Ecco la C per le operazioni binarie; dovrebbe essere semplice applicarlo a C #:

enum {
     A = 1,
     B = 2,
     C = 4,
     AB = A | B,
     All = AB | C,
};

int flags = A|C;

bool anything_and_a = flags & A;

bool only_a = (flags == A);

bool a_and_or_c_and_anything_else = flags & (A|C);

bool both_ac_and_anything_else = (flags & (A|C)) == (A|C);

bool only_a_and_c = (flags == (A|C));

Per inciso, la denominazione della variabile nell'esempio della domanda è la singolare 'lettera', che potrebbe implicare che rappresenti solo una singola lettera; il codice di esempio chiarisce che è un insieme di lettere possibili e che sono consentiti più valori, quindi considera di rinominare la variabile "lettere".

Che ne dite di

if ((letter & Letters.AB) > 0)

?

Ho creato un metodo di estensione semplice che non richiede un controllo sui Enumtipi:

public static bool HasAnyFlag(this Enum value, Enum flags)
{
    return
        value != null && ((Convert.ToInt32(value) & Convert.ToInt32(flags)) != 0);
}

Funziona anche su enumerazioni nullable. Il HasFlagmetodo standard no, quindi ho creato un'estensione per coprire anche quello.

public static bool HasFlag(this Enum value, Enum flags)
{
    int f = Convert.ToInt32(flags);

    return
        value != null && ((Convert.ToInt32(value) & f) == f);
}

Un semplice test:

[Flags]
enum Option
{
    None = 0x00,
    One = 0x01,
    Two = 0x02,
    Three = One | Two,
    Four = 0x04
}

[TestMethod]
public void HasAnyFlag()
{
    Option o1 = Option.One;
    Assert.AreEqual(true, o1.HasAnyFlag(Option.Three));
    Assert.AreEqual(false, o1.HasFlag(Option.Three));

    o1 |= Option.Two;
    Assert.AreEqual(true, o1.HasAnyFlag(Option.Three));
    Assert.AreEqual(true, o1.HasFlag(Option.Three));
}

[TestMethod]
public void HasAnyFlag_NullableEnum()
{
    Option? o1 = Option.One;
    Assert.AreEqual(true, o1.HasAnyFlag(Option.Three));
    Assert.AreEqual(false, o1.HasFlag(Option.Three));

    o1 |= Option.Two;
    Assert.AreEqual(true, o1.HasAnyFlag(Option.Three));
    Assert.AreEqual(true, o1.HasFlag(Option.Three));
}

Godere!

Ci sono molte risposte qui, ma penso che il modo più idiomatico di farlo con Flags sarebbe Letters.AB.HasFlag (letter) o (Letters.A | Letters.B) .HasFlag (letter) se non l'hai fatto ho già Letters.AB. letter.HasFlag (Letters.AB) funziona solo se ha entrambi.

Funzionerebbe per te?

if ((letter & (Letters.A | Letters.B)) != 0)

Saluti,

Sebastiaan

È possibile utilizzare questo metodo di estensione su enum, per qualsiasi tipo di enum:

public static bool IsSingle(this Enum value)
{
    var items = Enum.GetValues(value.GetType());
    var counter = 0;
    foreach (var item in items)
    {
        if (value.HasFlag((Enum)item))
        {
            counter++;
        }
        if (counter > 1)
        {
            return false;
        }
    }
    return true;
}

if((int)letter != 0) { }

Si potrebbe semplicemente verificare se il valore non è zero.

if ((Int32)(letter & Letters.AB) != 0) { }

Ma considererei una soluzione migliore introdurre un nuovo valore di enumerazione con valore zero e confrontare nuovamente questo valore di enumerazione (se possibile perché si deve essere in grado di modificare l'enumerazione).

[Flags]
enum Letters
{
    None = 0,
    A    = 1,
    B    = 2,
    C    = 4,
    AB   =  A | B,
    All  = AB | C
}

if (letter != Letters.None) { }

AGGIORNARE

Ho letto male la domanda - risolto il primo suggerimento e ignora il secondo suggerimento.

Ci sono due approcci che posso vedere che funzionerebbero per verificare la presenza di eventuali bit impostati.

Aproach A

if (letter != 0)
{
}

Funziona finché non ti dispiace controllare tutti i bit, compresi quelli non definiti!

Aproach B

if ((letter & Letters.All) != 0)
{
}

Questo controlla solo i bit definiti, purché Letters.Tutti rappresentino tutti i bit possibili.

Per bit specifici (uno o più set), utilizzare Aproach B in sostituzione di Lettere. Tutti con i bit che si desidera verificare (vedere di seguito).

if ((letter & Letters.AB) != 0)
{
}

Siamo spiacenti, ma lo mostrerò in VB :)

   <Flags()> Public Enum Cnt As Integer
        None = 0
        One = 1
        Two = 2
        Three = 4
        Four = 8    
    End Enum

    Sub Test()
    Dim CntValue As New Cnt
    CntValue += Cnt.One
    CntValue += Cnt.Three
    Console.WriteLine(CntValue)
    End Sub

CntValue = 5 Quindi l'enum contiene 1 + 4