从动态创建的Enum获取Enum

Question

你能帮我吗，在C#

给了一个Enum

public enum InterferenceEnum
    {
        None = 0,
        StrongNoiseSource = 1,
        MediumNoiseSource = 2,
        VerySensitiveSignal = 4,
        SensitiveSignal = 8,
    }

这是一个动态的Enum

public Type GenerateEnumerations(List<string> lEnumItems, string assemblyName)
    {
        //    Create Base Assembly Objects
        AppDomain appDomain = AppDomain.CurrentDomain;
        AssemblyName asmName = new AssemblyName(assemblyName);
        AssemblyBuilder asmBuilder = appDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Run);

        //    Create Module and Enumeration Builder Objects
        ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule(assemblyName + "_module");
        EnumBuilder enumBuilder = modBuilder.DefineEnum(assemblyName, TypeAttributes.Public, typeof(int));
        enumBuilder.DefineLiteral("None", 0);
        int flagCnt = 1;
        foreach (string fmtObj in lEnumItems)
        {
            enumBuilder.DefineLiteral(fmtObj, flagCnt);
            flagCnt++;
        }
        var retEnumType = enumBuilder.CreateType();
        //asmBuilder.Save(asmName.Name + ".dll");
        return retEnumType;
    }

使用上述功能

List<string> nets_List = new List<string>() { "A", "B", "C" };
netListEnum = GenerateEnumerations(nets_List, "netsenum");

现在，如果我有一个值为"None“的变量，我可以通过

SomeEnum enum = (SomeEnum)Enum.Parse(typeof(SomeEnum), "EnumValue");

使用第一个Enum，我可以得到字符串"None“的枚举

InterferenceEnum enum = (InterferenceEnum)Enum.Parse(typeof(InterferenceEnum), "None");

如何获得动态生成枚举的枚举？

var enum = (netListEnum.GetType())Enum.Parse(typeof(netListEnum.GetType()), "None"); 

上面的代码是错误的，因为我仍然用netListEnum类型“转换”它，下面是更新的代码

var enum = Enum.Parse(netListEnum, "None"); 

Answer 1

您已经有了它-- "Enum.Parse()“会将指定类型的枚举盒装返回到对象中。但是被装箱的对象是您创建的枚举类型；如果在它上调用"GetType()“，则返回相同的类型：

    List<string> nets_List = new List<string>() { "A", "B", "C" };
    var netListEnumType = GenerateEnumerations(nets_List, "netsenum");

    var typeName = netListEnumType.Name; // returns "netsenum" 
    var typeTypeName = netListEnumType.GetType().Name; // returns "RuntimeType", the actual name of the instantiated Type class.

    foreach (var enumName in nets_List)
    {
        var enumValBoxed = Enum.Parse(netListEnumType, enumName);
        Console.WriteLine(enumValBoxed.ToString()); // Writes "A", "B" and "C"
        Debug.Assert(enumValBoxed.GetType() == netListEnumType); // no assert yay.
    }

我在您的代码中看到的唯一问题是您正在执行netListEnum.GetType()，但是netListEnum已经是Type类型了--实际上是您创建的类型--所以这是不必要的。

如果需要将由此创建的枚举传递给泛型对象中的某些泛型方法，例如Dictionary<string, TEnum>，则可以使用MakeGenericMethod通过反射调用它。

Answer 2

我的造物主：

public class XEnum
    {
        private EnumBuilder enumBuilder;
        private int index;
        private AssemblyBuilder _ab;
        private AssemblyName _name;
        public XEnum(string enumname)
        {
            AppDomain currentDomain = AppDomain.CurrentDomain;
            _name = new AssemblyName("MyAssembly");
            _ab = currentDomain.DefineDynamicAssembly(
                _name, AssemblyBuilderAccess.RunAndSave);

            ModuleBuilder mb = _ab.DefineDynamicModule("MyModule");

            enumBuilder = mb.DefineEnum(enumname, TypeAttributes.Public, typeof(int));


        }
        /// <summary>
        /// adding one string to enum
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public FieldBuilder add(string s)
        {
            FieldBuilder f = enumBuilder.DefineLiteral(s, index);
            index++;
            return f;
        }
        /// <summary>
        /// adding array to enum
        /// </summary>
        /// <param name="s"></param>
        public void addRange(string[] s)
        {
            for (int i = 0; i < s.Length; i++)
            {
                enumBuilder.DefineLiteral(s[i], i);
            }
        }
        /// <summary>
        /// getting index 0
        /// </summary>
        /// <returns></returns>
        public object getEnum()
        {
            Type finished = enumBuilder.CreateType();
            _ab.Save(_name.Name + ".dll");
            Object o1 = Enum.Parse(finished, "0");
            return o1;
        }

        public Type getType()
        {
            Type finished = enumBuilder.CreateType();
            _ab.Save(_name.Name + ".dll");
            return finished;
        }
        /// <summary>
        /// getting with index
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        public object getEnum(int i)
        {
            Type finished = enumBuilder.CreateType();
            _ab.Save(_name.Name + ".dll");
            Object o1 = Enum.Parse(finished, i.ToString());
            return o1;
        }
    }

若要从String Array生成Enum：

 public static object STE(string[] @enum)
        {
            if (@enum.Length > 0)
            {
                XEnum xe = new XEnum("Enum");
                xe.addRange(@enum);
                return xe.getEnum();
            }
            else return null;
        }

若要从枚举获取选定的字符串，请执行以下操作：

 public static object STE(string sel, string[] @enum)
        {
            XEnum xe = new XEnum("Enum");
            xe.addRange(@enum);
            var obj=  xe.getType();
            return Enum.Parse(obj, sel);
        }

要使用STE，将它们放入静态类，因此要使用以下方法：

string[] ab = {"a", "b"};
object abEnum = STE(ab); //creates Enum
private object aEnum = STE("a", ab); //gets selected Value