有没有办法检查 int 是否是 C# 中的合法枚举？

Question

我读过一些 SO 帖子，似乎缺少最基本的操作。

public enum LoggingLevel
{
    Off = 0,
    Error = 1,
    Warning = 2,
    Info = 3,
    Debug = 4,
    Trace = 5
};

if (s == "LogLevel")
{
    _log.LogLevel = (LoggingLevel)Convert.ToInt32("78");
    _log.LogLevel = (LoggingLevel)Enum.Parse(typeof(LoggingLevel), "78");
    _log.WriteDebug(_log.LogLevel.ToString());
}

这不会导致异常，它很乐意存储 78。有没有办法验证进入枚举的值？

Answer 1

上述解决方案不处理[Flags]情况。

我下面的解决方案可能存在一些性能问题（我确信可以通过各种方式进行优化），但本质上它将始终证明枚举值是否有效。

它依赖于三个假设：

• C# 中的枚举值仅允许为 int，绝对不能为其他
• C# 中的枚举名称必须以字母字符开头
• 不能使用有效的枚举名称带减号：-

如果没有匹配的枚举（标志或不），则对枚举调用 ToString() 会返回 int 值。如果匹配允许的枚举值，它将打印匹配的名称。

因此：

[Flags]
enum WithFlags
{
    First = 1,
    Second = 2,
    Third = 4,
    Fourth = 8
}

((WithFlags)2).ToString() ==> "Second"
((WithFlags)(2 + 4)).ToString() ==> "Second, Third"
((WithFlags)20).ToString() ==> "20"

考虑到这两条规则，我们可以假设，如果 .NET Framework 正确完成其工作，则对有效枚举的 ToString() 方法的任何调用都将产生以字母字符作为其值的内容。第一个字符：

public static bool IsValid<TEnum>(this TEnum enumValue)
    where TEnum : struct
{
    var firstChar = enumValue.ToString()[0];
    return (firstChar < '0' || firstChar > '9') && firstChar != '-';
}

人们可以称其为“hack”，但优点是，通过依赖 Microsoft 自己的 Enum 和 C# 标准实现，您不必依赖自己的可能有错误的代码或检查。在性能不是特别关键的情况下，这将节省大量令人讨厌的 switch 语句或其他检查！

编辑

感谢@ChaseMedallion 指出我最初的实现不支持负值。此问题已得到纠正并提供了测试。

以及支持它的测试：

[TestClass]
public class EnumExtensionsTests
{
    [Flags]
    enum WithFlags
    {
        First = 1,
        Second = 2,
        Third = 4,
        Fourth = 8
    }

    enum WithoutFlags
    {
        First = 1,
        Second = 22,
        Third = 55,
        Fourth = 13,
        Fifth = 127
    }

    enum WithoutNumbers
    {
        First, // 1
        Second, // 2
        Third, // 3
        Fourth // 4
    }

    enum WithoutFirstNumberAssigned
    {
        First = 7,
        Second, // 8
        Third, // 9
        Fourth // 10
    }


    enum WithNagativeNumbers
    {
        First = -7,
        Second = -8,
        Third = -9,
        Fourth = -10
    }

