创建通用方法约束T到一个枚举
我正在构建一个扩展Enum.Parse概念的函数
所以我写了以下内容：
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 。
公平的，但是有一个解决方法，以允许通用枚举，或者我将不得不模仿Parse函数，并将一个类型作为属性传递，这将迫使丑陋的拳击要求到您的代码。
编辑下面的所有建议都非常感谢，谢谢。
已经解决了（我离开了循环来保持大小写不敏感 - 我在解析XML时使用了这个）
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最近在MSIL或F＃中发布了一个编译器强制类型安全的通用解决方案，这非常值得一看，并且是upvote。 如果解决方案在页面上进一步起泡，我将删除此编辑。
由于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的值类型。 虽然这种可能性很少见。
我迟到了，但我把它看作是一个挑战，看看它是如何完成的。 在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引用，这意味着当您调试时，您必须将其保留在2个独立的程序集中。 您可以将它们添加为程序集的一部分的唯一方法是使用/addmodule:{files}命令行参数自己运行csc.exe。 在MSBuild脚本中这不会太痛苦。 当然，如果你勇敢或愚蠢，你可以每次手动运行csc。 由于多个程序集需要访问它，它肯定会变得更加复杂。
所以，它可以在.Net中完成。 这值得额外的努力吗？ 恩，好吧，我想我会让你决定那个。
F＃解决方案作为替代
额外的信用：事实证明，除了MSIL之外，至少还有一种.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支持的着名语言，因此它更容易维护，但您仍然需要在解决方案中使用单独的项目。 但是，它自然会产生相当不同的IL（代码非常不同），并且它依赖于FSharp.Core库，该库与任何其他外部库一样，都需要成为发行版的一部分。
以下是您如何使用它（基本上与MSIL解决方案相同），并显示它在其他同义词结构上正确失败：
// 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);
您可以通过滥用约束继承来让真正的编译器强制使用枚举约束。 下面的代码同时指定了一个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语言规范中有具体说明：
如果类型参数S依赖于类型参数T，那么：[...] S有值类型约束并且T具有引用类型约束是有效的。 实际上，这将T限制为System.Object，System.ValueType，System.Enum类型和任何接口类型。
链接地址: http://www.djcxy.com/p/3575.html