使用 AssemblyBuilder 构建复杂类型

Question

我一直在研究 small library to build very simple types dynamically using AssemblyBuilder。我可以构建一个类型，向其中添加属性。但我面临的问题是添加一个属性给定一个动态生成的类型，该类型也是使用这个简单的库生成的。在其他作品中，创建复杂类型。我尝试向该类型添加名称空间，但我认为问题的根源在于在创建父类型时没有导入嵌套类型。

我如何创建类型和嵌套类型：

var token = "TestNameSpace";
var nestedType = Builders.CustomTypeBuilder.New(@namespace: token).AddProperty<string>("NestedProp").Compile();

var propertyName = "NestedProp";
var obj = Builders.CustomTypeBuilder.NewExtend<DummyClass>(@namespace: token)
    .AddProperty(propertyName, nestedType)
    .Instantiate<DummyClass>();

嵌套类型（或NestedProp）类似于undefined（"Unresolved ..."）。

库背后的主要逻辑：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using CustomTypeBuilder.Extensions;
using static CustomTypeBuilder.Utilities.TypeUtility;

namespace CustomTypeBuilder
{
    /// <summary>
    /// Creates a new type dynamically
    /// </summary>
    public class CustomTypeGenerator
    {
        private readonly TypeBuilder _typeBuilder;

        private readonly Dictionary<string, Type> _properties;

        /// <summary>
        /// Initialize custom type builder
        /// </summary>
        /// <param name="name"></param>
        /// <param name="parentType"></param>
        /// <param name="namespace"></param>
        public CustomTypeGenerator(string name = null, Type parentType = null, string @namespace = null)
        {
            var assemblyName = RandomSafeString("DynamicAseembly");
            var typeSignature = name ?? RandomSafeString("DynamicType");

            // add namespace
            if (@namespace != name)
            {
                typeSignature = $"{@namespace}.{typeSignature}";
            }

            var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(assemblyName), AssemblyBuilderAccess.Run);
            var moduleBuilder = assemblyBuilder.DefineDynamicModule(RandomSafeString("Module"));
            _typeBuilder = moduleBuilder.DefineType(typeSignature,
                TypeAttributes.Public |
                TypeAttributes.Class |
                TypeAttributes.AutoClass |
                TypeAttributes.AnsiClass |
                TypeAttributes.BeforeFieldInit |
                TypeAttributes.AutoLayout,
                parentType);

            _typeBuilder.DefineDefaultConstructor(MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName);

            _properties = new Dictionary<string, Type>();
        }

        /// <summary>
        /// Add attribute to the class
        /// </summary>
        /// <param name="attribute"></param>
        public void AddAttribute(Attribute attribute)
        {
            _typeBuilder.SetCustomAttribute(attribute.BuildCustomAttribute());
        }

        /// <summary>
        /// Compile the type builder to a type
        /// </summary>
        /// <returns></returns>
        public Type CompileResultType()
        {            
            return _typeBuilder.CreateType();
        }

        /// <summary>
        /// Add interfaces to a type
        /// </summary>
        /// <param name="type"></param>
        public void AddInterface(Type type)
        {
            if (!type.IsInterface)
            {
                throw new ArgumentException("Type was expected to be an interface");
            }

            _typeBuilder.AddInterfaceImplementation(type);

            // add types in interface
            type.GetProperties().ForEach(x => AddProperty(x.Name, x.PropertyType));
        }

        public void ExtendType(Type type)
        {
            _typeBuilder.SetParent(type);
        }

        public void AddProperty(string propertyName, Type propertyType)
        {
            if (!IsValidName(propertyName)) throw new ArgumentException("Property name does not follow to C# type system");

            if (_properties.Keys.Any(x => x == propertyName)) throw new ArgumentException("Duplicate property name");

            // add property to dictionary
            _properties.Add(propertyName, propertyType);

            var fieldBuilder = _typeBuilder.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);

            var propertyBuilder = _typeBuilder.DefineProperty(propertyName, PropertyAttributes.HasDefault, propertyType, null);
            var getPropMthdBldr = _typeBuilder.DefineMethod("get_" + propertyName,
                MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, propertyType,
                Type.EmptyTypes);
            var getIl = getPropMthdBldr.GetILGenerator();

            getIl.Emit(OpCodes.Ldarg_0);
            getIl.Emit(OpCodes.Ldfld, fieldBuilder);
            getIl.Emit(OpCodes.Ret);

            var setPropMthdBldr = _typeBuilder.DefineMethod("set_" + propertyName,
                    MethodAttributes.Public |
                    MethodAttributes.SpecialName |
                    MethodAttributes.HideBySig,
                    null, new[] {propertyType});