    [TestMethod]
    public void IsValidEnumTests()
    {
        Assert.IsTrue(((WithFlags)(1 | 4)).IsValid());
        Assert.IsTrue(((WithFlags)(1 | 4)).IsValid());
        Assert.IsTrue(((WithFlags)(1 | 4 | 2)).IsValid());
        Assert.IsTrue(((WithFlags)(2)).IsValid());
        Assert.IsTrue(((WithFlags)(3)).IsValid());
        Assert.IsTrue(((WithFlags)(1 + 2 + 4 + 8)).IsValid());

        Assert.IsFalse(((WithFlags)(16)).IsValid());
        Assert.IsFalse(((WithFlags)(17)).IsValid());
        Assert.IsFalse(((WithFlags)(18)).IsValid());
        Assert.IsFalse(((WithFlags)(0)).IsValid());

        Assert.IsTrue(((WithoutFlags)1).IsValid());
        Assert.IsTrue(((WithoutFlags)22).IsValid());
        Assert.IsTrue(((WithoutFlags)(53 | 6)).IsValid());   // Will end up being Third
        Assert.IsTrue(((WithoutFlags)(22 | 25 | 99)).IsValid()); // Will end up being Fifth
        Assert.IsTrue(((WithoutFlags)55).IsValid());
        Assert.IsTrue(((WithoutFlags)127).IsValid());

        Assert.IsFalse(((WithoutFlags)48).IsValid());
        Assert.IsFalse(((WithoutFlags)50).IsValid());
        Assert.IsFalse(((WithoutFlags)(1 | 22)).IsValid());
        Assert.IsFalse(((WithoutFlags)(9 | 27 | 4)).IsValid());

        Assert.IsTrue(((WithoutNumbers)0).IsValid());
        Assert.IsTrue(((WithoutNumbers)1).IsValid());
        Assert.IsTrue(((WithoutNumbers)2).IsValid());
        Assert.IsTrue(((WithoutNumbers)3).IsValid());
        Assert.IsTrue(((WithoutNumbers)(1 | 2)).IsValid()); // Will end up being Third
        Assert.IsTrue(((WithoutNumbers)(1 + 2)).IsValid()); // Will end up being Third

        Assert.IsFalse(((WithoutNumbers)4).IsValid());
        Assert.IsFalse(((WithoutNumbers)5).IsValid());
        Assert.IsFalse(((WithoutNumbers)25).IsValid());
        Assert.IsFalse(((WithoutNumbers)(1 + 2 + 3)).IsValid());

        Assert.IsTrue(((WithoutFirstNumberAssigned)7).IsValid());
        Assert.IsTrue(((WithoutFirstNumberAssigned)8).IsValid());
        Assert.IsTrue(((WithoutFirstNumberAssigned)9).IsValid());
        Assert.IsTrue(((WithoutFirstNumberAssigned)10).IsValid());

        Assert.IsFalse(((WithoutFirstNumberAssigned)11).IsValid());
        Assert.IsFalse(((WithoutFirstNumberAssigned)6).IsValid());
        Assert.IsFalse(((WithoutFirstNumberAssigned)(7 | 9)).IsValid());
        Assert.IsFalse(((WithoutFirstNumberAssigned)(8 + 10)).IsValid());

        Assert.IsTrue(((WithNagativeNumbers)(-7)).IsValid());
        Assert.IsTrue(((WithNagativeNumbers)(-8)).IsValid());
        Assert.IsTrue(((WithNagativeNumbers)(-9)).IsValid());
        Assert.IsTrue(((WithNagativeNumbers)(-10)).IsValid());
        Assert.IsFalse(((WithNagativeNumbers)(-11)).IsValid());
        Assert.IsFalse(((WithNagativeNumbers)(7)).IsValid());
        Assert.IsFalse(((WithNagativeNumbers)(8)).IsValid());
    }
}

Answer 2

规范的答案是 Enum.IsDefined，但这 a：如果在紧密循环中使用，有点慢，b：对于 [Flags] 枚举没有用。

就我个人而言，我不会再担心这一点，只需适当地切换，记住：

• 如果可以不识别所有内容（并且不执行任何操作），那么就不要添加默认值: （或者有一个空的 default: 解释原因）
• 如果存在合理的默认行为，请将其放入 default:
• 否则，处理您知道的默认行为about 并为其余部分抛出异常：

像这样：

switch(someflag) {
    case TriBool.Yes:
        DoSomething();
        break;
    case TriBool.No:
        DoSomethingElse();
        break;
    case TriBool.FileNotFound:
        DoSomethingOther();
        break;
    default:
        throw new ArgumentOutOfRangeException("someflag");
}

Answer 3

使用：

Enum.IsDefined ( typeof ( Enum ), EnumValue );

Answer 4

使用Enum.IsDefined。

Answer 5

为了处理 [Flags] 您还可以使用 C# Cookbook 中的此解决方案：

首先，向枚举添加一个新的 ALL 值：

[Flags]
enum Language
{
    CSharp = 1, VBNET = 2, VB6 = 4, 
    All = (CSharp | VBNET | VB6)
}

然后，检查该值是否在 ALL 中：

public bool HandleFlagsEnum(Language language)
{
    if ((language & Language.All) == language)
    {
        return (true);
    }
    else
    {
        return (false);
    }
}

Answer 6

正如其他人所说，即使您具有使用 FlagsAttribute 装饰的枚举的有效位标志组合，Enum.IsDefined 也会返回 false。

遗憾的是，创建对 有效 位标志返回 true 的方法的唯一方法有点冗长：

public static bool ValidateEnumValue<T>(T value) where T : Enum
{
    // Check if a simple value is defined in the enum.
    Type enumType = typeof(T);
    bool valid = Enum.IsDefined(enumType, value);
    // For enums decorated with the FlagsAttribute, allow sets of flags.
    if (!valid && enumType.GetCustomAttributes(typeof(FlagsAttribute), false)?.Any() == true)
    {
        long mask = 0;
        foreach (object definedValue in Enum.GetValues(enumType))
            mask |= Convert.ToInt64(definedValue);
        long longValue = Convert.ToInt64(value);
        valid = (mask & longValue) == longValue;
    }
    return valid;
}

