创buildgenerics方法约束T到一个枚举

我正在构build一个扩展Enum.Parse概念的函数

• 允许在没有findEnum值的情况下parsing默认值
• 不区分大小写

所以我写了以下内容：

public static T GetEnumFromString<T>(string value, T defaultValue) where T : Enum { if (string.IsNullOrEmpty(value)) return defaultValue; foreach (T item in Enum.GetValues(typeof(T))) { if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item; } return defaultValue; } 

我得到一个错误约束不能是特殊的类“System.Enum”。

公平的，但是有一个解决方法，以允许一个通用的枚举，或者我将不得不模仿parsing函数和传递一个types作为一个属性，这迫使丑陋的拳击要求您的代码。

编辑下面的所有build议已经非常感谢，谢谢。

已经解决了（我已经离开了循环保持不区分大小写 – 我parsingXML的时候就是这样）

 public static class EnumUtils { public static T ParseEnum<T>(string value, T defaultValue) where T : struct, IConvertible { if (!typeof(T).IsEnum) throw new ArgumentException("T must be an enumerated type"); if (string.IsNullOrEmpty(value)) return defaultValue; foreach (T item in Enum.GetValues(typeof(T))) { if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item; } return defaultValue; } } 

编辑： （2015年2月16日）Julien Lebosquain最近发布了一个编译器强制types安全的通用解决scheme在MSIL或F＃下面，这是非常值得一看，并upvote。 如果解决scheme在页面上进一步起泡，我将删除此编辑。

Answer 1

