对象的深拷贝--反射

继续上节的对象深拷贝，上节讲了通过序列化和反序列化来实现深度拷贝，这一节我们来讲述一下第二种深度拷贝的方法，反射。通过反射来实现深度拷贝。

反射主要是在运行时获取对象的元信息，System.Reflection命名空间允许我们在程序运行时来获取对象的信息、创建已存在类的实例，也能够获取对象的属性和执行对象的方法。

下面我创建一个静态的方法来接收任何类型的对象，并返回一个新对象的引用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;

namespace ReflectionCopy
{
    public class Utility
    {
        public static object CloneObject(object objsource)
        {
            //第一步获取原对象的类型，并创建一个同类型的对象
            Type typesource = objsource.GetType();

            object objTarget = Activator.CreateInstance(typesource);

            //第二步获取原对象的所有属性

            PropertyInfo[] propertyinfo = typesource.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            //第三步将原对象的所有属性赋给目标对象

            foreach (PropertyInfo item in propertyinfo)
            {
                if (item.CanWrite)
                {

                    //值类型，字符串，枚举类型直接把值复制，不存在浅拷贝  虽然字符串是引用类型，但是字符串是不可变的，每次都是创建新的字符串对象，所以不存在浅拷贝
                    if (item.PropertyType.IsEnum || item.PropertyType.IsValueType || item.PropertyType.Equals(typeof(System.String)))
                    {

                        item.SetValue(objTarget, item.GetValue(objsource, null), null);
                    }
                    else
                    {
                        object objpropertyvalue = item.GetValue(objsource, null);

                        item.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;
    }
}

现在我们调用该方法，看看结果：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ReflectionCopy
{
    class Program
    {
        static void Main(string[] args)
        {
            Employee emp = new Employee();

            emp.EmployeeId = 1000;
            emp.EmployeeName = "IT少年";
            emp.Department = new Department { DepartmentId = 1, DepartmentName = "Examination" };

            Employee empclone = emp.CloneObject() as Employee;

            emp.EmployeeId = 1003;
            emp.EmployeeName = "TTT";
            emp.Department.DepartmentId = 3;
            emp.Department.DepartmentName = "admin";
            Console.WriteLine("----emp原始对象------");
            Console.WriteLine("拷贝前DepartmentName应该是admin:  " + emp.Department.DepartmentName);
            Console.WriteLine("拷贝前DepartmentID应该是3:  " + emp.Department.DepartmentId);

            Console.WriteLine("----empclone拷贝对象------");
            Console.WriteLine("拷贝DepartmentName应该是Examination：    " + empclone.Department.DepartmentName);
            Console.WriteLine("拷贝DepartmentID应该是1：     " + empclone.Department.DepartmentId);
            Console.ReadKey();
        }

    }
}

运行结果可以看出和序列化和反序列化深拷贝一样的。