c#中深拷贝和浅拷贝（表达式树）

c#的object类提供了一个浅拷贝的方法MemberwiseClone，该方法克隆的是原始对象的独立副本，但是这个副本和原始对象会共同指向同一个引用类型属性的引用。比如官方提供了一个例子：

public class IdInfo
{
    public int IdNumber;
    
    public IdInfo(int IdNumber)
    {
        this.IdNumber = IdNumber;
    }
}

public class Person 
{
    public int Age;
    public string Name;
    public IdInfo IdInfo;

    public Person ShallowCopy()
    {
       return (Person) this.MemberwiseClone();
    }

    public Person DeepCopy()
    {
       Person other = (Person) this.MemberwiseClone();
       other.IdInfo = new IdInfo(IdInfo.IdNumber);
       other.Name = String.Copy(Name);
       return other;
    }
}

如果你对Person类的某个实例对象person1使用MemberwiseClone方法进行浅拷贝得到person2，那么person1和person2的IdInfo指向的是同一个引用。

MemberwiseClone 方法创建一个浅表副本，方法是创建一个新的对象，然后将当前对象的非静态字段复制到新的对象。 如果字段是值类型，则执行字段的逐位副本。 如果字段是引用类型，则会复制引用，但不会复制引用的对象;因此，原始对象及其复本引用相同的对象。

同时，官方文档也提供了四种深拷贝的方案：

• 调用要复制的对象的类构造函数，以创建具有从第一个对象获取的属性值的第二个对象。 这假设对象的值由其类构造函数完全定义。

• 调用 MemberwiseClone 方法来创建对象的浅表副本，然后将原始对象的属性深拷贝到新对象里面。

• 序列化要深层复制的对象，然后将序列化的数据还原到其他对象变量。

• 使用带有递归的反射来执行深层复制操作。

第一种和第二种方法，本质都是根据类的结构写特定的拷贝方法。第三种和第四种方法则相对通用许多。

1.反射方式：

        public T DeepCopyByReflection<T>(T obj)
        {
            Type type = obj.GetType();

            if (obj is string || type.IsValueType) return obj;

            if (type.IsArray)
            {
                Type elementType = Type.GetType(type.FullName.Replace("[]", string.Empty));
                var array = obj as Array;
                Array copied = Array.CreateInstance(elementType, array.Length);
                for (int i = 0; i < array.Length; i++)
                {
                    copied.SetValue(DeepCopyByReflection(array.GetValue(i)), i);
                }

                return (T)Convert.ChangeType(copied, obj.GetType());
            }

            object retval = Activator.CreateInstance(obj.GetType());

            var fields = obj.GetType().GetFields(BindingFlags.Public | 
BindingFlags.NonPublic | BindingFlags.Instance);
            
            foreach (var field in fields)
            {
                var val = field.GetValue(obj);
                if (val == null)
                    continue;
                field.SetValue(retval, DeepCopyByReflection(val));
            }
            return (T)retval;
        }

上面的代码是一种通过反射来进行深拷贝的方法，它的本质是递归一个类，把所有的字段通过反射的方式重新赋值给新的类。这里需要注意的是要使用GetFields而不是GetProperties方法来获取目标类里面的所有的字段，因为GetProperties方法只能获取到属性，对于私有的字段，无法获取到，这样，深拷贝的时候就会漏掉这个私有字段。

它会调用其中一个构造方法，所以当你使用这个方法的时候，要特别注意你的那个无参构造方法里面的功能逻辑代码，要考虑执行了这个构造方法之后，会产生哪些后果。

另外这个时候如果你的类里面包含一个Action，由于这个Action没有无参构造方法，你再用这个克隆方法就会变得很麻烦。实际上不止Action，只要被克隆的对象里面包含一个无参构造方法的实体对象，那么用这种反射的方式克隆就会变得很麻烦，因为需要在实例化的时候给构造方法传递参数。

另外，针对循环引用的问题，这个方法解决起来也会很棘手。

2.序列化方式：

        // 利用XML序列化和反序列化实现
        public T DeepCopyWithXmlSerializer<T>(T obj)
        {
            object retval;
            using (MemoryStream ms = new MemoryStream())
            {
                XmlSerializer xml = new XmlSerializer(typeof(T));
                xml.Serialize(ms, obj);
                ms.Seek(0, SeekOrigin.Begin);
                retval = xml.Deserialize(ms);
                ms.Close();
            }

            return (T)retval;
        }

        // 利用二进制序列化和反序列实现，支持循环引用
        public T DeepCopyWithBinarySerialize<T>(T obj)
        {
            object retval;
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
                // 序列化成流
                bf.Serialize(ms, obj);
                ms.Seek(0, SeekOrigin.Begin);
                // 反序列化成对象
                retval = bf.Deserialize(ms);
                ms.Close();
            }
            
            return (T)retval;
        }

        // 利用DataContractSerializer序列化和反序列化实现
        public T DeepCopy<T>(T obj)
        {
            object retval;
            using (MemoryStream ms = new MemoryStream())
            {
                DataContractSerializer ser = new DataContractSerializer(typeof(T));
                ser.WriteObject(ms, obj);
                ms.Seek(0, SeekOrigin.Begin);
                retval = ser.ReadObject(ms);
                ms.Close();
            }
            return (T)retval;
        }

序列化相对来说是一种不错的方式，因为它解决了无参构造方法的克隆问题，同时它也不会导致在克隆的时候调用构造函数，因为克隆多调用一次构造函数，其实是我们不太希望的结果。

3.表达树方式（Expression Trees）：

这种方式的本质是动态生成一段克隆代码，然后把被克隆对象的属性逐个拷贝给新的对象。github上有一个开源项目，采用的就是这种方式。https://github.com/MarcinJuraszek/CloneExtensions

这个项目会根据你要拷贝的对象，利用表达树自动生成深拷贝的代码块，帮你拷贝一个对象。它目前的问题是无法深拷贝私有变量。但是它解决了循环引用的问题。