我正在构建一个扩展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 。

很公平，但是有一个解决方法允许 Generic 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＃7.3 最终支持此功能！

以下代码段（来自dotnet 示例 ）演示了它的用法：

public static Dictionary<int, string> EnumNamedValues<T>() where T : System.Enum
{
    var result = new Dictionary<int, string>();
    var values = Enum.GetValues(typeof(T));

    foreach (int item in values)
        result.Add(item, Enum.GetName(typeof(T), item));
    return result;
}

请务必在 C＃项目中将语言版本设置为 7.3 版。

原始答案如下：

我已经迟到了，但我把它视为一个挑战，看看它是如何完成的。它不可能在 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}命令行参数/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);

C＃≥7.3

从 C＃7.3 开始（Visual Studio2017≥v15.7 提供），此代码现在完全有效：

public static TEnum Parse<TEnum>(string value)
where TEnum : struct, Enum { ... }

C＃≤7.2

您可以通过滥用约束继承来获得真正的编译器强制枚举约束。以下代码同时指定了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 和任何接口类型。