C#：检查一组枚举值的最佳方法？

问题描述 投票：0回答：8

假设你有 

enum MyEnum {A = 0, B = 1, C = 2, D = 4, E = 8, F = 16};

在某些时候，您有一个函数将检查 MyEnum 的实例，如果它是 C、D 或 F，则返回 true 

bool IsCDF(MyEnum enumValue) 
{
  return //something slick
}

我记得有一些非常巧妙的方法来进行位移并执行此操作，其读起来比一堆三元 if 语句更好，但对于我的生活，我不记得它是什么。

有人知道吗？

c# math enums
8个回答
38
投票
bool IsCDF(MyEnum enumValue) 
{
  return new[]{MyEnum.C, MyEnum.D, MyEnum.F}.Contains(enumValue);
}
28
投票

如果将其设为

[Flags]
枚举，则可以为每个枚举值分配不同的位值（1、2、4、8、16...）。然后，您可以使用按位运算来确定某个值是否是一组可能值中的一个。

所以，看看它是 C、D 还是 F：

bool IsCDF(MyEnum enumValue)
{
    return ((enumValue & (MyEnum.C | MyEnum.D | MyEnum.F)) != 0);
}

或使用

HasFlag()
（效率较低但更具可读性）：

bool IsCDF(MyEnum enumValue)
{
    return enumValue.HasFlag(MyEnum.C | MyEnum.D | MyEnum.F);
}

请注意，这对于 0 值（在您的示例中为“A”）不起作用，并且您必须小心所有枚举值都解析为唯一的位值（即 2 的非零幂）。

这种方法的优点是：

  • 它通常需要单个 CPU 指令/周期来执行，而执行三个单独的“if”检查将需要 3 个或更多指令（取决于您的目标平台）。
  • 您可以将要测试的值集作为枚举值（单个整数）传递，而无需使用枚举值列表。
  • 您可以通过按位运算做许多其他有用的事情，而使用普通的数值/比较方法会显得笨重且缓慢。

方便提示： 定义 [Flags] 枚举时，使用左移 (

<<
) 使位值更清晰（并且更难出错），尤其是对于高阶位：

[Flags]
enum MyEnum
{
    A = 1 << 0,     // Equivalent to 1
    B = 1 << 1,     // Equivalent to 2
    C = 1 << 2,     // Equivalent to 4
    D = 1 << 3,     // Equivalent to 8
    …
    Big = 1 << 26,  // Equivalent to 67108864
}
5
投票

我可能会使用Unconstrained Melody作为保持事情整洁的一种方式：

if (value.HasAny(MyEnum.C | MyEnum.D | MyEnum.E))
{
    ...
}

我可能会将“C、D 或 E”位提取到命名常量中 - 可能在枚举本身中，如果它有意义的话：

3
投票

这是我创建的一个扩展，它允许您查看给定的枚举值是否位于枚举值的可能选择的变量列表中。

using System.Linq;
public static class ExtensionMethods
{
    public static bool IsAny<T>(this T value, params T[] choices)
        where T : Enum
    {
        return choices.Contains(value);
    }
}

使用方法

bool IsCDF(MyEnum enumValue) 
{
    return enumValue.IsAny(MyEnum.C, MyEnum.D, MyEnum.F);
}
2
投票

您可能正在考虑FlagsAttribute。请参阅 here 和 here 了解一些示例。

您可以使用 Enum.HasFlag 方法

1
投票

也许这个扩展类对你有用：

public static class Flags
{
    /// <summary>
    /// Checks if the type has any flag of value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public static bool HasAny<T>(this System.Enum type, T value)
    {
        try
        {
            return (((int) (object) type & (int) (object) value) != 0);
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// Checks if the value contains the provided type.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public static bool Has<T>(this System.Enum type, T value)
    {
        try
        {
            return (((int)(object)type & (int)(object)value) == (int)(object)value);
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// Checks if the value is only the provided type.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public static bool Is<T>(this System.Enum type, T value)
    {
        try
        {
            return (int)(object)type == (int)(object)value;
        }
        catch
        {
            return false;
        }
    }

    /// <summary>
    /// Appends a value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T Add<T>(this System.Enum type, T value)
    {
        try
        {
            return (T)(object)(((int)(object)type | (int)(object)value));
        }
        catch (Exception ex)
        {
            throw new ArgumentException(
                string.Format(
                    "Could not append value from enumerated type '{0}'.",
                    typeof(T).Name
                    ), ex);
        }
    }

    /// <summary>
    /// Appends a value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public static void AddTo<T>(this System.Enum type, ref T value)
    {
        try
        {
            value = (T)(object)(((int)(object)type | (int)(object)value));
        }
        catch (Exception ex)
        {
            throw new ArgumentException(
                string.Format(
                    "Could not append value from enumerated type '{0}'.",
                    typeof(T).Name
                    ), ex);
        }
    }

    /// <summary>
    /// Removes the value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T Remove<T>(this System.Enum type, T value)
    {
        try
        {
            return (T)(object)(((int)(object)type & ~(int)(object)value));
        }
        catch (Exception ex)
        {
            throw new ArgumentException(
                string.Format(
                    "Could not remove value from enumerated type '{0}'.",
                    typeof(T).Name
                    ), ex);
        }
    }

    /// <summary>
    /// Removes the value.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="type"></param>
    /// <param name="value"></param>
    /// <returns></returns>
    public static void RemoveFrom<T>(this System.Enum type, ref T value)
    {
        try
        {
            value = (T)(object)(((int)(object)type & ~(int)(object)value));
        }
        catch (Exception ex)
        {
            throw new ArgumentException(
                string.Format(
                    "Could not remove value from enumerated type '{0}'.",
                    typeof(T).Name
                    ), ex);
        }
    }
}
0
投票
return (enumValue & MyEnum.C == MyEnum.C) 
       || (enumValue & MyEnum.D == MyEnum.D) 
       || (enumValue & MyEnum.F == MyEnum.F);
0
投票

在 c# 8 中你可以这样做：

public class MyClass
{
    public static bool IsCDF(MyEnum enumValue) 
    {
        enumValue is MyEnum.C or MyEnum.D or MyEnum.F;
        // enumValue is not (MyEnum.C or MyEnum.D) // for nots
    }
}

使用扩展方法方式：

public static class EnumExtensions
{
    public static bool ContainsAnyFlag<T>(this T enumValue, params T[] flags) where T : Enum
    {
        return flags.Any(flag => enumValue.HasFlag(flag));
    }
}

var enumValue = MyEnum.A;
Console.WriteLine(enumValue.ContainsAnyFlag(MyEnum.C, MyEnum.B, MyEnum.D)); // Output: False
Console.WriteLine(enumValue.ContainsAnyFlag(MyEnum.A, MyEnum.B)); // Output: True

否则你可以这样做：

public static bool IsCDF(MyEnum enumValue)
{
    MyEnum flags = MyEnum.C | MyEnum.D | MyEnum.F;
    return (enumValue & flags) != 0;
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.