由于Enum Type实现了IConvertible接口，更好的实现应该是这样的：

 public T GetEnumFromString<T>(string value) where T : struct, IConvertible { if (!typeof(T).IsEnum) { throw new ArgumentException("T must be an enumerated type"); } //... } 

这仍然允许传递实现IConvertible的值types。 虽然这种可能性很less见。

Answer 2

我迟到了，但是我把它看成是一个挑战，看看如何做到这一点。 在C＃（或VB.NET，但向下滚动F＃） 是不可能的 ，但在MSIL中是可能的。 我写了这个小东西

 // license: http://www.apache.org/licenses/LICENSE-2.0.html .assembly MyThing{} .class public abstract sealed MyThing.Thing extends [mscorlib]System.Object { .method public static !!T GetEnumFromString<valuetype .ctor ([mscorlib]System.Enum) T>(string strValue, !!T defaultValue) cil managed { .maxstack 2 .locals init ([0] !!T temp, [1] !!T return_value, [2] class [mscorlib]System.Collections.IEnumerator enumerator, [3] class [mscorlib]System.IDisposable disposer) // if(string.IsNullOrEmpty(strValue)) return defaultValue; ldarg strValue call bool [mscorlib]System.String::IsNullOrEmpty(string) brfalse.s HASVALUE br RETURNDEF // return default it empty // foreach (T item in Enum.GetValues(typeof(T))) HASVALUE: // Enum.GetValues.GetEnumerator() ldtoken !!T call class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle) call class [mscorlib]System.Array [mscorlib]System.Enum::GetValues(class [mscorlib]System.Type) callvirt instance class [mscorlib]System.Collections.IEnumerator [mscorlib]System.Array::GetEnumerator() stloc enumerator .try { CONDITION: ldloc enumerator callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext() brfalse.s LEAVE STATEMENTS: // T item = (T)Enumerator.Current ldloc enumerator callvirt instance object [mscorlib]System.Collections.IEnumerator::get_Current() unbox.any !!T stloc temp ldloca.s temp constrained. !!T // if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item; callvirt instance string [mscorlib]System.Object::ToString() callvirt instance string [mscorlib]System.String::ToLower() ldarg strValue callvirt instance string [mscorlib]System.String::Trim() callvirt instance string [mscorlib]System.String::ToLower() callvirt instance bool [mscorlib]System.String::Equals(string) brfalse.s CONDITION ldloc temp stloc return_value leave.s RETURNVAL LEAVE: leave.s RETURNDEF } finally { // ArrayList's Enumerator may or may not inherit from IDisposable ldloc enumerator isinst [mscorlib]System.IDisposable stloc.s disposer ldloc.s disposer ldnull ceq brtrue.s LEAVEFINALLY ldloc.s disposer callvirt instance void [mscorlib]System.IDisposable::Dispose() LEAVEFINALLY: endfinally } RETURNDEF: ldarg defaultValue stloc return_value RETURNVAL: ldloc return_value ret } } 

它生成一个看起来像这样的函数，如果它是有效的C＃：

 T GetEnumFromString<T>(string valueString, T defaultValue) where T : Enum 

然后用下面的C＃代码：

 using MyThing; // stuff... private enum MyEnum { Yes, No, Okay } static void Main(string[] args) { Thing.GetEnumFromString("No", MyEnum.Yes); // returns MyEnum.No Thing.GetEnumFromString("Invalid", MyEnum.Okay); // returns MyEnum.Okay Thing.GetEnumFromString("AnotherInvalid", 0); // compiler error, not an Enum } 

不幸的是，这意味着将这部分代码写成MSIL而不是C＃，唯一的附加好处是可以通过System.Enum约束这个方法。 这也是一种无赖，因为它被编译成一个单独的程序集。 但是，这并不意味着你必须这样部署。

通过删除行.assembly MyThing{}并调用ilasm，如下所示：

 ilasm.exe /DLL /OUTPUT=MyThing.netmodule 

你得到一个netmodule而不是一个程序集。

不幸的是，VS2010（和更早的，显然）不支持添加netmodule引用，这意味着当你正在debugging时，你不得不把它放在2个独立的程序集中。 您可以将它们作为程序集的一部分添加的唯一方法是使用/addmodule:{files}命令行参数自己运行csc.exe。 在MSBuild脚本中不会太痛苦。 当然，如果你勇敢或愚蠢，你可以每次手动运行csc。 由于多个程序集需要访问它，它肯定会变得更加复杂。

所以，它可以在.Net中完成。 这值得额外的努力吗？ 恩，好吧，我想我会让你决定那个。

---

F＃解决scheme作为替代

额外的信用：事实certificate，除了MSIL以外，至less还有一种.NET语言可以对enum进行通用限制：F＃。

 type MyThing = static member GetEnumFromString<'T when 'T :> Enum> str defaultValue: 'T = /// protect for null (only required in interop with C#) let str = if isNull str then String.Empty else str Enum.GetValues(typedefof<'T>) |> Seq.cast<_> |> Seq.tryFind(fun v -> String.Compare(v.ToString(), str.Trim(), true) = 0) |> function Some x -> x | None -> defaultValue 

这是一个很容易维护，因为它是一个熟悉的语言与完整的Visual Studio IDE支持，但你仍然需要一个单独的项目在你的解决scheme。 然而，它自然会产生相当不同的IL（代码是非常不同的），它依赖于FSharp.Core库，就像任何其他外部库一样，它需要成为你的发行版的一部分。

以下是您可以如何使用它（基本上与MSIL解决scheme相同），并显示它在其他同义词结构上正确失败：

 // works, result is inferred to have type StringComparison var result = MyThing.GetEnumFromString("OrdinalIgnoreCase", StringComparison.Ordinal); // type restriction is recognized by C#, this fails at compile time var result = MyThing.GetEnumFromString("OrdinalIgnoreCase", 42); 

Answer 3

你可以有一个真正的编译器通过滥用约束inheritance强制枚举约束。 下面的代码同时指定了一个class和一个struct约束：

 public abstract class EnumClassUtils<TClass> where TClass : class { public static TEnum Parse<TEnum>(string value) where TEnum : struct, TClass { return (TEnum) Enum.Parse(typeof(TEnum), value); } } public class EnumUtils : EnumClassUtils<Enum> { } 

用法：

 EnumUtils.Parse<SomeEnum>("value"); 

注意：这在C＃5.0语言规范中有具体说明：

如果types参数S取决于types参数T，那么：[…] S具有值types约束和T具有引用types约束是有效的。 实际上，这将T限制为System.Object，System.ValueType，System.Enumtypes和任何接口types。