您可能希望将 GetCustomAttribute 的结果缓存在字典中：

private static readonly Dictionary<Type, bool> _flagEnums = new Dictionary<Type, bool>();
public static bool ValidateEnumValue<T>(T value) where T : Enum
{
    // Check if a simple value is defined in the enum.
    Type enumType = typeof(T);
    bool valid = Enum.IsDefined(enumType, value);
    if (!valid)
    {
        // For enums decorated with the FlagsAttribute, allow sets of flags.
        if (!_flagEnums.TryGetValue(enumType, out bool isFlag))
        {
            isFlag = enumType.GetCustomAttributes(typeof(FlagsAttribute), false)?.Any() == true;
            _flagEnums.Add(enumType, isFlag);
        }
        if (isFlag)
        {
            long mask = 0;
            foreach (object definedValue in Enum.GetValues(enumType))
                mask |= Convert.ToInt64(definedValue);
            long longValue = Convert.ToInt64(value);
            valid = (mask & longValue) == longValue;
        }
    }
    return valid;
}

请注意上面的代码对 T 使用了新的 Enum 约束，该约束仅自 C# 7.3 起可用。在旧版本中，您需要传递一个对象值并对其调用GetType()。

Answer 7

一种方法是依靠强制转换和枚举到字符串的转换。将 int 转换为 Enum 类型时，int 会转换为相应的枚举值，或者如果未为 int 定义枚举值，则生成的枚举仅包含 int 作为值。

enum NetworkStatus{
  Unknown=0,
  Active,
  Slow
}

int statusCode=2;
NetworkStatus netStatus = (NetworkStatus) statusCode;
bool isDefined = netStatus.ToString() != statusCode.ToString();

未测试任何边缘情况。

Answer 8

我知道这是一个老问题，但我今天遇到了这个问题，我想扩展 Josh Comley 的答案（https://stackoverflow .com/a/23177585/3403999）

我想解决乔什的回答中有几个错误的假设：

1. 它假设“-”始终是负号。我不知道是否有任何文化使用不同的符号，但 .Net 当然允许在 NumberFormatInfo 中使用它（https://learn.microsoft.com/en-us/dotnet/api/system.globalization.numberformatinfo. Negativesign?view=net -5.0）。我能想到的唯一可能常见的是括号，即 (1) == -1。
2. 枚举成员必须以字母字符开头。具体来说，我知道您可以使用下划线作为第一个字符。 IE，enum MyEnum { _One = 1 } 有效。
3. 不太确定这完全错误，但它假设“0”到“9”和“-”范围之外的任何内容都是有效的字母字符。这似乎是一个错误的假设，因为该范围之外的控制字符会返回 true - 尽管我认为您无法将这些控制字符放入枚举成员名称中而不引发编译错误。

无论如何，这是我更新的解决方案：

public static bool IsValid<TEnum>(this TEnum value) where TEnum : System.Enum
{
    char first = value.ToString()[0];
    return (char.IsLetter(first) || first == '_');
}

我确实发现您可以在枚举成员名称中使用其他语言的 Unicode 字母（https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/inside-a-program/identifier-names< /a>）。我的解决方案在这方面仍然通过。我使用以下枚举进行了测试：enum MyEnum { \u05D0 }。枚举已编译，IsValid 返回 true。

我很好奇，与使用带有填充 Enum.GetValues(typeof(TEnum)) 的 HashSet 的静态帮助程序类相比，您会采取这种路线，在其中检查是否会受到什么样的性能影响HashSet 包含枚举值。我们的想法是，Enum.GetValues 和 Enum.IsDefined 都只是昂贵的反射命中的包装，因此您可以使用 GetValues 执行一次反射，缓存结果，然后只需检查 HashSet。

我使用 StopWatch 和 Random 进行了一个相当简单的测试，它将生成有效的 &无效的枚举值，然后我通过 3 种不同的方法运行它们：ToString 方法、GetValues HashSet 方法和 IsDefined 方法。我让他们对每个方法执行 int.MaxValue 次。结果：

• 每次运行 20 亿次，ToString 平均需要 2 分钟左右。
• GetValues HashSet 每次运行 20 亿次大约需要 50 秒。
• 每次运行 20 亿次 IsDefined 大约需要 5 分钟。

因此，如果性能是一个问题，或者您正在执行循环，那么所有推荐 IsDefined 的解决方案可能都是一个坏主意。如果您只是使用它以某种方式验证单个实例上的用户输入，那么它可能并不重要。

