我正在构建一个函数来扩展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日)Julien Lebosquain最近在下面的MSIL或F#中发布了由编译器强制执行的类型安全的通用解决方案 ,这很值得一看,并值得一提。 如果解决方案在页面上冒泡,我将删除此编辑。

===============>>#1 票数:961 已采纳

由于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的值类型。 机会虽然很少。

===============>>#2 票数:599

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{}.assembly MyThing{}以下方式调用ilasm:

ilasm.exe /DLL /OUTPUT=MyThing.netmodule

您将得到一个netmodule而不是一个程序集。

不幸的是,VS2010(显然是更早的版本)不支持添加netmodule引用,这意味着在调试时必须将其保留在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);

===============>>#3 票数:196

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和任何接口类型。

===============>>#4 票数:30

编辑

Julien Lebosquain现在已经很好地回答了这个问题。 我还想在添加TryParseParseOrDefault同时,使用ignoreCasedefaultValue和可选参数扩展他的答案。

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

通过使用注释和“新”开发,我对Vivek答案的旧改进:

  • 使用TEnum为用户清晰
  • 添加更多接口约束以进行其他约束检查
  • TryParse使用现有参数处理ignoreCase (在VS2010 / .Net 4中引入)
  • (可选)使用通用default (在VS2005 / .Net 2中引入)
  • defaultValueignoreCase使用具有默认值的可选参数 (在VS2010 / .Net 4中引入)

导致:

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 票数:18

您可以为该类定义一个静态构造函数,该构造函数将检查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)从字符串转换为枚举。 最后一个true参数用于忽略输入的大小写。

===============>>#6 票数:15

还应该考虑到,由于开箱即用地支持使用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发行说明 感谢@MohamedElshawaf指出这个有效的问题。

请注意,就我而言,撰写本EDIT时的ReSharper 2018.1尚不支持C#7.3。 激活ReSharper后,它突出显示了Enum约束,因为它告诉我不能使用'System.Array','System.Delegate','System.Enum','System.ValueType','object'作为类型参数约束 ReSharper建议删除方法类型T的'Enum'约束作为快速解决方案

但是,如果您在“ 工具”->“选项”->“ ReSharper Ultimate”->“常规”下暂时关闭ReSharper,则使用VS 15.7或更高版本以及C#7.3或更高版本时,语法会非常完美。

===============>>#7 票数:11

我修改了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);
    }
}

===============>>#8 票数: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;
}

===============>>#9 票数:5

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

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

===============>>#10 票数:4

希望这会有所帮助:

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

===============>>#11 票数:3

足够有趣的是,显然这在其他语言 (直接由Managed C ++,IL)中也是可能的

报价:

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

谁知道

===============>>#12 票数:3

这是我的看法。 从答案和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来源

===============>>#13 票数:3

从C#<= 7.2开始,现有答案是正确的。 但是,存在一个C#语言功能请求 (与corefx功能请求绑定)以允许以下操作:

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

在撰写本文时,该功能在语言开发会议上处于“讨论中”状态。

编辑

根据nawfal的信息,这在C# 7.3中进行了介绍。

===============>>#14 票数:1

我喜欢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;
}

===============>>#15 票数:1

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

===============>>#16 票数:1

我一直很喜欢这样(您可以根据需要进行修改):

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

===============>>#17 票数:1

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

===============>>#18 票数:1

如之前其他答案中所述; 尽管这不能用源代码表示,但实际上可以在IL级别完成。 @Christopher Currens的答案显示了IL如何做到这一点。

使用Fody的Add-In ExtraConstraints.Fody ,可以通过一种非常简单的方法以及构建工具来实现此目的。 只是他们的NuGet包(加FodyExtraConstraints.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,您可能还需要注意非常有趣的Enums.NET

===============>>#19 票数:1

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

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

===============>>#20 票数:0

如果以后可以使用直接强制转换,我想您可以在必要时在您的方法中使用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);

