创建将 T 限制为枚举的通用方法

Posted

技术标签:

【中文标题】创建将 T 限制为枚举的通用方法【英文标题】：Create Generic method constraining T to an Enum 【发布时间】：2010-09-09 21:32:30 【问题描述】：

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

在未找到 Enum 值的情况下允许解析默认值 不区分大小写

所以我写了以下内容：

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 日）Christopher Currens 在下面发布了a compiler enforced type-safe generic solution in MSIL or F#，非常值得一看，并点赞。如果解决方案在页面上进一步冒泡，我将删除此编辑。

编辑 2：（2021 年 4 月 13 日）由于这个问题现在已经得到解决和支持，自 C# 7.3 以来，我已经更改了接受的答案，尽管完全阅读最重要的答案是值得的学术和历史兴趣:)

【问题讨论】：

也许你是should use ToUpperInvariant() 而不是 ToLower()... @Shimmy：一旦您将值类型传递给扩展方法，您就在处理它的副本，因此您无法更改其状态。 知道这是一个旧线程，不知道他们是否改变了一些东西，但扩展方法对值类型工作正常，确保它们可能并不总是那么有意义，但我使用了“公共静态TimeSpan Seconds(this int x) return TimeSpan.FromSeconds(x); " 启用“Wait.For(5.Seconds())...”的语法 意识到这不是问题的一部分，但您可以通过使用 String.Equals 和 StringComparison.InvariantCultureIgnoreCase 来改进您的 foreach 循环逻辑 Anyone know a good workaround for the lack of an enum generic constraint?的可能重复 【参考方案1】：

既然Enum类型实现了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 的值类型。不过机会很少。

【讨论】：

好吧，如果你选择沿着这条路走下去，那就让它更加受限制......使用“class TestClass where T : struct, IComparable, IFormattable, IConvertible” 另一个建议是使用标识符 TEnum 定义泛型类型。因此： public TEnum GetEnumFromString(string value) where TEnum : struct, IConvertible, IComparible, IFormattable 包含其他接口并不会带来太多好处，因为几乎所有内置值类型都实现了所有这些接口。对于通用扩展方法的约束尤其如此，这对于操作枚举非常方便，除了这些扩展方法就像感染所有对象的病毒。 IConvertable 至少缩小了很多。 非常老的话题，但自 C# 7.3 以来有了巨大的改进。现在完全支持使用 Enum 约束。在底部一直看到我更长的答案。 从 C# 7.3 开始支持此功能【参考方案2】：

C# 7.3 终于支持这个功能了！

以下 sn-p（来自 the dotnet samples）演示了如何：

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

你得到一个网络模块而不是一个程序集。

不幸的是，VS2010（以及更早的版本，显然）不支持添加网络模块引用，这意味着您在调试时必须将其保留在 2 个单独的程序集中。将它们作为程序集的一部分添加的唯一方法是使用/addmodule:files 命令行参数自己运行 csc.exe。在 MSBuild 脚本中不会太痛苦。当然，如果你是勇敢或愚蠢的，你可以每次手动运行 csc 。而且它肯定会变得更加复杂，因为多个程序集需要访问它。

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

F# 解决方案作为替代方案

额外功劳：事实证明，除了 MSIL：F# 之外，至少还有一种其他 .NET 语言可以对 enum 进行通用限制。

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

【讨论】：

是的，非常铁杆。我非常尊重能够在 IL 中编写代码的人，并且知道如何在更高的语言级别支持这些功能 - 我们中的许多人仍然认为这个级别在应用程序、业务规则下是低级别的、UI、组件库等 我真正想知道的是为什么 C# 团队还没有开始允许这样做，因为它已经得到 MSIL 的支持。 @MgSam - 来自Eric Lippert: There's no particularly unusual reason why not; we have lots of other things to do, limited budgets, and this one has never made it past the "wouldn't this be nice?" discussion in the language design team. @LordofScripts：我认为原因是因为将T 限制为System.Enum 的类将无法使用T 完成人们可能期望的所有事情， C# 的作者认为他们不妨完全禁止它。我认为这个决定很不幸，因为它 C# 只是忽略了对 System.Enum 约束的任何特殊处理，因此可以编写一个比 Enum.HasFlag(Enum) 快几个数量级的 HasAnyFlags&lt;T&gt;(this T it, T other) 扩展方法，并对其进行类型检查论据。 @MichaelBlackburn 这比听起来更复杂，主要是由于枚举上的位标志。一位名叫 HaloFour 的 github 用户在this Roslyn issue 中给出了很好的总结。【参考方案3】：

