我需要验证一个整数才能知道它是否是一个有效的枚举值。
在 C# 中执行此操作的最佳方法是什么？
Jedi Master Spooky
问问题
70000 次
11 回答
96
您一定会爱上这些认为数据不仅总是来自 UI，而且在您的控制范围内的 UI 的人！
IsDefined在大多数情况下都很好，您可以从以下开始：
public static bool TryParseEnum<TEnum>(this int enumValue, out TEnum retVal)
{
retVal = default(TEnum);
bool success = Enum.IsDefined(typeof(TEnum), enumValue);
if (success)
{
retVal = (TEnum)Enum.ToObject(typeof(TEnum), enumValue);
}
return success;
}
（显然，如果您认为它不适合 int 扩展，请删除“this”）
于 2011-01-26T17:02:44.867 回答
26
恕我直言，标记为答案的帖子不正确。
参数和数据验证是几十年前钻研给我的事情之一。
为什么
验证是必需的，因为基本上任何整数值都可以分配给枚举而不会引发错误。
我花了很多天研究 C# 枚举验证，因为它在许多情况下是必要的功能。
在哪里
对我来说，枚举验证的主要目的是验证从文件中读取的数据：你永远不知道文件是否已损坏、是否被外部修改或被故意黑客入侵。
并且通过对从剪贴板粘贴的应用程序数据进行枚举验证：您永远不知道用户是否编辑了剪贴板内容。
也就是说，我花了几天时间研究和测试许多方法，包括分析我能找到或设计的每种方法的性能。
调用 System.Enum 中的任何内容都非常缓慢，以至于对于包含成百上千个对象的函数而言，这些对象的属性中具有一个或多个必须验证边界的枚举，这是一个明显的性能损失。
最重要的是，在验证枚举值时远离System.Enum 类中的所有内容，它非常慢。
结果
我目前用于枚举验证的方法可能会引起这里许多程序员的翻白眼，但恕我直言，对于我的特定应用程序设计而言，它是最不邪恶的。
我定义了一个或两个常量，它们是枚举的上限和（可选）下限，并在一对 if() 语句中使用它们进行验证。
一个缺点是，如果更改枚举，则必须确保更新常量。
此方法也仅在枚举是“自动”样式时才有效，其中每个枚举元素都是增量整数值，例如 0,1,2,3,4,.... 它不能与标志或枚举一起正常工作具有非增量值。
另请注意，此方法几乎与常规 int32 上的 "<" ">" 一样快（在我的测试中获得了 38,000 个滴答声）。
例如：
public const MyEnum MYENUM_MINIMUM = MyEnum.One;
public const MyEnum MYENUM_MAXIMUM = MyEnum.Four;
public enum MyEnum
{
One,
Two,
Three,
Four
};
public static MyEnum Validate(MyEnum value)
{
if (value < MYENUM_MINIMUM) { return MYENUM_MINIMUM; }
if (value > MYENUM_MAXIMUM) { return MYENUM_MAXIMUM; }
return value;
}
表现
对于那些感兴趣的人，我描述了枚举验证的以下变体，以下是结果。
分析是在发布编译时在每个方法上循环一百万次执行的，具有随机整数输入值。每个测试运行 10 次以上并取平均值。滴答结果包括执行的总时间，其中包括随机数生成等，但这些在测试中将保持不变。1 个滴答声 = 10ns。
注意这里的代码不是完整的测试代码，它只是基本的枚举验证方法。对这些进行了测试，还有许多其他变体，所有这些变体的结果都与此处显示的 1,800,000 滴答声相似。
列出从最慢到最快的四舍五入结果，希望没有错别字。
在方法中确定的界限= 13,600,000 滴答
public static T Clamp<T>(T value)
{
int minimum = Enum.GetValues(typeof(T)).GetLowerBound(0);
int maximum = Enum.GetValues(typeof(T)).GetUpperBound(0);
if (Convert.ToInt32(value) < minimum) { return (T)Enum.ToObject(typeof(T), minimum); }
if (Convert.ToInt32(value) > maximum) { return (T)Enum.ToObject(typeof(T), maximum); }
return value;
}
Enum.IsDefined = 1,800,000 tick
注意：此代码版本不会限制为 Min/Max，但如果超出范围则返回 Default。
public static T ValidateItem<T>(T eEnumItem)
{
if (Enum.IsDefined(typeof(T), eEnumItem) == true)
return eEnumItem;
else
return default(T);
}
System.Enum Convert Int32 with casts = 1,800,000 tick
public static Enum Clamp(this Enum value, Enum minimum, Enum maximum)
{
if (Convert.ToInt32(value) < Convert.ToInt32(minimum)) { return minimum; }
if (Convert.ToInt32(value) > Convert.ToInt32(maximum)) { return maximum; }
return value;
}
if() 最小/最大常数= 43,000 个滴答 = 获胜者快 42 倍和 316 倍。
public static MyEnum Clamp(MyEnum value)
{
if (value < MYENUM_MINIMUM) { return MYENUM_MINIMUM; }
if (value > MYENUM_MAXIMUM) { return MYENUM_MAXIMUM; }
return value;
}
-eol-
于 2013-04-01T22:03:57.430 回答
15
正如其他人提到的那样，Enum.IsDefined它很慢，如果它处于循环中，您必须注意这一点。
在进行多重比较时，更快的方法是首先将值放入HashSet. 然后简单地使用Contains来检查该值是否有效，如下所示：
int userInput = 4;
// below, Enum.GetValues converts enum to array. We then convert the array to hashset.
HashSet<int> validVals = new HashSet<int>((int[])Enum.GetValues(typeof(MyEnum)));
// the following could be in a loop, or do multiple comparisons, etc.
if (validVals.Contains(userInput))
{
// is valid
}
于 2014-12-04T22:16:46.543 回答
11
这是一个快速的通用解决方案，使用静态构造的HashSet<T>.
您可以在工具箱中定义一次，然后将其用于所有枚举验证。
public static class EnumHelpers
{
/// <summary>
/// Returns whether the given enum value is a defined value for its type.
/// Throws if the type parameter is not an enum type.
/// </summary>
public static bool IsDefined<T>(T enumValue)
{
if (typeof(T).BaseType != typeof(System.Enum)) throw new ArgumentException($"{nameof(T)} must be an enum type.");
return EnumValueCache<T>.DefinedValues.Contains(enumValue);
}
/// <summary>
/// Statically caches each defined value for each enum type for which this class is accessed.
/// Uses the fact that static things exist separately for each distinct type parameter.
/// </summary>
internal static class EnumValueCache<T>
{
public static HashSet<T> DefinedValues { get; }
static EnumValueCache()
{
if (typeof(T).BaseType != typeof(System.Enum)) throw new Exception($"{nameof(T)} must be an enum type.");
DefinedValues = new HashSet<T>((T[])System.Enum.GetValues(typeof(T)));
}
}
}
请注意，通过使用带有字符串键的字典（注意不区分大小写和数字字符串表示），这种方法也很容易扩展到枚举解析。
于 2019-03-06T16:50:39.363 回答
8
Enum.IsDefined布拉德艾布拉姆斯在他的帖子中特别警告不要过度简化的危险。
摆脱这种要求（即验证枚举的需要）的最好方法是删除用户可能会出错的地方，例如某种输入框。例如，使用带有下拉菜单的枚举来强制使用有效的枚举。
于 2008-08-17T13:46:20.833 回答
7
该答案是对 deegee 的回答的回应，该回答引发了 System.Enum 的性能问题，因此不应将其视为我首选的通用答案，更多地解决严格性能场景中的枚举验证。
如果您遇到关键任务性能问题，其中缓慢但功能性代码在紧密循环中运行，那么我个人会考虑尽可能将该代码移出循环，而不是通过减少功能来解决。例如，如果将来有人决定弃用某些枚举值，则将代码限制为仅支持连续枚举可能是寻找错误的噩梦。简单地说，您可以在开始时调用 Enum.GetValues 一次，以避免触发所有反射等数千次。这应该可以立即提高性能。如果您需要更高的性能并且您知道很多枚举是连续的（但您仍然希望支持“gappy”枚举），您可以更进一步并执行以下操作：
public abstract class EnumValidator<TEnum> where TEnum : struct, IConvertible
{
protected static bool IsContiguous
{
get
{
int[] enumVals = Enum.GetValues(typeof(TEnum)).Cast<int>().ToArray();
int lowest = enumVals.OrderBy(i => i).First();
int highest = enumVals.OrderByDescending(i => i).First();
return !Enumerable.Range(lowest, highest).Except(enumVals).Any();
}
}
public static EnumValidator<TEnum> Create()
{
if (!typeof(TEnum).IsEnum)
{
throw new ArgumentException("Please use an enum!");
}
return IsContiguous ? (EnumValidator<TEnum>)new ContiguousEnumValidator<TEnum>() : new JumbledEnumValidator<TEnum>();
}
public abstract bool IsValid(int value);
}
public class JumbledEnumValidator<TEnum> : EnumValidator<TEnum> where TEnum : struct, IConvertible
{
private readonly int[] _values;
public JumbledEnumValidator()
{
_values = Enum.GetValues(typeof (TEnum)).Cast<int>().ToArray();
}
public override bool IsValid(int value)
{
return _values.Contains(value);
}
}
public class ContiguousEnumValidator<TEnum> : EnumValidator<TEnum> where TEnum : struct, IConvertible
{
private readonly int _highest;
private readonly int _lowest;
public ContiguousEnumValidator()
{
List<int> enumVals = Enum.GetValues(typeof (TEnum)).Cast<int>().ToList();
_lowest = enumVals.OrderBy(i => i).First();
_highest = enumVals.OrderByDescending(i => i).First();
}
public override bool IsValid(int value)
{
return value >= _lowest && value <= _highest;
}
}
你的循环变成这样的地方：
//Pre import-loop
EnumValidator< MyEnum > enumValidator = EnumValidator< MyEnum >.Create();
while(import) //Tight RT loop.
{
bool isValid = enumValidator.IsValid(theValue);
}
我确信 EnumValidator 类可以更有效地编写（这只是一个快速演示），但坦率地说，谁在乎导入循环之外发生了什么？唯一需要超快的位是在循环内。这就是采用抽象类路由的原因，以避免循环中不必要的 if-enumContiguous-then-else（工厂 Create 基本上是预先完成的）。您会注意到有点虚伪，为简洁起见，此代码将功能限制为 int-enums。我应该使用 IConvertible 而不是直接使用 int，但是这个答案已经够罗嗦了！
于 2014-02-24T14:10:23.250 回答
2
这就是我根据网上的多个帖子进行操作的方式。这样做的原因是为了确保用Flags属性标记的枚举也可以成功验证。
public static TEnum ParseEnum<TEnum>(string valueString, string parameterName = null)
{
var parsed = (TEnum)Enum.Parse(typeof(TEnum), valueString, true);
decimal d;
if (!decimal.TryParse(parsed.ToString(), out d))
{
return parsed;
}
if (!string.IsNullOrEmpty(parameterName))
{
throw new ArgumentException(string.Format("Bad parameter value. Name: {0}, value: {1}", parameterName, valueString), parameterName);
}
else
{
throw new ArgumentException("Bad value. Value: " + valueString);
}
}
于 2013-09-26T18:46:22.953 回答
2
基于 Timo 的回答，我精心设计了以下扩展方法（C# 6 语法）来提供快速、通用的解决方案。
这避免了 的性能问题Enum.IsDefined，并且语法更简洁。
public static class EnumHelpers
{
/// <summary>
/// Returns whether the given enum value is a defined value for its type.
/// </summary>
public static bool IsDefined<T>(this T enumValue)
where T : Enum
=> EnumValueCache<T>.DefinedValues.Contains(enumValue);
/// <summary>
/// Caches the defined values for each enum type for which this class is accessed.
/// </summary>
private static class EnumValueCache<T>
where T : Enum
{
public static readonly HashSet<T> DefinedValues = new HashSet<T>((T[])Enum.GetValues(typeof(T)));
}
}
用法：
if (!myEnumValue.IsDefined())
// ...
于 2019-06-27T17:57:20.040 回答
1
您可以将 FluentValidation 用于您的项目。这是“枚举验证”的一个简单示例
让我们使用 FluentValidation 创建一个 EnumValidator 类；
public class EnumValidator<TEnum> : AbstractValidator<TEnum> where TEnum : struct, IConvertible, IComparable, IFormattable
{
public EnumValidator(string message)
{
RuleFor(a => a).Must(a => typeof(TEnum).IsEnum).IsInEnum().WithMessage(message);
}
}
现在我们创建了我们的 enumvalidator 类；让我们创建一个类来调用 enumvalidor 类；
public class Customer
{
public string Name { get; set; }
public Address address{ get; set; }
public AddressType type {get; set;}
}
public class Address
{
public string Line1 { get; set; }
public string Line2 { get; set; }
public string Town { get; set; }
public string County { get; set; }
public string Postcode { get; set; }
}
public enum AddressType
{
HOME,
WORK
}
是时候为客户类中的地址类型调用我们的枚举验证器了。
public class CustomerValidator : AbstractValidator<Customer>
{
public CustomerValidator()
{
RuleFor(x => x.type).SetValidator(new EnumValidator<AddressType>("errormessage");
}
}
于 2019-12-24T14:41:23.500 回答
0
我发现这个链接很好地回答了它。它用：
(ENUMTYPE)Enum.ToObject(typeof(ENUMTYPE), INT)
于 2008-08-17T14:40:04.500 回答
0
要验证一个值是否是枚举中的有效值，您只需要调用静态方法Enum.IsDefined 即可。
int value = 99;//Your int value
if (Enum.IsDefined(typeof(your_enum_type), value))
{
//Todo when value is valid
}else{
//Todo when value is not valid
}
于 2016-07-12T14:09:39.347 回答