在C#中，我们通常会在编译时定义好类的属性。然而，有时候会遇到需要在运行时动态添加属性的情况。比如，根据不同的业务需求对对象进行扩展。本文将介绍如何通过C#中的反射和 Reflection.Emit 动态地为对象添加属性。

什么是反射和动态属性？

反射 是一种能够在程序运行时检查和调用对象成员（如属性、方法、字段）的功能。动态属性 则是指在程序运行时添加到对象的新属性。这在编写灵活性较高的程序时非常有用。

使用Reflection.Emit动态添加属性

Reflection.Emit 是.NET 提供的一组API，它允许我们在运行时生成和操作程序集、模块和类型。通过 System.Reflection.Emit，我们可以动态地创建类型并为这些类型添加属性。

代码实现

以下是一个完整的代码示例，演示如何为一个已有的类 Person 动态添加属性。

导入必要的命名空间

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

定义基础类

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

定义动态添加属性的核心逻辑

public static Type AddDynamicPropertiesToObject(Type baseType, Dictionary<string, Type> properties)
{
    var assemblyName = new AssemblyName(baseType.FullName + "DynamicAssembly");
    var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
    var moduleBuilder = assemblyBuilder.DefineDynamicModule(baseType.FullName + "DynamicModule");
    var typeBuilder = moduleBuilder.DefineType(baseType.FullName + "Proxy", TypeAttributes.Public, baseType);

    // 定义与原始类型相同的构造函数
    var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes);
    var ctorIL = constructorBuilder.GetILGenerator();
    ctorIL.Emit(OpCodes.Ldarg_0);
    ctorIL.Emit(OpCodes.Call, baseType.GetConstructor(Type.EmptyTypes));
    ctorIL.Emit(OpCodes.Ret);

    foreach (var property in properties)
    {
        // 定义字段
        var fieldBuilder = typeBuilder.DefineField("_" + property.Key, property.Value, FieldAttributes.Private);
        // 定义属性
        var propertyBuilder = typeBuilder.DefineProperty(property.Key, PropertyAttributes.HasDefault, property.Value, null);

        // 定义getter方法
        var getterMethod = typeBuilder.DefineMethod("get_" + property.Key, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, property.Value, Type.EmptyTypes);
        var getterIL = getterMethod.GetILGenerator();
        getterIL.Emit(OpCodes.Ldarg_0);
        getterIL.Emit(OpCodes.Ldfld, fieldBuilder);
        getterIL.Emit(OpCodes.Ret);
        propertyBuilder.SetGetMethod(getterMethod);

        // 定义setter方法
        var setterMethod = typeBuilder.DefineMethod("set_" + property.Key, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, new Type[] { property.Value });
        var setterIL = setterMethod.GetILGenerator();
        setterIL.Emit(OpCodes.Ldarg_0);
        setterIL.Emit(OpCodes.Ldarg_1);
        setterIL.Emit(OpCodes.Stfld, fieldBuilder);
        setterIL.Emit(OpCodes.Ret);
        propertyBuilder.SetSetMethod(setterMethod);
    }

    // 创建动态类型
    var dynamicType = typeBuilder.CreateType();
    return dynamicType;
}

复制字段和属性值

为了确保新建的对象包含原始对象的所有数据，我们需要一个方法来复制原始对象的字段和属性。

private static void CopyFields<T>(T source, object destination)
{
    var sourceType = source.GetType();
    var destType = destination.GetType();
    var fields = sourceType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
    
    // 复制字段
    foreach (var field in fields)
    {
        var destField = destType.GetField(field.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
        if (destField != null)
        {
            destField.SetValue(destination, field.GetValue(source));
        }
    }

    var properties = sourceType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
    
    // 复制属性
    foreach (var property in properties)
    {
        if (property.CanRead && property.CanWrite)
        {
            var destProperty = destType.GetProperty(property.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            if (destProperty != null)
            {
                destProperty.SetValue(destination, property.GetValue(source));
            }
        }
    }
}

示例主函数

最后，我们编写一个示例主函数来演示这一功能。

public static void Main(string[] args)
{
    var person = new Person { Name = "Bob", Age = 32 };

    // 动态生成新类型
    var dynamicType = AddDynamicPropertiesToObject(
        typeof(Person),
        new Dictionary<string, Type>
        {
            { "Country", typeof(string) },
            { "Occupation", typeof(string) }
        });

    // 创建代理对象
    var proxyPerson = Activator.CreateInstance(dynamicType);

    // 复制原始对象的字段到代理对象
    CopyFields(person, proxyPerson);

    // 设置新属性的值
    dynamicType.GetProperty("Country")?.SetValue(proxyPerson, "Australia");
    dynamicType.GetProperty("Occupation")?.SetValue(proxyPerson, "Developer");

    // 打印输出
    Console.WriteLine(#34;Name: {((Person)proxyPerson).Name}");
    Console.WriteLine(#34;Age: {((Person)proxyPerson).Age}");
    Console.WriteLine(#34;Country: {dynamicType.GetProperty("Country")?.GetValue(proxyPerson)}");
    Console.WriteLine(#34;Occupation: {dynamicType.GetProperty("Occupation")?.GetValue(proxyPerson)}");
}

总结

通过上述步骤，我们已经成功地为 Person 类在运行时动态添加了 Country 和 Occupation 属性。整个过程包括动态生成类型、复制字段和属性值，并创建和操作代理对象。这种方法在需要高度动态和灵活性的应用场景中非常有用。

希望通过这篇文章，读者能够了解如何使用反射和 Reflection.Emit 在运行时实现动态属性的添加。如果有任何问题或建议，欢迎在评论中交流。