C#中Object的深拷贝

简介：

C#中System.Object 是所有类类型、结构类型、枚举类型和委托类型的基类。可以说它是类型继承的基础。System.Object包括一个用于创建当前对象实例的一份拷贝的MemberwiseClone的成员方法。

问题描述：

System.Object的MemberwiseClone方法创建一个新对象的浅拷贝，并把当前对象实例的非静态字段拷贝至新对象实例中。通过属性，对象拷贝能够正确执行：如果属性是值类型，那么将按位拷贝数据，如果属性是引用类型，那么将拷贝原始对象的引用，也就是说，克隆对象指向同一个对象实例。这就意味着MemberwiseClone方法并未创建一个对象的深拷贝。

解决方法：

有许多方法实现类对象的深拷贝，下面我将通过示例介绍其中的两种：

　　1.通过序列化、反序列化实现深拷贝

　　2.通过反射实现深拷贝

1、通过序列化、反序列化实现对象的深拷贝

ICloneable接口使得开发者定制实现Clone方法用以创建一个已存对象的深拷贝。通常Object.MemberwiseClone方法帮助开发者创建一份已存对象的拷贝，但是创建的是这个对象的浅拷贝。序列化是指将对象状态存储为二进制流的过程，而反序列化是指将而二进制流转换为原始对象的过程。在.Net中有许多方法可以实现序列化和反序列化，例如二进制序列化、XML序列化、数据约定序列化等等。二进制序列化比XML序列化快速，且二进制序列化使用私有、公有字段，因而二进制序列化是实现序列化和反序列化的不错选择。

通过序列化和反序列化，可以创建对象的深拷贝。需要注意的是，所有类型只有标记为[serializable]特性才能实现序列化和反序列化。

示例程序：

首先创建Employee类，它包含Department类型的属性，Employee类继承ICloneable接口并且实现Clone方法。运用二进制格式化器（binary formater），实现对象的序列化和反序列化为一个新对象。

[Serializable]
    public class Department
    {
        private Int32 _DepartmentID;
        private String _DepartmentName;
        public Int32 DepartmentID 
        {
            get {return _DepartmentID;}
            set { _DepartmentID = value;}
        }
        public String DepartmentName
        {
            get {return _DepartmentName;}
            set {_DepartmentName = value;}
        }
    }
     [Serializable]
    public class Employee : ICloneable
    {
          private Int32 _EmployeeID;
          private String _EmployeeName;
          private Department _Dempartment;
        public Int32 EmployeeID 
        { 
            get {return _EmployeeID;} 
            set {_EmployeeID = value; }
        }
        public String EmployeeName 
        { 
            get { return _EmployeeName; }
            set { _EmployeeName = value;} 
        }
        public Department Department 
        { 
            get{ return _Dempartment; } 
            set{ _Dempartment= value;} 
        }

        public object Clone()
        {
            using (MemoryStream stream = new MemoryStream())
            {
                if (this.GetType().IsSerializable)
                {
                    BinaryFormatter formatter = new BinaryFormatter();
                    formatter.Serialize(stream, this);
                    stream.Position = 0;
                    return formatter.Deserialize(stream);
                }
                return null;
            }
        }
    }

也可以通过扩展方法实现：

public static class ObjectExtension
    {
        public static T CopyObject<T>(this object objSource)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, objSource);
                stream.Position = 0;
                return (T)formatter.Deserialize(stream);
            }
        }
    }

2.通过反射实现深拷贝

