注意系统。Enum Parse()和TryParse()方法仍然有where struct约束，而不是where Enum，因此不会编译:

    bool IsValid<TE>(string attempted) where TE : Enum
    {
        return Enum.TryParse(attempted, out TE _);
    }

但这将:

bool Ok<TE>(string attempted) where TE : struct,Enum
{
    return Enum.TryParse(attempted, out var _)
}

因此，where struct,Enum可能比where Enum更可取

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引用，这意味着在调试时必须把它放在两个独立的程序集中。将它们作为程序集的一部分添加的唯一方法是自己使用/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。核心库，就像任何其他外部库一样，它需要成为发行版的一部分。

下面是如何使用它(基本上与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);

希望这对你有帮助:

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;
      }
}

我用二元酸对样品进行了修改。这个版本只适用于枚举，不允许结构体通过。

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);
    }
}

有趣的是，显然这在其他语言中是可能的(Managed c++， IL直接)。

引用:

．.． 这两个约束实际上都产生了有效的IL，如果用其他语言编写，也可以被c#使用(您可以在托管c++或IL中声明这些约束)。

谁知道

您可以为该类定义一个静态构造函数，该构造函数将检查类型T是否是enum，如果不是则抛出异常。这是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");
        }
    }
}

然后在解析方法中，你可以使用enumel . parse (typeof(T)， input, true)将字符串转换为enum。最后一个true参数用于忽略输入的大小写。