如何檢查標誌組合的任何標誌是否已設置？

Question

比方說，我有這樣的枚舉：

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

要檢查是否例如AB設爲我可以這樣做：

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

有沒有一種簡單的檢查是否有任何的標誌的方式組合標誌常量是否設置比以下？

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

你能舉個例子把&換成東西嗎？

不是當談到這樣的二進制東西太穩定...

Answer 1

。類似於：

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

Answer 2

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

Answer 3

如何

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

？

Answer 4

如果它真的惹惱了你，你可以寫一個這樣的功能：如果你想知道，如果信有任何AB字母必須使用AND &運營商的

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)) 
{ 
    // ... 
} 

Answer 5

這會適合您嗎？

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

問候，

Sebastiaan

Answer 6

要檢查是否例如AB設爲我可以這樣做：

IF（（信& Letters.AB）==快報。 AB）

是否有一種更簡單的方法來檢查組合標誌常量的任何標誌是否設置爲f ollowing？

這就驗證了既 A和B被設置，並忽略任何其他標誌是否被設置。

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

這就驗證了要麼 A或B被設置，並忽略任何其他標誌是否被設定或沒有。

這可以簡化爲：

if(letter & Letters.AB) 

這裏的下二進制操作;它應該是簡單的將其應用到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)); 

順便說一下，在問題的例子變量的命名是奇異「信」，這可能意味着它僅代表一個字母;示例代碼清楚地表明它是一組可能的字母，並且允許多個值，因此可以考慮重命名變量「字母」。

Answer 7

您可以檢查該值是否不爲零。

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

但我會認爲這是一個更好的解決方案與零值引入新的枚舉值和比較agains此枚舉值（如果可能的話，因爲你必須能夠修改枚舉）。

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

if (letter != Letters.None) { } 

UPDATE

Missread問題 - 固定的第一個建議，只是忽略了第二個建議。

Answer 8

我可以看到有兩個方法可以用來檢查設置的位。

阿布羅奇一個

if (letter != 0) 
{ 
} 

這個工作，只要你不介意檢查所有位，包括非義之輩！

阿布羅奇乙

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

這僅檢查所定義的比特，只要Letters.All表示所有可能的位。

對於特定位（一個或多個集合），使用Aproach B替換Letters.All，並使用要檢查的位（請參見下文）。

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

Answer 9

我使用擴展方法來寫這樣的事情：

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

下面的代碼：

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; 
    } 
} 

Answer 10

在.NET 4中，你可以使用Enum.HasFlag method：

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); 
    } 
} 

示例顯示以下輸出：

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

Answer 11

在.NET 4或更高版本中有HasFlag方法。

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

Answer 12

如果可以使用.NET 4或高於使用HasFlag（）方法

例子

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

相同

letter.HasFlag(Letters.AB) 

Answer 13

我創建了一個簡單的擴展方法，該方法不需要檢查Enum類型：

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

它也適用於可爲空的枚舉。標準的HasFlag方法沒有，所以我創建了一個擴展來覆蓋它。

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

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

一個簡單的測試：

[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)); 
} 

享受！

Answer 14

這裏有很多答案，但我認爲用Flags做這個的最習慣的方法是Letters.AB.HasFlag（letter）或（Letters.A | Letters.B）.HasFlag（letter）if你還沒有Letters.AB。 letter.HasFlag（Letters.AB）僅在具有兩者時纔有效。

Answer 15

很抱歉，但我會將它顯示在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 所以枚舉包含1 + 4

Answer 16

您可以使用此枚舉擴展方法，對於任何類型的枚舉：

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; 
}