反射用于获取运行时对象原始信息。运用System.Reflection名字空间的类可以获取运行史对象时的信息，从已存对象创建类型实例，并访问其属性及调用方法。考虑一下代码，我创建了一个接受Object参数的静态方法，并且返回同样类型的一个新实例。

 public class Utility
    {
        public static object CloneObject(object objSource)
        {
            //Get the type of source object and create a new instance of that type
            Type typeSource = objSource.GetType();
            object objTarget = Activator.CreateInstance(typeSource);

            //Get all the properties of source object type
            PropertyInfo[] propertyInfo = typeSource.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            //Assign all source property to taget object 's properties
            foreach (PropertyInfo property in propertyInfo)
            {
                //Check whether property can be written to 
                if (property.CanWrite)
                {
                    //check whether property type is value type, enum or string type
                    if (property.PropertyType.IsValueType || property.PropertyType.IsEnum || property.PropertyType.Equals(typeof(System.String)))
                    {
                        property.SetValue(objTarget, property.GetValue(objSource, null), null);
                    }
                    //else property type is object/complex types, so need to recursively call this method until the end of the tree is reached
                    else
                    {
                        object objPropertyValue = property.GetValue(objSource, null);
                        if (objPropertyValue == null)
                        {
                            property.SetValue(objTarget, null, null);
                        }
                        else
                        {
                            property.SetValue(objTarget, CloneObject(objPropertyValue), null);
                        }
                    }
                }
            }
            return objTarget;
        }
    }

这也可以通过以下的扩展方法实现。

 public static class ObjectExtension
    {
        public static object CloneObject(this object objSource)
        {
            //Get the type of source object and create a new instance of that type
            Type typeSource = objSource.GetType();
            object objTarget = Activator.CreateInstance(typeSource);

            //Get all the properties of source object type
            PropertyInfo[] propertyInfo = typeSource.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            //Assign all source property to taget object 's properties
            foreach (PropertyInfo property in propertyInfo)
            {
                //Check whether property can be written to 
                if (property.CanWrite)
                {
                    //check whether property type is value type, enum or string type
                    if (property.PropertyType.IsValueType || property.PropertyType.IsEnum || property.PropertyType.Equals(typeof(System.String)))
                    {
                        property.SetValue(objTarget, property.GetValue(objSource, null), null);
                    }
                    //else property type is object/complex types, so need to recursively call this method until the end of the tree is reached
                    else
                    {
                        object objPropertyValue = property.GetValue(objSource, null);
                        if (objPropertyValue == null)
                        {
                            property.SetValue(objTarget, null, null);
                        }
                        else
                        {
                            property.SetValue(objTarget, objPropertyValue.CloneObject(), null);
                        }
                    }
                }
            }
            return objTarget;
        }
    }

以下是示例代码及输出：

class Program
    {
        static void Main(string[] args)
        {
            Employee emp = new Employee();
            emp.EmployeeID = 1000;
            emp.EmployeeName = "Cacotopia";
            emp.Department = new Department { DepartmentID = 1, DepartmentName = "development center" };

            Employee empClone = emp.Clone() as Employee;

            Employee empClone1 = Utility.CloneObject(emp) as Employee;
            Employee empClone2 = emp.CloneObject() as Employee;

            Employee empClone3 = emp.CopyObject<Employee>();
            //now Change Original Object Value
            emp.EmployeeName = "24/7";
            emp.Department.DepartmentName = "Admin";

            //Print origianl as well as clone object properties value.

            Console.WriteLine("Original Employee Name : " + emp.EmployeeName);
            Console.WriteLine("Original Department Name : " + emp.Department.DepartmentName);

            Console.WriteLine("");

            Console.WriteLine("Clone Object Employee Name (Clone Method) : " + empClone.EmployeeName);
            Console.WriteLine("Clone Object Department Name (Clone Method) : " + empClone.Department.DepartmentName);

            Console.WriteLine("");

            Console.WriteLine("Clone Object Employee Name (Static Method) : " + empClone1.EmployeeName);
            Console.WriteLine("Clone Object Department Name (Static Method) : " + empClone1.Department.DepartmentName);

            Console.WriteLine("");

            Console.WriteLine("Clone Object Employee Name (Extension Method) : " + empClone2.EmployeeName);
            Console.WriteLine("Clone Object Department Name (Extension Method) : " + empClone2.Department.DepartmentName);
            Console.WriteLine("press any key to exit...");
            Console.ReadKey();
        }
    }

结束语：

通过序列化和反射我们可以实现对象的深拷贝。运用序列化实现深拷贝的唯一不足之处在于必须将对象标记为Serializable。