Answer 4

编辑

Julien Lebosquain现在回答了这个问题。 我还想用ignoreCase ， defaultValue和可选参数来扩展他的答案，同时添加TryParse和ParseOrDefault 。

 public abstract class ConstrainedEnumParser<TClass> where TClass : class // value type constraint S ("TEnum") depends on reference type T ("TClass") [and on struct] { // internal constructor, to prevent this class from being inherited outside this code internal ConstrainedEnumParser() {} // Parse using pragmatic/adhoc hard cast: // - struct + class = enum // - 'guaranteed' call from derived <System.Enum>-constrained type EnumUtils public static TEnum Parse<TEnum>(string value, bool ignoreCase = false) where TEnum : struct, TClass { return (TEnum)Enum.Parse(typeof(TEnum), value, ignoreCase); } public static bool TryParse<TEnum>(string value, out TEnum result, bool ignoreCase = false, TEnum defaultValue = default(TEnum)) where TEnum : struct, TClass // value type constraint S depending on T { var didParse = Enum.TryParse(value, ignoreCase, out result); if (didParse == false) { result = defaultValue; } return didParse; } public static TEnum ParseOrDefault<TEnum>(string value, bool ignoreCase = false, TEnum defaultValue = default(TEnum)) where TEnum : struct, TClass // value type constraint S depending on T { if (string.IsNullOrEmpty(value)) { return defaultValue; } TEnum result; if (Enum.TryParse(value, ignoreCase, out result)) { return result; } return defaultValue; } } public class EnumUtils: ConstrainedEnumParser<System.Enum> // reference type constraint to any <System.Enum> { // call to parse will then contain constraint to specific <System.Enum>-class } 

用法示例：

 WeekDay parsedDayOrArgumentException = EnumUtils.Parse<WeekDay>("monday", ignoreCase:true); WeekDay parsedDayOrDefault; bool didParse = EnumUtils.TryParse<WeekDay>("clubs", out parsedDayOrDefault, ignoreCase:true); parsedDayOrDefault = EnumUtils.ParseOrDefault<WeekDay>("friday", ignoreCase:true, defaultValue:WeekDay.Sunday); 

---

旧

通过使用评论和“新”发展，我对Vivek的回答进行了一些改进：

• 使用TEnum为用户清晰
• 为更多的约束检查添加更多的接口约束
• 让TryParse处理ignoreCase与现有参数（在VS2010 / .Net 4中引入）
• 可选地使用通用default值 （在VS2005 / .Net 2中引入）
• 使用可选参数 （在VS2010 / .Net 4中引入），默认值为defaultValue和ignoreCase

导致：

 public static class EnumUtils { public static TEnum ParseEnum<TEnum>(this string value, bool ignoreCase = true, TEnum defaultValue = default(TEnum)) where TEnum : struct, IComparable, IFormattable, IConvertible { if ( ! typeof(TEnum).IsEnum) { throw new ArgumentException("TEnum must be an enumerated type"); } if (string.IsNullOrEmpty(value)) { return defaultValue; } TEnum lResult; if (Enum.TryParse(value, ignoreCase, out lResult)) { return lResult; } return defaultValue; } } 

Answer 5

你可以为这个类定义一个静态的构造函数，它将检查typesT是一个枚举，如果不是，则抛出一个exception。 这是Jeffery Richter在他的书CLR via C＃中提到的方法。

 internal sealed class GenericTypeThatRequiresAnEnum<T> { static GenericTypeThatRequiresAnEnum() { if (!typeof(T).IsEnum) { throw new ArgumentException("T must be an enumerated type"); } } } 

然后在parsing方法中，您可以使用Enum.Parse（typeof（T），input，true）将string转换为枚举。 最后一个真实的参数是忽略input的情况。

Answer 6

我通过dimarzionist修改了样本。 这个版本只能和Enums一起使用，不能让结构通过。

 public static T ParseEnum<T>(string enumString) where T : struct // enum { if (String.IsNullOrEmpty(enumString) || !typeof(T).IsEnum) throw new Exception("Type given must be an Enum"); try { return (T)Enum.Parse(typeof(T), enumString, true); } catch (Exception ex) { return default(T); } } 