===============>>#21 票数:-6

仅出于完整性考虑,以下是Java解决方案。 我相信同样可以在C#中完成。 它避免了必须在代码中的任何地方指定类型-而是在要解析的字符串中指定它。

问题是没有任何方法可以知道String可能匹配哪个枚举-因此答案就是要解决该问题。

不仅接受字符串值,还接受同时具有枚举和“ 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;
    }


}

  ask by johnc translate from so

未解决问题?本站智能推荐:

2回复

是否可以在C#泛型方法中定义“not Nullable ”约束?

在C#中, Nullable<T>类型不满足where struct泛型约束(而AFAK这在技术上是一个结构)。 这可用于指定泛型参数必须是不可为空的值类型: 当然, Nullable<T>也不满足引用类型where class约束: 这是否可以定义约束
2回复

如何通过C#中的反射提取泛型方法约束?

给定System.Reflection.MethodInfo类型的对象如何提取泛型参数约束? 不知怎的,我找不到有关此的合理信息。
3回复

如何限制泛型方法的嵌套泛型类型

我正在尝试创建一种基于给定泛型从数据库返回数据的方法。 接口:(此定义编译) 一个可能的具体实现:(此定义编译) 尝试基于接口编写通用方法:(此定义不编译) 错误: 要这样使用: 题: 为什么要为接口而不是方法进行编译? 我希望两者都能
2回复

构造/创建泛型类型并将类型约束转换为struct-as-base-type约束

通常,我们不能将类型参数T约束为从密封类型(例如struct类型)派生。 这将毫无意义,因为只有一种类型可以适合,因此不需要泛型。 所以约束如下: 要么: 这是非法的,这是有充分理由的。 但是,当约束到另一个类型参数时,有时会在其他类型参数被“替换”为实际类型(恰好被密
3回复

指定类本身的泛型类的基类约束

昨天,我向朋友们解释了C#的通用限制。 在演示where T : CLASSNAME约束的地方时,我掀起了这样的事情: 并且看到它编译真的很惊讶。 然而,经过一番思考后,我认为从编译器的角度来看它是完全合法的 - UnusableClass<T>与其他任何可以在此约束中使
4回复

针对通用接口还是作为通用约束创建扩展方法?

我不确定这两个签名是否有任何实际区别: 我认为这些功能实际上几乎相同,但是我不太确定...我在这里俯瞰什么?
4回复

如何使用没有约束的类型参数调用具有泛型约束的方法?

假设我有一个方法: 我想用它如下: 因此,在运行期间我知道S满足ExampleMethod<T>的约束。 我知道可以使用反射调用它,类似于: 没有反思可能吗? 注意:这是来自现实生活示例的简化代码,显然我无法控制这些方法的签名,因此答案“将约束添加到C
1回复

实例化类型约束的泛型类,而不对其进行子类化

背景 [如果您对背景不感兴趣,请跳至问题 ] 我在前几天阅读时偶然发现了这个通用的类定义,它让我困扰了一段时间: 我很困惑T on Entity<T>如何成为Type Entity<T>本身。 这似乎是一种奇怪的递归约束。 然后我意识到这个约束
7回复

C#中是否有带有参数约束的泛型构造函数?

在C#中,您可以对通用方法施加约束,例如: 您在其中指定T应该具有不需要任何参数的构造函数。 我想知道是否有一种方法可以添加约束,例如“ 存在带有float[,]参数的构造函数? ” 以下代码无法编译: 解决方法也有用吗?
1回复

C#泛型和通用约束

我正在编写一个带有类型参数T的通用抽象类A,我打算用类B派生它。 A有一个数据成员mX,一个C类实例,带有泛型函数。 这个泛型函数GetAllOfType()有一个类型参数T.这个类型参数被约束到第三个类,D。GetAllOfType()搜索D的实例容器,包括D的派生类的实例,并返回类型