C#≥7.3

从 C# 7.3（Visual Studio 2017 ≥ 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 和任何接口类型。

【讨论】：

@DavidI.McIntosh EnumClassUtils&lt;System.Enum&gt; 足以将 T 限制为任何 System.Enum 和任何派生类型。 struct on Parse 然后将其进一步限制为真正的枚举类型。您需要在某些时候限制为Enum。为此，您的类必须是嵌套的。见gist.github.com/MrJul/7da12f5f2d6c69f03d79 为了清楚起见，我的评论“不愉快”并不是对您的解决方案的评论 - 它确实是一个漂亮的 hack。只是“不愉快”，MS 强迫我们使用如此复杂的 hack。 有没有办法让它也可用于扩展方法？ where TClass : class 约束在这里获得了什么？ 有没有办法进一步限制TEnum，从而允许int v; TEnum e = (TEnum) v;？【参考方案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);

旧

我通过使用 cmets 和“新”开发对 Vivek's answer 的旧改进：

使用TEnum 让用户更清楚 为额外的约束检查添加更多接口约束 让TryParse 用现有参数处理ignoreCase （在VS2010/.Net 4中引入） 可选择使用通用default value（在VS2005/.Net 2 中引入） 使用optional arguments（在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;

【讨论】：

【参考方案5】：

从 C# feature request（与 corefx 功能请求相关联）允许以下操作；

public class MyGeneric<TEnum> where TEnum : System.Enum

在撰写本文时，该功能在语言发展会议上处于“讨论中”。

编辑

根据nawfal 的信息，这是在C# 7.3 中引入的。

编辑 2

现在在 C# 7.3 中 (release notes)

样品；

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;

【讨论】：

这里的讨论很有趣，谢谢。不过（到目前为止）还没有什么是一成不变的 @johnc，非常正确但值得一提，它是一个经常被问到的功能。它进来的几率是公平的。 这是在 C# 7.3 中出现的：docs.microsoft.com/en-us/visualstudio/releasenotes/…。 :) 请支持这个答案，它应该在列表中高得多，现在该功能已经存在！ :)【参考方案6】：

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

那么在 parse 方法中，你可以只使用 Enum.Parse(typeof(T), input, true) 将字符串转换为枚举。最后一个 true 参数用于忽略输入的大小写。

【讨论】：

这对于泛型类来说是一个不错的选择——当然，它对泛型方法没有帮助。 另外，这在编译时也没有强制执行，你只会知道你在构造函数执行时提供了一个非EnumT。虽然这比等待实例构造函数要好得多。【参考方案7】：

还应该考虑的是，由于使用 Enum 约束的 C# 7.3 版本支持开箱即用，无需进行额外的检查和其他工作。

因此，鉴于您已将项目的语言版本更改为 C# 7.3，以下代码将可以正常工作：

    private static T GetEnumFromString<T>(string value, T defaultValue) where T : Enum
    
        // Your code goes here...

如果您不知道如何将语言版本更改为 C# 7.3，请参阅以下屏幕截图：

编辑 1 - 所需的 Visual Studio 版本并考虑使用 ReSharper

要让 Visual Studio 识别新语法，您至少需要 15.7 版本。您可以在 Microsoft 的发行说明中找到同样提到的内容，请参阅 Visual Studio 2017 15.7 Release Notes。感谢@MohamedElshawaf 指出这个有效的问题。

还请注意，在我的情况下，ReSharper 2018.1 在编写此 EDIT 时还不支持 C# 7.3。激活 ReSharper 后，它会将 Enum 约束突出显示为一个错误，告诉我 Cannot use 'System.Array', 'System.Delegate', 'System.Enum', 'System.ValueType', 'object' as type parameter constraint。 ReSharper 建议作为快速修复删除方法类型参数 T 的“枚举”约束