Answer 7

我试着改进一下代码：

 public T LoadEnum<T>(string value, T defaultValue = default(T)) where T : struct, IComparable, IFormattable, IConvertible { if (Enum.IsDefined(typeof(T), value)) { return (T)Enum.Parse(typeof(T), value, true); } return defaultValue; } 

Answer 8

我有特定的要求，我需要使用与枚举值相关联的文本的枚举。 例如，当我使用枚举指定错误types时，需要描述错误的详细信息。

 public static class XmlEnumExtension { public static string ReadXmlEnumAttribute(this Enum value) { if (value == null) throw new ArgumentNullException("value"); var attribs = (XmlEnumAttribute[]) value.GetType().GetField(value.ToString()).GetCustomAttributes(typeof (XmlEnumAttribute), true); return attribs.Length > 0 ? attribs[0].Name : value.ToString(); } public static T ParseXmlEnumAttribute<T>(this string str) { foreach (T item in Enum.GetValues(typeof(T))) { var attribs = (XmlEnumAttribute[])item.GetType().GetField(item.ToString()).GetCustomAttributes(typeof(XmlEnumAttribute), true); if(attribs.Length > 0 && attribs[0].Name.Equals(str)) return item; } return (T)Enum.Parse(typeof(T), str, true); } } public enum MyEnum { [XmlEnum("First Value")] One, [XmlEnum("Second Value")] Two, Three } static void Main() { // Parsing from XmlEnum attribute var str = "Second Value"; var me = str.ParseXmlEnumAttribute<MyEnum>(); System.Console.WriteLine(me.ReadXmlEnumAttribute()); // Parsing without XmlEnum str = "Three"; me = str.ParseXmlEnumAttribute<MyEnum>(); System.Console.WriteLine(me.ReadXmlEnumAttribute()); me = MyEnum.One; System.Console.WriteLine(me.ReadXmlEnumAttribute()); } 

Answer 9

有趣的是，显然这在其他语言 （Managed C ++，IL直接）中是可能的 。

去引用：

…两个约束实际上都会生成有效的IL，如果使用其他语言编写（可以在托pipe的C ++或IL中声明这些约束），也可以由C＃使用。

谁知道

Answer 10

希望这是有帮助的：

 public static TValue ParseEnum<TValue>(string value, TValue defaultValue) where TValue : struct // enum { try { if (String.IsNullOrEmpty(value)) return defaultValue; return (TValue)Enum.Parse(typeof (TValue), value); } catch(Exception ex) { return defaultValue; } } 

Answer 11

这是我的看法。 从答案和MSDN结合

 public static TEnum ParseToEnum<TEnum>(this string text) where TEnum : struct, IConvertible, IComparable, IFormattable { if (string.IsNullOrEmpty(text) || !typeof(TEnum).IsEnum) throw new ArgumentException("TEnum must be an Enum type"); try { var enumValue = (TEnum)Enum.Parse(typeof(TEnum), text.Trim(), true); return enumValue; } catch (Exception) { throw new ArgumentException(string.Format("{0} is not a member of the {1} enumeration.", text, typeof(TEnum).Name)); } } 

MSDN源码

Answer 12

我总是喜欢这个（你可以适当的修改）：

 public static IEnumerable<TEnum> GetEnumValues() { Type enumType = typeof(TEnum); if(!enumType.IsEnum) throw new ArgumentException("Type argument must be Enum type"); Array enumValues = Enum.GetValues(enumType); return enumValues.Cast<TEnum>(); } 

Answer 13

我喜欢使用IL的克里斯托弗·库伦斯（Christopher Currens）的解决scheme，但是对于那些不想处理包括MSIL在内的微妙业务的人来说，我在C＃中写了类似的function。

请注意，虽然你不能像where T : Enum那样使用generics限制where T : Enum因为Enum是特殊types的。 所以我必须检查给定的generics是否真的是枚举。

我的function是：

 public static T GetEnumFromString<T>(string strValue, T defaultValue) { // Check if it realy enum at runtime if (!typeof(T).IsEnum) throw new ArgumentException("Method GetEnumFromString can be used with enums only"); if (!string.IsNullOrEmpty(strValue)) { IEnumerator enumerator = Enum.GetValues(typeof(T)).GetEnumerator(); while (enumerator.MoveNext()) { T temp = (T)enumerator.Current; if (temp.ToString().ToLower().Equals(strValue.Trim().ToLower())) return temp; } } return defaultValue; } 

Answer 14

我已经将Vivek的解决scheme封装到一个可重用的实用程序类中。 请注意，您仍然应该在types上定义types约束“where T：struct，IConvertible”。

 using System; internal static class EnumEnforcer { /// <summary> /// Makes sure that generic input parameter is of an enumerated type. /// </summary> /// <typeparam name="T">Type that should be checked.</typeparam> /// <param name="typeParameterName">Name of the type parameter.</param> /// <param name="methodName">Name of the method which accepted the parameter.</param> public static void EnforceIsEnum<T>(string typeParameterName, string methodName) where T : struct, IConvertible { if (!typeof(T).IsEnum) { string message = string.Format( "Generic parameter {0} in {1} method forces an enumerated type. Make sure your type parameter {0} is an enum.", typeParameterName, methodName); throw new ArgumentException(message); } } /// <summary> /// Makes sure that generic input parameter is of an enumerated type. /// </summary> /// <typeparam name="T">Type that should be checked.</typeparam> /// <param name="typeParameterName">Name of the type parameter.</param> /// <param name="methodName">Name of the method which accepted the parameter.</param> /// <param name="inputParameterName">Name of the input parameter of this page.</param> public static void EnforceIsEnum<T>(string typeParameterName, string methodName, string inputParameterName) where T : struct, IConvertible { if (!typeof(T).IsEnum) { string message = string.Format( "Generic parameter {0} in {1} method forces an enumerated type. Make sure your input parameter {2} is of correct type.", typeParameterName, methodName, inputParameterName); throw new ArgumentException(message); } } /// <summary> /// Makes sure that generic input parameter is of an enumerated type. /// </summary> /// <typeparam name="T">Type that should be checked.</typeparam> /// <param name="exceptionMessage">Message to show in case T is not an enum.</param> public static void EnforceIsEnum<T>(string exceptionMessage) where T : struct, IConvertible { if (!typeof(T).IsEnum) { throw new ArgumentException(exceptionMessage); } } } 

Answer 15

我创build了一个扩展方法to get integer value from enum看看方法的实现

 public static int ToInt<T>(this T soure) where T : IConvertible//enum { if (typeof(T).IsEnum) { return (int) (IConvertible)soure;// the tricky part } //else // throw new ArgumentException("T must be an enumerated type"); return soure.ToInt32(CultureInfo.CurrentCulture); } 

这是用法

 MemberStatusEnum.Activated.ToInt()// using extension Method (int) MemberStatusEnum.Activated //the ordinary way 

Answer 16

正如其他答案中所述; 虽然这不能用源代码来expression，但它实际上可以在IL Level上完成。 @Christopher Currens的答案显示了IL如何做到这一点。

用Fody的Add-In ExtraConstraints.Fody有一个非常简单的方法，用build-tooling来完成这个工作。 只要将他们的Nuget软件包（Fody， ExtraConstraints.Fody ）添加到您的项目中，并按如下所示添加约束（摘自ExtraConstraints的自述文件）：

 public void MethodWithEnumConstraint<[EnumConstraint] T>() {...} public void MethodWithTypeEnumConstraint<[EnumConstraint(typeof(ConsoleColor))] T>() {...} 

并且Fody将添加必要的IL来约束存在。 另请注意约束代表的附加function：

 public void MethodWithDelegateConstraint<[DelegateConstraint] T> () {...} public void MethodWithTypeDelegateConstraint<[DelegateConstraint(typeof(Func<int>))] T> () {...} 

关于枚举，你可能也想记下非常有趣的Enums.NET 。