C#深度学习の----深拷贝与浅拷贝

本人在进行编程的时候遇到一个问题，要对一个绑定的依赖属性进行赋值，改变属性中的某一部分，绑定的目标上的所有值都发生了变化，这并不是我想要的，由此引出深浅拷贝的问题。（请加群交流：435226676）

　　首先，讲到深浅拷贝，自然就有一个问题来了？什么是深拷贝，什么又是浅拷贝呢？下面就具体介绍下它们的定义。

　　深拷贝：指的是拷贝一个对象时，不仅仅把对象的引用进行复制，还把该对象引用的值也一起拷贝。这样进行深拷贝后的拷贝对象就和源对象互相独立，其中任何一个对象的改动都不会对另外一个对象造成影响。举个例子，一个人叫张三，然后使用克隆技术以张三来克隆另外一个人叫李四，这样张三和李四就是相互独立的，不管张三缺胳膊还是李四少腿了都不会影响另外一个人。在.NET领域，值对象就是典型的例子，如int, Double以及结构体和枚举等。具体例子如下所示：

int source = 123;
//值类型赋值内部执行深拷贝
int copy = source;
//对拷贝对象进行赋值不会改变源对象的值
copy = 234;
//同样对源对象赋值也不会改变拷贝对象的值
source = 345;

浅拷贝：指的是拷贝一个对象时，仅仅拷贝对象的引用进行拷贝，但是拷贝对象和源对象还是引用同一份实体。此时，其中一个对象的改变都会影响到另一个对象。例如，一个人一开始叫张三，后来改名字为张老三了，可是他们还是同一个人，
不管张三缺胳膊还是张老三少腿，都反应在同一个人身上。在.NET中引用类型就是一个例子。如类类型。具体例子如下所示：

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

    class Program
    {
        static void Main(string[] args)
        {
            Person sourceP = new Person() { Name = "张三" };
            Person copyP = sourceP; // 浅拷贝
            copyP.Name = "张老三"; // 拷贝对象改变Name值
            // 结果都是"张老三",因为实现的是浅拷贝，一个对象的改变都会影响到另一个对象
            Console.WriteLine("Person.Name: [SourceP: {0}] [CopyP:{1}]", sourceP.Name, copyP.Name);
            Console.Read();
        }
    }

综上：深拷贝和浅拷贝主要影响引用类型，引用类型浅拷贝，拷贝的是引用，深拷贝，拷贝的是实体，引用类型浅拷贝会改变源

浅拷贝的实现：
System.Object.MemberwiseClone()方法，如果需要可以对其进行封装；
引用类型=也是浅拷贝（引用类型的赋值运算是浅拷贝）
深拷贝的实现：反射（保存最初对象以保证不会相互引用）、反序列化、可视化树 （如果成员简单，可以直接new一个对象，然后各个属性进行赋值）      

 public static T DeepCopyWithReflection<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;
        }

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

//反射的例子

public T Clone<T>(this T controlToClone)
where T : CapImagePanel
{
PropertyInfo[] controlProperties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance);

T instance = Activator.CreateInstance<T>();

foreach (PropertyInfo propInfo in controlProperties)
{
if (propInfo.CanWrite)
{
if (propInfo.Name != "WindowTarget")
propInfo.SetValue(instance, propInfo.GetValue(controlToClone, null), null);
}
}

return instance;
}

至于可视化树，基本就是wpf中新visil等