但是，如果您在 Tools -> Options -> ReSharper Ultimate -> General 下暂时关闭 ReSharper，您会发现语法非常好，因为您使用的是 VS 15.7 或更高版本以及 C# 7.3 或更高。

【讨论】：

你用的是什么VS版本？ @MohamedElshawaf 我相信它的 15.7 版本包含对 C# 7.3 的支持 我认为最好写where T : struct, Enum，以避免将System.Enum本身作为类型参数传递。 就像@MariuszPawelski 我写struct, Enum。我的理由在答案和 cmets here 中进行了解释。 ReSharper 信息对我很有帮助。注意最新预览版支持此功能。【参考方案8】：

我通过 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);

【讨论】：

失败时我不会返回默认值；我会让异常传播（就像使用 Enum.Parse 一样）。相反，使用 TryParse 返回布尔值并使用输出参数返回结果。 OP 希望它不区分大小写，这不是。【参考方案9】：

我试着改进一下代码：

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;

【讨论】：

这比公认的答案更好，因为它允许您调用defaultValue.ToString("D", System.Globalization.NumberFormatInfo.CurrentInfo)，即使您不知道它是哪种类型的枚举，只是对象是枚举。 使用IsDefined 的预先检查将破坏不区分大小写。与Parse 不同，IsDefined 没有ignoreCase 参数，and MSDN says it only matches exact case。【参考方案10】：

我确实有特定的要求，我需要将枚举与与枚举值关联的文本一起使用。例如，当我使用枚举指定错误类型时，它需要描述错误详细信息。

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

【讨论】：

【参考方案11】：

希望这有帮助：

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;

【讨论】：

如果您需要不区分大小写，只需将return (TValue)Enum.Parse(typeof (TValue), value); 替换为return (TValue)Enum.Parse(typeof (TValue), value, true);【参考方案12】：

有趣的是，显然这是possible in other langauges（直接托管C++，IL）。

引用：

...这两个约束实际上都会产生有效的 IL，如果用另一种语言编写，也可以由 C# 使用（您可以在托管 C++ 或 IL 中声明这些约束）。

谁知道

【讨论】：

C++ 托管扩展对泛型没有任何支持，我认为您的意思是 C++/CLI。【参考方案13】：

这是我的看法。结合来自答案和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 Source

【讨论】：

这真的没有意义。如果 TEnum 实际上是一个 Enum 类型，但 text 是一个空字符串，那么你会得到一个 ArgumentException 说“TEnum 必须是一个 Enum 类型”，即使它是。【参考方案14】：

请注意 System.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 更可取

【讨论】：

【参考方案15】：

我一直很喜欢这个（你可以酌情修改）：

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

【讨论】：

【参考方案16】：

我喜欢 Christopher Currens 使用 IL 的解决方案，但对于那些不想处理将 MSIL 纳入其构建过程的棘手业务的人，我用 C# 编写了类似的函数。

请注意，您不能使用像 where T : Enum 这样的通用限制，因为 Enum 是特殊类型。因此我必须检查给定的泛型类型是否真的是枚举。

我的功能是：

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;

【讨论】：

【参考方案17】：

我已将 Vivek 的解决方案封装到一个实用程序类中，您可以重复使用它。请注意，您仍然应该在您的类型上定义类型约束“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);

【讨论】：

【参考方案18】：

我创建了一个扩展方法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

【讨论】：

虽然它可能有效，但它几乎与问题无关。【参考方案19】：

如之前其他答案所述；虽然这不能在源代码中表达，但实际上可以在 IL 级别完成。 @Christopher Currens answer 展示了 IL 如何做到这一点。

使用Fodys 插件ExtraConstraints.Fody 有一个非常简单的方法，加上构建工具，可以实现这一目标。只需将他们的 nuget 包（Fody、ExtraConstraints.Fody）添加到您的项目中，并添加如下约束（摘自 ExtraConstraints 自述文件）：

public void MethodWithEnumConstraint<[EnumConstraint] T>() ...

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

