创建一般法的约束T Enum

https://stackoverflow.com/questions/79126

09-06-2019
|

题

我要建一个功能延长 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.

不够公平，但是有一个解决办法以允许一般枚举的，还是我要去模仿 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;
    }
}

编辑： (16日2015年)朱利安Lebosquain最近发布一个编译器类型的强制执行安全的通用解决方案在集或F# 下面，这是非常值得一看，一个投票.我会除去这个编辑如果溶液泡沫进一步的页。

解决方案

由于 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.机会是罕见的。

其他提示

这个功能是支持最后在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#)，但是 是的可能 在集.我写了这点...事情

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

不幸的是，这意味着有这部分你的代码写在集，而不是C#，唯一的好处是，你能够限制这种方法通过 System.Enum.它也是一种令人失望，因为它被汇编成一个单独的组件。然而，这并不意味着你必须要部署这种方式。

通过删除线 .assembly MyThing{} 并援引ilasm如下：

ilasm.exe /DLL /OUTPUT=MyThing.netmodule

你会得到一个netmodule而不是大会。

不幸的是，VS2010(和早些时候，显然)不支持增加netmodule参考文献，这意味着你必须离开它在2个独立的集会时你在调试。只有这样，你可以增加他们的一部分，你会跑csc.exe 自己使用 /addmodule:{files} 命令行参数。它不会太痛苦在MSBuild脚本。当然，如果你是勇敢的还是愚蠢，你可以跑csc自己手动每时间。它当然变得更加复杂，因为多个组件的需要对其进行访问。

因此，这是可以做到的。网。它是值得额外的努力？嗯，嗯，我想我会让你决定那一个。

F#解决方案如替代

额外的信贷：事实证明，一般限制 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 库，其中，就像任何其他外部图书馆，需要成为一部分的分布。

这里就是你如何可以使用(基本上相同的集方案)，以及显示，它正确地失败的代名词，否则结构:

// 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类型的系统。目的，系统。ValueType、系统。枚举，以及任何接口的类型。

编辑

这个问题现在已经寄望已经回答了朱利安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);

旧

我的老上的改进 Vivek的答案通过采用的评论意见和新的事态发展：

使用 TEnum 为了清楚起见，对用户
增加更多的接口，限制附加限制条件的检查
让 TryParse 手柄 ignoreCase 与现有参数 (介绍了在VS2010/.净4)
有选择地使用通用的 default 值 (介绍了在VS2005/.净2)
使用可选择参数(介绍了在VS2010/.净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;
    }
}

你可以静态定义的构造对该类检查T型是一个枚举，并把一个异常，如果它不是。这是该法提到由杰弗里*里克特在他的书CLR通过。

internal sealed class GenericTypeThatRequiresAnEnum<T> {
    static GenericTypeThatRequiresAnEnum() {
        if (!typeof(T).IsEnum) {
        throw new ArgumentException("T must be an enumerated type");
        }
    }
}

然后在分析方法，可以仅使用枚举。分析(类型(T),input,true)转换从串的枚举。最后一个真正的参数是用于忽略的情况下输入的。

它也应当考虑的是，由于释放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 Studio2017年的15.7释放笔记.谢谢@MohamedElshawaf指出了这一有效的问题。

Pls还注意到，在我的情况ReSharper2018.1作为编写该编辑还不支持C#7.3.具有ReSharper激活它强调枚举的约束，因为一个错误，告诉我 不能使用的系统。阵列','系统。Delegate','系统。Enum','系统。ValueType','object'类型参数的约束.ReSharper建议作为一个快速的修复 删除'Enum'制约的类型放慢参数T的方法

然而，如果关闭ReSharper暂时下 工具->的选择->ReSharper最终->一般 你会看到的语法是完全没有给使用VS15.7或更高和C#7.3或更高。

我修改的样本通过dimarzionist.这个版本将仅用枚举，而不是放结构得到通过。

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

我试图提高码有点：

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

我有具体要求，在那里我需要来使用枚举的文本相关联枚举的价值。例如，当我使用enum指定的错误类型它需要描述错误的详细信息。

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

希望这是有帮助：

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

有趣的是，显然这是可能在其他语言 (管理C++、IL直接).

引用:

...这两种制约实际上产生效IL也可以通过消耗C#如果另一种语言编写的(你可以宣布这些限制在管理C++或在IL)。

谁知道

这是我需要它。合并从答复和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源

现有的答案都是真实的C# <=7.2.然而，有一个C#语言功能要求 (绑到一个 corefx 功能要求)，以允许以下；

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

在编写本报告时，特点是"讨论"在语言发展会议。

编辑

为每脑法力's的信息，这是在被引入C# 7.3.

我总是很喜欢这个(你可以修改如适当的话):

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

我喜欢克里斯托弗*Currens的溶液使用IL但对于那些不想处理棘手的业务，包括集到它们的生成过程中，我写了类似的功能。

请注意，虽然你不能使用一般限制像 where T : 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;
}

我已经封Vivek的解决方案进入一个实用程序类，你可以重复使用。请注意，还应该定义类型的限制"T:结构，请参"在你的类型。

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

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

正如在其他的答案之前；虽然这不能被表达的源代码，它实际上可以做IL水平。@克里斯托弗*Currens 答案演示如何IL做到这一点。

与福迪鸟s加 ExtraConstraints.福迪鸟有一个非常简单的方法，完成与建设工具，来实现这一点。只是增加他们的nuget包(Fody, ExtraConstraints.Fody)到项目和添加的限制如下(摘录自述的ExtraConstraints):

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

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

而福迪鸟将增加必要的IL约束。还注意到，额外的要素的制约的代表们:

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

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

关于枚举，可能还需要注意的非常有趣 Enums.NET.

如果它的确定直接使用铸件之后，我猜你可以使用 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);

只是为了完整起见，下面是Java的解决方案。我肯定同样可以做C#如此。它避免具有类型指定的任何地方的代码来代替，可以指定在弦，你们试图分析。

问题是，没有任何办法知道这枚举的串可能的匹配所以答案是解决这一问题。

而不是接受仅仅是串值，接受一串，有两枚举，值的形式"枚举。价值"。工作代码下面的-需要Java1.8或以后。这也将使XML更精确的因为你会看到的东西喜欢的颜色="的色彩。红色"，而不只是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;
    }


}

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow