.NET IL实现对象深拷贝

对于深拷贝，通常的方法是将对象进行序列化，然后再反序化成为另一个对象。例如在stackoverflow上有这样的解决办法：https://stackoverflow.com/questions/78536/deep-cloning-objects/78612#78612。这种序列化的方式，对深拷贝来讲，无疑是一个性能杀手。

今天大家介绍一个深拷贝的框架 DeepCopy，github地址：https://github.com/ReubenBond/DeepCopy，它是从orleans框架改编过来的，实现逻辑非常简单。

框架的实现原理是通过IL代码生成字段拷贝的方法。IL的优点是可以绕过C#的语法规则，例如：访问私有对象以及给readonly字段赋值等。

在介绍框架前，先介绍一下IL相关的工具。

IL工具

即使您不是第一次使用IL，这也不是一件容易的事情，无法确认什么样IL代码才能达到预期的结果。这是工具来帮助您的地方。可以先用C#编写代码，然后将它复制到LINQPad中，运行并打开输出中的IL选项卡。

使用像JetBrains的dotPeek这样的反编译/反汇编程序也是一个不错选择。您可以将编译的程序集在dotPeek中打开它来显示IL。

最后，ReSharper是不可或缺的工具。ReSharper带有一个方便的IL查看器。

这些工具可以帮助您如何解决IL产生的问题，您也可以访问官方文档。

DeepCopy

DeepCopy本质上它只提供了一个方法：

    public static T Copy<T>(T original);

DeepCopy调用示例代码：

    List<string> original = new List<string>(2);

    original.Add("A");
    original.Add("B");

    var result = DeepCopier.Copy(original);

实现原理

Copy方法将递归传递对象中的每个字段复制到相同类型的新实例中。首先要处理的是对同一个对象的多次引用，如果用户提供了一个包含自身引用的对象，那么结果也会包含对自身的引用。这意味着我们需要执行引用跟踪。这点很容易做到：我们维护一个Dictionary<object, object>从原始对象到拷贝对象的映射。我们的主要方法Copy<T>(T orig)将调用上下文的方法来检查字典中拷贝的对象是否存在：

    public static T Copy<T>(T original, CopyContext context)
    {
      /* TODO: implementation */
    }

拷贝流程大致如下：

• 如果传入是null，则返回null；
• 如果传入的对象已经拷贝过，则返回其拷贝过的对象；
• 如果传入是“不可变的对象”，则直接返回传入对象；
• 如果传入是一个数组，则将每个元素复制到一个新数组中并将其返回；
• 创建一个新的传入类型实例，递归地将每个字段从传入对象复制到拷贝对象并返回。

对“不可变对象”的定义很简单：类型是一个基原类型、Enum、String、Guid、DateTime...，或者使用特殊[Immutable]标记的类型。更详细的不可变类型可以参考源代码，CopyPolicy.cs。

除了上面的最后一步，其它的事情都很简单。最后一步，递归复制每个字段，可以使用反射来获取和设置字段值。反射是一个性能杀手，所以使用IL来实现这一步。

IL代码实现

DeepCopy中的主要IL代码在CopierGenerator.cs类的CreateCopier<T>(Type type)方法中。让我们一步步揭秘：

首先创建一个DynamicMethod对象，它将保存创建的IL代码。在创建DynamicMethod对象时，必须告诉它签名是什么，在这里，它是一个通用的委托类型delegate T DeepCopyDelegate<T>(T original, CopyContext context)。

    var dynamicMethod = new DynamicMethod(
        type.Name + "DeepCopier",
        typeof(T), // 委托返回的类型
        new[] {typeof(T), typeof(CopyContext)}, // 委托的参数类型。
        typeof(CopierGenerator).Module,
        true);
    
    var il = dynamicMethod.GetILGenerator(); 

IL将会变得相当复杂，因为它需要处理不可变的类型和值类型，接下来让我一点一点地说明。

    // 定义一个变量来保存返回的结果。
    il.DeclareLocal(type);

接下来，需要初始化传入类型的新实例到局部变量。有三种情况需要考虑，每种情况对应下面代码中的一个块：

• 该类型是一个值类型（结构）。使用default(T)表达式来初始化它。
• 该类型有一个无参数的构造函数。通过调用new T()初始化它。
• 该类型没有无参数的构造函数。在这种情况下，我们借助 .Net 框架来解决，调用FormatterServices.GetUninitializedObject(type)。

    // 构造结果对象实例。
    var constructorInfo = type.GetConstructor(Type.EmptyTypes);
    if (type.IsValueType)
    {
        // 值类型可以直接初始化。
        // C#: result = default(T);
        il.Emit(OpCodes.Ldloca_S, (byte)0);
        il.Emit(OpCodes.Initobj, type);
    }
    else if (constructorInfo != null)
    {
        // 如果存在默认构造函数，则直接使用默认的参数。
        // C#: result = new T();
        il.Emit(OpCodes.Newobj, constructorInfo);
        il.Emit(OpCodes.Stloc_0);
    }
    else
    {
        // 如果没有默认构造函数的存在，使用GetUninitializedObject创建实例。
        // C#: result = (T)FormatterServices.GetUninitializedObject(type);
        il.Emit(OpCodes.Ldtoken, type);
        il.Emit(OpCodes.Call, DeepCopier.MethodInfos.GetTypeFromHandle);
        il.Emit(OpCodes.Call, this.methodInfos.GetUninitializedObject);
        il.Emit(OpCodes.Castclass, type);
        il.Emit(OpCodes.Stloc_0);
    }

在本地创建一个用于保存结果的变量，它是传入类型的新实例。在我们做任何事情之前，我们必须记录新创建对象的引用。将每个参数按顺序推入堆栈，并使用OpCodes.Call来调用context.RecordObject(original, result)。使用OpCodes.Call来调用CopyContext.RecordObject方法，因为CopyContext是一个sealed类，否则会使用OpCodes.Callvirt。

    // 值类型的实例不会存在多次引用的问题，
    // 所以只在上下文中记录引用类型。
    if (!type.IsValueType)
    {
        // 记录对象引用。
        // C#: context.RecordObject(original, result);
        il.Emit(OpCodes.Ldarg_1); // 参数：context
        il.Emit(OpCodes.Ldarg_0); // 参数数：original
        il.Emit(OpCodes.Ldloc_0); // 本地用来保存结果的变量
        il.Emit(OpCodes.Call, this.methodInfos.RecordObject);
    }

枚举对象上的每一个字段并生成代码，将字段的值复制到结果变量中。过程如下：

    // 复制每一个字段的值。
    foreach (var field in this.copyPolicy.GetCopyableFields(type))
    {
        // 加载结果对象的引用。
        if (type.IsValueType)
        {
            // 值类型需要通过地址来加载，而不是复制到堆栈上。
            il.Emit(OpCodes.Ldloca_S, (byte)0);
        }
        else
        {
            il.Emit(OpCodes.Ldloc_0);
        }
    
        // 加载原始对象字段的值。
        il.Emit(OpCodes.Ldarg_0);
        il.Emit(OpCodes.Ldfld, field);
    
        // 如果是不可变类型则直接赋值，否则需要深拷贝字段。
        if (!this.copyPolicy.IsShallowCopyable(field.FieldType))
        {
            // 复制字段使用泛型方法 DeepCopy.Copy<T>(T original, CopyContext context)
            // C#: Copy<T>(field)
            il.Emit(OpCodes.Ldarg_1);
            il.Emit(OpCodes.Call, this.methodInfos.CopyInner.MakeGenericMethod(field.FieldType));
        }
    
        // 将复制的值赋给结果对象的字段。
        il.Emit(OpCodes.Stfld, field);
    }

返回结果并通过CreateDelegate构建委托，下一步可以直接使用。

    // C#: return result;
    il.Emit(OpCodes.Ldloc_0);
    il.Emit(OpCodes.Ret);
    
    return dynamicMethod.CreateDelegate(typeof(DeepCopyDelegate<T>)) as DeepCopyDelegate<T>;

性能

框架性能怎么样呢，分别比较通过手写代码、DeepCopy、二进制序列化和Json.Net序列化来实现对象的深拷贝，然后通过 Benchmark测试一下它们之间的性能。

实现方式	Method	Mean	Error	StdDev	Gen 0	Allocated
手写代码	CodeCopy	7.874 ns	0.0941 ns	0.0880 ns	0.0203	64 B
DeepCopy	DeepCopy	114.510 ns	0.4071 ns	0.3608 ns	0.0203	64 B
二进制序列化	BinarySerialize	46,912.139 ns	156.4497 ns	138.6886 ns	3.4180	10827 B
Json.Net序列化	JsonSerialize	8,942.457 ns	97.0560 ns	90.7862 ns	1.6479	5208 B

虽然DeepCopy与手写代码来说性能相差很大(差异很大的根本原因是反复查找是否存在自引用)，但是与二进制序列化、Json序列化来说，性能不在一个等级上。

总结

这是框架的内部逻辑，当然还有一些细节被遗漏了，例如：数组中的特殊处理DeepCopier.cs；

当然还有很多需要优化的细节，大家可以在github上提出您的宝贵意见。

参考内容：

• https://reubenbond.github.io/posts/codegen-2-il-boogaloo

作者：Sweet Tang
本文地址：http://www.cnblogs.com/tdfblog/p/DeepCopy-By-IL.html
欢迎转载，请在明显位置给出出处及链接。