并且 Fody 将添加必要的 IL 以使约束存在。 还要注意约束代表的附加功能：

public void MethodWithDelegateConstraint<[DelegateConstraint] T> ()
...

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

关于枚举，您可能还想注意非常有趣的Enums.NET。

【讨论】：

【参考方案20】：

这是我的实现。基本上，您可以设置任何属性并且它可以工作。 

public static class EnumExtensions
    
        public static string GetDescription(this Enum @enum)
        
            Type type = @enum.GetType();
            FieldInfo fi = type.GetField(@enum.ToString());
            DescriptionAttribute[] attrs =
                fi.GetCustomAttributes(typeof(DescriptionAttribute), false) as DescriptionAttribute[];
            if (attrs.Length > 0)
            
                return attrs[0].Description;
            
            return null;

【讨论】：

【参考方案21】：

如果之后可以使用直接强制转换，我想你可以在你的方法中使用System.Enum 基类，只要有必要。您只需要仔细替换类型参数即可。所以方法实现应该是这样的：

public static class EnumUtils

    public static Enum GetEnumFromString(string value, Enum defaultValue)
    
        if (string.IsNullOrEmpty(value)) return defaultValue;
        foreach (Enum item in Enum.GetValues(defaultValue.GetType()))
        
            if (item.ToString().ToLower().Equals(value.Trim().ToLower())) return item;
        
        return defaultValue;

然后你可以像这样使用它：

var parsedOutput = (YourEnum)EnumUtils.GetEnumFromString(someString, YourEnum.DefaultValue);

【讨论】：

使用Enum.ToObject() 会产生更灵活的结果。除此之外，您可以在不区分大小写的情况下进行字符串比较，这将不需要调用ToLower()【参考方案22】：

为了完整起见，以下是 Java 解决方案。我确信同样可以在 C# 中完成。它避免了必须在代码中的任何地方指定类型 - 相反，您可以在尝试解析的字符串中指定它。

问题是没有办法知道字符串可能匹配哪个枚举 - 所以答案就是解决这个问题。

不要只接受字符串值，而是接受一个既有枚举又有“enumeration.value”形式的值的字符串。工作代码如下 - 需要 Java 1.8 或更高版本。这也会使 XML 更加精确，因为您会看到类似 color="Color.red" 而不仅仅是 color="red" 的内容。

您可以使用包含枚举名称点值名称的字符串调用 acceptEnumeratedValue() 方法。

该方法返回正式的枚举值。

import java.util.HashMap;
import java.util.Map;
import java.util.function.Function;


public class EnumFromString 

    enum NumberEnum One, Two, Three;
    enum LetterEnum A, B, C;


    Map<String, Function<String, ? extends Enum>> enumsByName = new HashMap<>();

    public static void main(String[] args) 
        EnumFromString efs = new EnumFromString();

        System.out.print("\nFirst string is NumberEnum.Two - enum is " + efs.acceptEnumeratedValue("NumberEnum.Two").name());
        System.out.print("\nSecond string is LetterEnum.B - enum is " + efs.acceptEnumeratedValue("LetterEnum.B").name());

    

    public EnumFromString() 
        enumsByName.put("NumberEnum", s -> return NumberEnum.valueOf(s););
        enumsByName.put("LetterEnum", s -> return LetterEnum.valueOf(s););
    

    public Enum acceptEnumeratedValue(String enumDotValue) 

        int pos = enumDotValue.indexOf(".");

        String enumName = enumDotValue.substring(0, pos);
        String value = enumDotValue.substring(pos + 1);

        Enum enumeratedValue = enumsByName.get(enumName).apply(value);

        return enumeratedValue;

【讨论】：

以上是关于创建将 T 限制为枚举的通用方法的主要内容，如果未能解决你的问题，请参考以下文章

将枚举值作为参数的通用 C# 方法[重复]

无法在通用方法中将整数转换为枚举 [重复]

在 C# 中将 Int 转换为通用枚举

为 toArray 方法创建通用数组

通用方法，其中T是type1或type2

任何人都知道缺少枚举通用约束的好方法吗？