对于 HashSet，对于您运行的每个不同的枚举来说，性能都会受到影响（因为第一次运行新的枚举类型会生成一个新的静态 HashSet）。不科学，但在我的 PC 上，在开始使用 ToString 方法执行单个枚举之前，我的盈亏平衡点似乎约为 200k 到 300k 运行。

ToString 方法虽然不是最快的方法，但具有处理 IsDefined 和 HashSet 都无法容纳的 Flags 枚举的额外好处。

如果性能确实是一个问题，请不要使用这 3 种方法中的任何一种。相反，编写一个方法来验证针对该枚举优化的特定枚举。

另请注意，我的测试使用相对较小的枚举（5 个左右的元素）。一旦你开始使用更大的枚举，我不知道 ToString 与 HashSet 之间的性能如何。

Answer 9

对一个老问题的另一个答案，源于以下事实：a）如果您有一个 int 对于您的枚举来说不是有效值，并且您尝试将其转换为该枚举类型，它将无论如何强制转换它，但结果值将与您定义的任何枚举值都不匹配，并且 b) 有一个通用版本的 Enum.IsDefined ，它将根据您传递给它的内容推断出类型。这是一个利用上述内容的通用 TryGetEnumValue 示例。

public static bool TryGetEnumValue<TEnum>(int tryMe, out TEnum enumValue) where TEnum : struct, Enum
{
    // This will cast the int to a TEnum, even if it is not a defined TEnum value.
    var val = (TEnum)(object)tryMe;

    // So now we test to see if it is a defined T enum value.
    if (Enum.IsDefined(val))
    {
        enumValue = val;
        return true;
    }
    else
    {
        enumValue = default;
        return false;
    }
}

一些测试显示了它的工作效果：

public enum PorridgeNiceness
{
    NotSet,
    TooCold,
    JustRight,
    TooHot
}
// Having not explictly assigned int values to my enum above, 
// they will be 0, 1, 2, 3 in that order.

[TestMethod] 
public void Test_() 
{
    Assert.IsTrue(TryGetEnumValue(1, out PorridgeNiceness a));
    Assert.AreEqual(PorridgeNiceness.TooCold, a);

    Assert.IsTrue(TryGetEnumValue(2, out PorridgeNiceness b));
    Assert.AreEqual(PorridgeNiceness.JustRight, b);

    Assert.IsFalse(TryGetEnumValue(99, out PorridgeNiceness _));
}

根据本线程中的其他讨论，此方法不会识别复合 Flags 值。

Answer 10

查看 Enum.IsDefined

用法：

if(Enum.IsDefined(typeof(MyEnum), value))
    MyEnum a = (MyEnum)value; 

这是示例从该页面：

using System;    
[Flags] public enum PetType
{
   None = 0, Dog = 1, Cat = 2, Rodent = 4, Bird = 8, Reptile = 16, Other = 32
};

public class Example
{
   public static void Main()
   {
      object value;     
      // Call IsDefined with underlying integral value of member.
      value = 1;
      Console.WriteLine("{0}: {1}", value, Enum.IsDefined(typeof(PetType), value));
      // Call IsDefined with invalid underlying integral value.
      value = 64;
      Console.WriteLine("{0}: {1}", value, Enum.IsDefined(typeof(PetType), value));
      // Call IsDefined with string containing member name.
      value = "Rodent";
      Console.WriteLine("{0}: {1}", value, Enum.IsDefined(typeof(PetType), value));
      // Call IsDefined with a variable of type PetType.
      value = PetType.Dog;
      Console.WriteLine("{0}: {1}", value, Enum.IsDefined(typeof(PetType), value));
      value = PetType.Dog | PetType.Cat;
      Console.WriteLine("{0}: {1}", value, Enum.IsDefined(typeof(PetType), value));
      // Call IsDefined with uppercase member name.      
      value = "None";
      Console.WriteLine("{0}: {1}", value, Enum.IsDefined(typeof(PetType), value));
      value = "NONE";
      Console.WriteLine("{0}: {1}", value, Enum.IsDefined(typeof(PetType), value));
      // Call IsDefined with combined value
      value = PetType.Dog | PetType.Bird;
      Console.WriteLine("{0:D}: {1}", value, Enum.IsDefined(typeof(PetType), value));
      value = value.ToString();
      Console.WriteLine("{0:D}: {1}", value, Enum.IsDefined(typeof(PetType), value));
   }
}

该示例显示以下输出：

//       1: True
//       64: False
//       Rodent: True
//       Dog: True
//       Dog, Cat: False
//       None: True
//       NONE: False
//       9: False
//       Dog, Bird: False