题 创建将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;
}

我得到一个Error Constraint不能是特殊类 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。如果解决方案在页面上向上冒泡,我将删除此编辑。


950
2017-09-17 01:56


起源


可能是你 应该用 ToUpperInvariant()而不是ToLower()...... - Max Galkin
@Shimmy:只要将值类型传递给扩展方法,就会处理它的副本,因此无法更改其状态。 - Garo Yeriazarian
知道它是一个旧线程,不知道它们是否改变了东西,但是扩展方法对于值类型工作正常,确定它们可能并不总是那么有意义,但我使用了“public static TimeSpan Seconds(this int x){ return TimeSpan.FromSeconds(x);}“启用”Wait.For(5.Seconds())...“的语法 - Jens
意识到这不是问题的一部分,但你可以通过使用带StringComparison.InvariantCultureIgnoreCase的String.Equals来改进你的foreach循环逻辑 - Firestrand
为何使用它 foreach-循环? Enum.Parse 包含一个 ignoreCase - 参数(我想是的 .Net 2.0)。 - Yahoo Serious


答案:


以来 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。但机会很少。


856
2017-09-17 04:13



从.NET 2.0开始,泛型可用。因此它们也可以在vb 2005中使用。 - Vivek
那么,如果你选择沿着这条路走下去,那就让它更加受约束...使用“类TestClass <T>其中T:struct,IComparable,IFormattable,IConvertible” - Ricardo Nolde
如果我们可以编写自定义约束,那就太棒了。用谓词或其他东西。 - Phil Gan
另一个建议是使用标识符TEnum定义泛型类型。因此:public TEnum GetEnumFromString <TEnum>(字符串值)其中TEnum:struct,IConvertible,IComparible,IFormattable {} - Lisa
通过包含其他接口不会获得太多收益,因为几乎所有内置值类型都实现了所有这些接口。对于通用扩展方法的约束尤其如此,这对于在枚举上操作非常方便,除了这些扩展方法就像感染所有对象的病毒一样。 IConvertable至少可以缩小它的范围。 - russbishop


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个独立的程序集中。将它们作为程序集的一部分添加的唯一方法是使用自己运行csc.exe /addmodule:{files} 命令行参数。它不会  在MSBuild脚本中很痛苦。当然,如果你是勇敢或愚蠢的,你可以每次手动运行csc。当多个程序集需要访问它时,它肯定会变得更加复杂。

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


F#解决方案作为替代

额外信用:事实证明,通用限制 enum 除了MSIL之外,至少有一种其他.NET语言是可能的: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);

420
2017-11-10 21:46



是的,非常铁杆。我非常尊重可以在IL中编码的人, 和 知道如何在更高的语言级别支持这些功能 - 我们许多人仍然认为这些级别在应用程序,业务规则,UI,组件库等下都处于低级别。 - TonyG
我真正想知道的是,为什么C#团队还没有开始允许这个,因为MSIL已经支持它了。 - MgSam
@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. - Christopher Currens
@LordofScripts:我认为原因在于,因为一个类限制了一个 T 至 System.Enum 将无法完成所有的事情 T 人们可能会想到,C#的作者认为他们可能完全禁止它。我认为这个决定很不幸,因为C#完全忽略了任何特殊处理 System.Enum 约束,本来可以写一个 HasAnyFlags<T>(this T it, T other) 扩展方法比数量级快几个数量级 Enum.HasFlag(Enum) 并且对其参数进行了类型检查。 - supercat
我不认为我曾经有过一个我没有在这里结束的项目。 C#6是110%的语法糖,而且没有进入?切废话。 - Michael Blackburn


C#≥7.3

从C#7.3开始(Visual Studio2017≥v15.7提供),此代码现在完全有效:

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

C#≤7.2

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


150
2018-02-15 15:16



@ DavidI.McIntosh EnumClassUtils<System.Enum> 足以将T限制为任何 System.Enum 和任何派生类型。 struct 上 Parse 然后将其进一步限制为真实的枚举类型。你需要限制 Enum 在某一点。为此,您的类必须嵌套。看到 gist.github.com/MrJul/7da12f5f2d6c69f03d79 - Julien Lebosquain
为了清楚起见,我的评论“不愉快”并不是对你的解决方案的评论 - 它真的是一个美丽的黑客。只是“不愉快”,MS迫使我们使用这样一个令人费解的黑客。 - David I. McIntosh
有没有办法将其用于扩展方法? - Mord Zuber
我会添加一个内部构造函数,以防止以奇怪的方式继承此类。 - John Gietzen
什么是 where TClass : class 约束增益在这里? - tsemer


编辑

现在这个问题得到了极好的回答 Julien Lebosquain。 我还想扩大他的答案 ignoreCasedefaultValue 和可选参数,同时添加 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);

我的旧改进 维维克的回答 通过使用评论和“新”发展:

  • 使用 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;
    }
}

29
2018-05-24 14:07





您可以为类定义静态构造函数,该构造函数将检查类型T是否为枚举,如果不是则抛出异常。这是Jeffery Richter在他的书CLR中通过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)将字符串转换为枚举。最后一个真实参数用于忽略输入的大小写。


18
2017-09-17 02:32



这是泛型类的一个很好的选择 - 当然,它对泛型方法没有帮助。 - McGarnagle


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

11
2017-09-17 02:24



我不会在失败时返回默认值;我会让异常传播(就像Enum.Parse一样)。相反,使用TryParse返回一个bool并使用out参数返回结果。 - Mark Simpson
OP希望它不区分大小写,但事实并非如此。 - Konrad Morawski
这是不区分大小写的,这就是最后的“真实”...... - increddibelly


我试着改进一下代码:

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

9
2017-12-16 11:24



这比接受的答案要好,因为它允许你打电话 defaultValue.ToString("D", System.Globalization.NumberFormatInfo.CurrentInfo) 即使你不知道它是哪种类型的枚举,只是该对象是枚举。 - styfle
提前检查 IsDefined 但是,会破坏案件的不敏感性。不像 Parse, IsDefined 没有 ignoreCase 论据, 和MSDN说它只匹配确切的情况。 - Nyerguds


还应该考虑到,因为使用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,请参阅以下屏幕截图: enter image description here

编辑1 - 必需的Visual Studio版本并考虑ReSharper

要使Visual Studio能够识别至少需要15.7版本的新语法。您可以在Microsoft的发行说明中找到,也可以参阅 Visual Studio 2017 15.7发行说明。感谢@MohamedElshawaf指出这个有效的问题。

请注意,在我的案例中,ReSharper 2018.1在编写此EDIT时尚不支持C#7.3。激活ReSharper会突出显示Enum约束,这是一个错误告诉我 不能使用'System.Array','System.Delegate','System.Enum','System.ValueType','object'作为类型参数约束。 ReSharper建议快速修复 删除方法类型参数T的'枚举'约束 

但是,如果你暂时关闭ReSharper 工具 - >选项 - > ReSharper Ultimate - >常规 你会发现使用VS 15.7或更高版本以及C#7.3或更高版本时语法完全正确。


6
2018-05-10 09:55



您使用的VS版本是什么? - mshwf
这应该是现在接受的答案 - Patrick Roberts
@MohamedElshawaf我相信它的版本15.7包含对C#7.3的支持 - Patrick Roberts
我觉得写作更好 where T : struct, Enum,以避免过世 System.Enum 本身作为类型参数。 - Mariusz Pawelski
就像@MariuszPawelski一样,我写道 struct, Enum。我的理由在答案和评论中得到了解释 这里。 - Stephen Kennedy