比较 C# 中的枚举标志

Comparing enum flags in C#

提问by Enyra

I need to detect if a flag is set within an enum value, which type is marked with the Flag attribute.

我需要检测是否在枚举值中设置了标志，哪个类型用 Flag 属性标记。

Usually it is made like that:

通常它是这样制作的：

(value & flag) == flag

But since I need to do this by generic (sometimes at runtime I event have only an "Enum" reference. I can not find an easy way to use the & operator. At the moment I make it like this:

但是因为我需要通过泛型来做到这一点（有时在运行时我事件只有一个“枚举”引用。我找不到使用 & 运算符的简单方法。目前我是这样的：

    public static bool IsSet<T>(this T value, T flags) where T : Enum
    { 
        Type numberType = Enum.GetUnderlyingType(typeof(T));

        if (numberType.Equals(typeof(int)))
        {
            return BoxUnbox<int>(value, flags, (a, b) => (a & b) == b);
        }
        else if (numberType.Equals(typeof(sbyte)))
        {
            return BoxUnbox<sbyte>(value, flags, (a, b) => (a & b) == b);
        }
        else if (numberType.Equals(typeof(byte)))
        {
            return BoxUnbox<byte>(value, flags, (a, b) => (a & b) == b);
        }
        else if (numberType.Equals(typeof(short)))
        {
            return BoxUnbox<short>(value, flags, (a, b) => (a & b) == b);
        }
        else if (numberType.Equals(typeof(ushort)))
        {
            return BoxUnbox<ushort>(value, flags, (a, b) => (a & b) == b);
        }
        else if (numberType.Equals(typeof(uint)))
        {
            return BoxUnbox<uint>(value, flags, (a, b) => (a & b) == b);
        }
        else if (numberType.Equals(typeof(long)))
        {
            return BoxUnbox<long>(value, flags, (a, b) => (a & b) == b);
        }
        else if (numberType.Equals(typeof(ulong)))
        {
            return BoxUnbox<ulong>(value, flags, (a, b) => (a & b) == b);
        }
        else if (numberType.Equals(typeof(char)))
        {
            return BoxUnbox<char>(value, flags, (a, b) => (a & b) == b);
        }
        else
        {
            throw new ArgumentException("Unknown enum underlying type " + numberType.Name + ".");
        }
    }


    private static bool BoxUnbox<T>(object value, object flags, Func<T, T, bool> op)
    {
        return op((T)value, (T)flags);
    }

But I don't like the never ending if - else blocks, so is there a way to cast these values that I can use the & operator or any other solution to check this?

但我不喜欢永无止境的 if - else 块，所以有没有办法转换这些值，我可以使用 & 运算符或任何其他解决方案来检查这个？

采纳答案by Hugoware

Personally, I think that look fine because you've wrapped it into a single purpose function. If you had that code scattered through an entire program I think you would have some problems, but what you've created improves clarity everywhere it is used and the function itself is clear enough what it does.

就我个人而言，我认为这看起来不错，因为您已将其包装成一个单一用途的函数。如果您将这些代码分散在整个程序中，我认为您会遇到一些问题，但是您创建的内容可以提高使用它的任何地方的清晰度，并且函数本身也很清楚它的作用。

Just my opinion of course.

当然只是我的意见。

You could though, use the is keyword, which might help a little

不过，您可以使用 is 关键字，这可能会有所帮助

public static bool IsSet<T>(this T value, T flags) where T : Enum
{ 
    if (value is int)
    {
        return ((int)(object)a & (int)(object)b) == (int)(object)b);
    }
    //etc...

回答by Noldorin

This should do the job for enumtypes with any underlying types:

这应该为enum具有任何基础类型的类型完成工作：

public static bool IsSet<T>(this T value, T flags) where T : struct
{
    return (Convert.ToInt64(value) & Convert.ToInt64(flags)) ==
        Convert.ToInt64(flags);
}

Convert.ToInt64is used because a 64-bit integer is the "widest" integral type possible, to which all enum values can be cast (even ulong). Note that charis not a valid underlying type.It seems that it is notvalid in C#, but it isin general valid in CIL/for the CLR.

Convert.ToInt64之所以使用，是因为 64 位整数是可能的“最宽”整数类型，所有枚举值都可以转换为（甚至ulong）。请注意，这char不是有效的基础类型。看来，这是不是在C＃有效的，但它是在一般有效的CIL /为CLR。

Also, you can't enforce a generic type constraint for enums (i.e. where T : struct); the best you can do is use where T : structto enforce Tto be a value type, and then optionally perform a dynamic check to ensure that Tis an enum type.

此外，您不能对枚举（即where T : struct）强制执行泛型类型约束；您能做的最好的事情是使用where T : struct强制T成为值类型，然后可选地执行动态检查以确保它T是枚举类型。

For completeness, here is my very brief test harness:

为了完整起见，这是我非常简短的测试工具：

static class Program
{
    static void Main(string[] args)
    {
        Debug.Assert(Foo.abc.IsSet(Foo.abc));
        Debug.Assert(Bar.def.IsSet(Bar.def));
        Debug.Assert(Baz.ghi.IsSet(Baz.ghi));
    }

    enum Foo : int
    {
        abc = 1,
        def = 10,
        ghi = 100
    }

    enum Bar : sbyte
    {
        abc = 1,
        def = 10,
        ghi = 100
    }

    enum Baz : ulong
    {
        abc = 1,
        def = 10,
        ghi = 100
    }
}

回答by David Basarab

I have used this to compare flags

我用它来比较标志

public static bool IsSet<T>(this T input, T match)
{
    return (Convert.ToUInt32(input) & Convert.ToUInt32(match)) != 0;
}

Here you can do the different conversions. From int to short to long.

在这里您可以进行不同的转换。从整数到短到长。

回答by arbiter

For me it looks overcomplicated. How about this (keeping in mind that enum is always mapped to an integer value type):

对我来说，它看起来过于复杂。这个怎么样（记住枚举总是映射到整数值类型）：

public static bool IsSet<T>(T value, T flags) where T : struct
{
    // You can add enum type checking to be perfectly sure that T is enum, this have some cost however
    // if (!typeof(T).IsEnum)
    //     throw new ArgumentException();
    long longFlags = Convert.ToInt64(flags);
    return (Convert.ToInt64(value) & longFlags) == longFlags;
}

回答by Thomas Levesque

I wrote a set of extension methods for enums, in case you need it :

我为枚举编写了一组扩展方法，以防您需要它：

public static class EnumExtensions
{
    private static void CheckEnumWithFlags<T>()
    {
        if (!typeof(T).IsEnum)
            throw new ArgumentException(string.Format("Type '{0}' is not an enum", typeof(T).FullName));
        if (!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
    {
        CheckEnumWithFlags<T>();
        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
    {
        CheckEnumWithFlags<T>();
        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
    {
        CheckEnumWithFlags<T>();
        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
    {
        CheckEnumWithFlags<T>();
        long lValue = 0;
        foreach (T flag in flags)
        {
            long lFlag = Convert.ToInt64(flag);
            lValue |= lFlag;
        }
        return (T)Enum.ToObject(typeof(T), lValue);
    }
}

The main drawback is that you can't specify where T : Enum: it is explicitly forbidden ("Constraint cannot be special class 'System.Enum'"), so the extension methods will appear in intellisense for all structs... I added the CheckEnumWithFlagsmethod to check that the type is actually an enum, and has the Flagsattribute.

主要缺点是你不能指定where T : Enum：它是明确禁止的（“约束不能是特殊类'System.Enum'”），所以扩展方法将出现在所有结构的智能感知中......我添加了CheckEnumWithFlags检查的方法类型实际上是一个枚举，并具有Flags属性。

---

---

UPDATE : Jon Skeet recently started an interesting library called UnconstrainedMelodywhich does exactly the same sort of things, and works around the generic type constraint limitation mentioned above

更新：Jon Skeet 最近启动了一个有趣的库，名为UnconstrainedMelody，它做的事情完全一样，并且解决了上面提到的泛型类型约束限制

回答by Rik

or... public static bool IsSet(this Enum value, Enum compare) { int baseValue = value.ToInt32(); int compareValue = compare.ToInt32(); if (baseValue == 0) return false; return ((baseValue & compareValue) == compareValue); }

或... public static bool IsSet(this Enum value, Enum compare) { int baseValue = value.ToInt32(); int compareValue = compare.ToInt32(); 如果（baseValue == 0）返回false；return ((baseValue & compareValue) == compareValue); }

回答by Shazam

Simply use the Enum.HasFlag()Method !

只需使用Enum.HasFlag()方法！