            var setIl = setPropMthdBldr.GetILGenerator();
            var modifyProperty = setIl.DefineLabel();
            var exitSet = setIl.DefineLabel();

            setIl.MarkLabel(modifyProperty);
            setIl.Emit(OpCodes.Ldarg_0);
            setIl.Emit(OpCodes.Ldarg_1);
            setIl.Emit(OpCodes.Stfld, fieldBuilder);

            setIl.Emit(OpCodes.Nop);
            setIl.MarkLabel(exitSet);
            setIl.Emit(OpCodes.Ret);

            propertyBuilder.SetGetMethod(getPropMthdBldr);
            propertyBuilder.SetSetMethod(setPropMthdBldr);
        }
    }
}

如有任何帮助，我们将不胜感激。谢谢。

Answer 1

虽然不能完全解决您的问题，但我希望其中的一些信息有所帮助。

来自 Visual Studio 2017 和 .NET Core 2.0 的调试器似乎可以显示 type/object。

嵌套类型也可以正确设置和显示。

它似乎在 VS Code 中也能正常工作

奇怪的是，当我们实例化 并分配 对象时，Rider 调试器和 .NET Core 2.0 似乎能够正确识别嵌套的属性类型 nestedType 在构造使用它的其他对象类型之前，但是如果我们仅仅实例化它是行不通的。

例如

var token = "TestNameSpace";
var nestedType = Builders.CustomTypeBuilder.New(@namespace: token).AddProperty<string>("NestedProp").Compile();
var propertyName = "NewProperty";

var someInstance = Activator.CreateInstance(nestedType);

var obj = Builders.CustomTypeBuilder.NewExtend<DummyClass>(@namespace: token)
    .AddProperty(propertyName, nestedType)
    .Instantiate<DummyClass>();

var nestedValue = Activator.CreateInstance(nestedType);

nestedType.GetProperty("NestedProp").SetValue(nestedValue, "NestedValue");
obj.GetType().GetProperty(propertyName).SetValue(obj, nestedValue);
Debugger.Break();

对比

var token = "TestNameSpace";
var nestedType = Builders.CustomTypeBuilder.New(@namespace: token).AddProperty<string>("NestedProp").Compile();
var propertyName = "NewProperty";

// Instantiated, but not assigned to a local variable
Console.WriteLine(Activator.CreateInstance(nestedType));

var obj = Builders.CustomTypeBuilder.NewExtend<DummyClass>(@namespace: token)
    .AddProperty(propertyName, nestedType)
    .Instantiate<DummyClass>();

var nestedValue = Activator.CreateInstance(nestedType);

nestedType.GetProperty("NestedProp").SetValue(nestedValue, "NestedValue");
obj.GetType().GetProperty(propertyName).SetValue(obj, nestedValue);
Debugger.Break();

但是，如果我们首先创建嵌套类型、实例化它并将其分配给单独作用域中的变量，那么这似乎取决于调试器是否在分配后暂停。

例如

static Type CreateNestedType()
{
    var nestedType = Builders.CustomTypeBuilder.New(@namespace: "TestNameSpace")
                             .AddProperty<string>("NestedProp")
                             .Compile();

    var x = Activator.CreateInstance(nestedType);
    Console.WriteLine(x.GetType());
    // Toggling this line changes the behaviour of the debugger at the *next* breakpoint.
    //Debugger.Break();
    return nestedType;
}

static void Main(string[] args)
{
    var nestedType = CreateNestedType();
    var propertyName = "NewProperty";

    var obj = Builders.CustomTypeBuilder.NewExtend<DummyClass>(@namespace: "TestNameSpace")
        .AddProperty(propertyName, nestedType)
        .Instantiate<DummyClass>();

    var nestedValue = Activator.CreateInstance(nestedType);

    nestedType.GetProperty("NestedProp").SetValue(nestedValue, "NestedValue");
    obj.GetType().GetProperty(propertyName).SetValue(obj, nestedValue);
    Debugger.Break();
}

在程序中实际使用对象时，尽管在调试器中显示不正确，但它们似乎行为正确。

当我使用 .NET Framework 而不是 .NET Core 编译和保存动态程序集时，它们都通过了 PEVerify。

当我们在同一动态中定义两种类型时，Rider 似乎可以处理上述所有情况 assembly/module，而不是为每种类型使用新的动态程序集。

基于所有这些，这似乎是 Rider 调试器中的 issue/bug/missing feature/shortcoming（随便你怎么称呼它），你可能想直接用 JetBrains 提升它看看如果他们能进一步说明情况。

使用 AssemblyBuilder 构建复杂类型

Using AssemblyBuilder to build a complex type

c#

reflection.emit

.net-core