深入解析浅复制和深复制

通过c#类型基础了解到变量在内存中的状态，那么我现在想把一个变量传递给另一个变量，对值和对象进行复制。实际上浅度复制是把栈中的数据复制下来，深度复制是把堆上的值进行复制。

那么什么时候使用深复制什么时候来使用浅复制呢，假如我请求一次数据库获取到这个对象，再创建新对象的时候可能会用复制的方式来创建这个对象，而不是再去请求一次数据库。

浅复制：

先看一段代码，

class Program
    {
        static void Main(string[] args)
        {
            int a = new int();
            a = 3;
            int b = a;
            a += 1;

            People peo = new People() { age = 19 };
            People peo2 = peo;
            peo.age = 20;
            Console.WriteLine("b={0},peo2={1}", b, peo2.age); //输出b=3,peo2=20
            Console.Read();
        }
    }
    public class People
    {
        public int age;
    }

结论：浅复制是将栈中的值复制一份，也就是值类型把这个值本身复制一份，操作原来的值对新值没有影响。引用类型是把栈上的引用值复制一份，对象本身不复制，操作对象，新对象也会跟着变化。

深复制：

上面已经介绍了浅拷贝的实现方式，那深拷贝要如何实现呢？在前言部分已经介绍了，实现深拷贝的方式有：反射、反序列化和表达式树。表达式树这里还不是很清晰，持续更新吧。

// 利用反射实现深拷贝
        public static T CopyWithReflection<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(DeepCopyWithReflection(array.GetValue(i)), i);
                }

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

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

            PropertyInfo[] properties = obj.GetType().GetProperties(
                BindingFlags.Public | BindingFlags.NonPublic
                | BindingFlags.Instance | BindingFlags.Static);
            foreach (var property in properties)
            {
                var propertyValue = property.GetValue(obj, null);
                if (propertyValue == null)
                    continue;
                property.SetValue(retval, DeepCopyWithReflection(propertyValue), null);
            }

            return (T)retval;
        }
//反序列化的实现方式，反序列化的方式也可以细分为3种，具体的实现如下所示：

 // 利用XML序列化和反序列化实现
        public static T CopyWithXmlSerializer<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 static T CopyWithBinarySerialize<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 static 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;
        }

为了方便测试，就用反序列化的方式来进行测试：

class Program
    {
        static void Main(string[] args)
        {
            People peo = new People() { age = 18 };
            People peo2 = (People)peo.Clone();
            peo.age = 20;
            Console.WriteLine("peo.age={0},peo2.age={1}", peo.age, peo2.age);//输出：peo.age=20,peo2.age=18
            Console.Read();
        }
        
    }
    [Serializable]
    public class People
    {
        public int age;
        public object Clone()
        {
            BinaryFormatter bf = new BinaryFormatter();
            MemoryStream ms = new MemoryStream();
            bf.Serialize(ms, this);
            ms.Position = 0;
            return (bf.Deserialize(ms)); ;
        }
    }

结论就不罗嗦了复制就这么回事，主要是理解，理解变量在内存中是怎么变化的。其实js里面的深浅复制也是这么回事。

谢谢大家观看！