Question

有许多c＃代码片段展示了构建.net程序集。

代码运行成功，但问题是保存的程序集不包含生成的代码。 - 即使我为AssemblyBuilder设置了RunAndSave属性。

有人能告诉我如何使用生成的类，方法等正确构建和保存程序集吗？

谢谢！

Answer 1

以下是我在演示中使用的一些代码。这是一个快速的例子，但它的工作原理。保存在BuildGenericType方法中完成。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection.Emit;
using System.Reflection;

namespace ReflectionEmit
{
    class Program
    {
        delegate int DoMath(int value);

        static DoMath mathFunc;

        static void Main(string[] args)
        {
            CreateCode(27, true);
            CreateCode(27, false);

            BuildGenericType();

            Console.ReadKey();
        }

        private static void CreateCode(int value, bool square)
        {
            mathFunc = (DoMath)BuildMethod(square).CreateDelegate(typeof(DoMath));
            int result = mathFunc(value);

            Console.WriteLine("Result for {0} was {1}", value, result );

        }

        private static DynamicMethod BuildMethod(bool square)
        {
            Type[] methodArgs = { typeof(int) };
            DynamicMethod mthMeth = new DynamicMethod(
                "Square",
                typeof(int),
                methodArgs,
                typeof(ReflectionEmit.Program).Module);

            ILGenerator il = mthMeth.GetILGenerator();

            if (square)
            {
                il.Emit(OpCodes.Ldarg_0); //Loads argument at index 0 into the evaluation stack
                il.Emit(OpCodes.Conv_I8); //Converts the value on top of the evaluation stack to int64
                il.Emit(OpCodes.Dup); //Copies the top most value on the evaluation stack, then pushes it to the top
                il.Emit(OpCodes.Mul); //Multiplies two values then pushes result to top of evaluation stack
                il.Emit(OpCodes.Ret); //Returns from the current method, pushing a return value (if present) from the callee's evaluation stack onto the caller's evaluation stack. 
            }
            else
            {
                il.Emit(OpCodes.Ldarg_0); //Loads argument at index 0 into the evaluation stack
                il.Emit(OpCodes.Conv_I8); //Converts the value on top of the evaluation stack to int64
                il.Emit(OpCodes.Dup); //Copies the top most value on the evaluation stack, then pushes it to the top
                il.Emit(OpCodes.Add); //Adds two values then pushes result to top of evaluation stack
                il.Emit(OpCodes.Ret); //Returns from the current method, pushing a return value (if present) from the callee's evaluation stack onto the caller's evaluation stack.
            }

            return mthMeth;
        }

        private static void BuildGenericType()
        {
            //Define assembly
            AppDomain dom = AppDomain.CurrentDomain;
            AssemblyName asmName = new AssemblyName("domath");
            AssemblyBuilder asm = dom.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);

            //Define a dynamic module
            ModuleBuilder mod = asm.DefineDynamicModule(asmName.Name, asmName.Name + ".dll");

            //Define a class
            TypeBuilder asmType = mod.DefineType("OurClass", TypeAttributes.Public);

            //Define the generic type parameters
            string[] typeNames = { "TFirst", "TSecond" };
            GenericTypeParameterBuilder[] genTypes = asmType.DefineGenericParameters(typeNames);

            GenericTypeParameterBuilder TFirst = genTypes[0];
            GenericTypeParameterBuilder TSecond = genTypes[1];

            //Define generic constraints
            TFirst.SetGenericParameterAttributes(GenericParameterAttributes.DefaultConstructorConstraint | GenericParameterAttributes.ReferenceTypeConstraint);
            TSecond.SetBaseTypeConstraint(typeof(SomeBaseClass));

            Type[] interfaceTypes = {typeof(InterfaceA), typeof(InterfaceB) };
            TSecond.SetInterfaceConstraints(interfaceTypes);

            //Define a field
            FieldBuilder fld1 = asmType.DefineField("Field1", TFirst, FieldAttributes.Private);

            //Define method
            Type listOf = typeof(List<>);
            Type listOfTFirst = listOf.MakeGenericType(TFirst);
            Type[] paramTypes = { TFirst.MakeArrayType() };

            MethodBuilder asmMethod = asmType.DefineMethod("SomeMethod", MethodAttributes.Public | MethodAttributes.Static, listOfTFirst, paramTypes);

            //Define Method Body
            ILGenerator il = asmMethod.GetILGenerator();

            Type ienumOf = typeof(IEnumerable<>);
            Type tFromListOf = listOf.GetGenericArguments()[0];
            Type ienumOfT = ienumOf.MakeGenericType(tFromListOf);
            Type[] ctorArgs = { ienumOfT };

            ConstructorInfo ctorPrep = listOf.GetConstructor(ctorArgs);
            ConstructorInfo ctor = TypeBuilder.GetConstructor(listOfTFirst, ctorPrep);

            il.Emit(OpCodes.Ldarg_0); //Loads the argument at index 0 onto the evaluation stack.
            il.Emit(OpCodes.Newobj, ctor); //Creates a new object or a new instance of a value type, pushing an object reference (type O) onto the evaluation stack.
            il.Emit(OpCodes.Ret); //Returns from the current method, pushing a return value (if present) from the callee's evaluation stack onto the caller's evaluation stack.

            //Create type and save file
            Type finished = asmType.CreateType();
            asm.Save(asmName.Name + ".dll");



        }
    }

    public interface InterfaceA { }
    public interface InterfaceB { }

    public class SomeBaseClass
    {

    }
}

作为替代方案，也许你可以试试Rosyln？ http://blogs.msdn.com/b/csharpfaq/archive/2011/12/02/introduction-to-the-roslyn-scripting-api.aspx

Answer 2

使用Microsoft documentation Example作为参考源代码，我猜想OP缺少的重要部分是对第二个参数（fileName使用相同的名称调用DefineDynamicModule时，以及调用Save时的第一个参数在AssemblyBuilder上。在这些地方使用相同的名称时，动态创建的模块及其所有类型等将与程序集一起保存。

在示例代码的文档中，该名称由aName.Name + ".dll"组成，如下所示：

AssemblyName aName = new AssemblyName("DynamicAssemblyExample");
AssemblyBuilder ab = AppDomain.CurrentDomain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.RunAndSave); // Include Save access!

ModuleBuilder mb = ab.DefineDynamicModule(aName.Name, aName.Name + ".dll"); // *Same name here ..*

// ... (Other code building types, methods etc.)

ab.Save(aName.Name + ".dll"); // *... and here*

其他说明：

文档中示例代码中的注释

“对于单模块程序集，模块名称通常是程序集名称加上扩展名。“

“备注”部分指出

”如果一个动态程序集包含多个动态模块，则程序集的清单文件名应与模块名称匹配，即指定为DefineDynamicModule方法的第一个参数。”

如上所述，这也许是找出使用相同名称的线索。实际上，它也可以使用DefineDynamicModule的一个参数重载来工作，并在那里使用文件名来命名模块。

请注意，DefineDynamicModule(String, String)重载在.NET Core或.NET 5.0中不可用。

如何构建程序集并保存它？

2 个答案: