C#对象的浅拷贝，深拷贝，序列化反序列化

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› Node.js›Node.js教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

C#中有两种类型变量，一种是值类型变量，一种是引用类型变量,对于值类型变量，深拷贝和前拷贝都是通过赋值操作符号(=)实现，其效果一致，将对象中的值类型的字段拷贝到新的对象中.这个很容易理解。本文重点讨论引用类型变量的拷贝机制和实现。

　　C#中引用类型对象的copy操作有两种：

　　浅拷贝(影子克隆/shallow copy):只复制对象的值类型字段,对象的引用类型,仍属于原来的引用. 深拷贝(深度克隆):不仅复制对象的值类型字段,同时也复制原对象中的对象.就是说完全是新对象产生的.

　　浅拷贝和深拷贝之间的区别：浅拷贝是指将对象中的数值类型的字段拷贝到新的对象中，而对象中的引用型字段则指复制它的一个引用到目标对象。

　　注意：string类型有点特殊，对于浅拷贝，类值类型对象进行处理。

　　浅拷贝的实现

　　使用Object类MemberwiseClone实现

　　MemberwiseClone:创建当前 Object 的浅表副本。

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

　　代码实现如下：

public class Person
　　{
　　public int Age { get; set; }
　　public string Address { get; set; }
　　public Name Name { get; set; }
　　public object Clone()
　　{
　　return this.MemberwiseClone();
　　}
　　}
　　public class Name
　　{
　　public Name(string frisName,string lastName)
　　{
　　FristName = frisName;
　　LastName = lastName;
　　}
　　public string FristName { get; set; }
　　public string LastName { get; set; }
　　}

赋值操作(=)VS使用Object类MemberwiseClone实现

　　对于引用类型的变量，我们有种误解，认为赋值操作就是浅拷贝一种，其实不然，两者有区别。

　　浅拷贝(shallow copy)对于引用类型对象中的值类型字段进行了逐位复制。赋值运算符只是把源对象的引用赋值给目的对象，两者引用同一个对象。浅拷贝后的对象的值类型字段更改不会反映到源对象，而赋值运算后的对象的值类型字段更改会反映到源对象代码实现如下：

public class Person
　　{
　　public int Age { get; set; }
　　public string Address { get; set; }
　　public Name Name { get; set; }
　　}
　　public class Name
　　{
　　public Name(string frisName,string lastName)
　　{
　　FristName = frisName;
　　LastName = lastName;
　　}
　　public string FristName { get; set; }
　　public string LastName { get; set; }
　　}

　　深拷贝实现

　　相对于浅拷贝,是指依照源对象为原型，创建一个新对象，将当前对象的所有字段进行执行逐位复制并支持递归，不管是是值类型还是引用类型，不管是静态字段还是非静态字段。

　　在C#中，我们们有三种方法实现深拷贝

　　一实现ICloneable接口，自定义拷贝功能。

　　ICloneable 接口，支持克隆，即用与现有实例相同的值创建类的新实例。

　　ICloneable 接口包含一个成员 Clone，它用于支持除 MemberwiseClone 所提供的克隆之外的克隆。Clone 既可作为深层副本实现，也可作为浅表副本实现。在深层副本中，所有的对象都是重复的;而在浅表副本中，只有顶级对象是重复的，并且顶级以下的对象包含引用。结果克隆必须与原始实例具有相同的类型或是原始实例的兼容类型。

　　代码实现如下：

　Code
　　public class Person:ICloneable
　　{
　　public int Age { get; set; }
　　public string Address { get; set; }
　　public Name Name { get; set; }
　　public object Clone()
　　{
　　Person tem = new Person();
　　tem.Address = this.Address;
　　tem.Age = this.Age;
　　tem.Name = new Name(this.Name.FristName, this.Name.LastName);
　　return tem;
　　}
　　}
　　public class Name
　　{
　　public Name(string frisName, string lastName)
　　{
　　FristName = frisName;
　　LastName = lastName;
　　}
　　public string FristName { get; set; }
　　public string LastName { get; set; }
　　}

　　大家可以看到,Person类继承了接口ICloneable并手动实现了其Clone方法,这是个简单的类,试想一下,如果你的类有成千上万个引用类型成员(当然太夸张,几十个还是有的)，这是不是份很恐怖的劳力活?

　　序列化/反序列化类实现

　　不知道你有没有注意到DataSet对象,对于他提供的两个方法:

　　DataSet.Clone 方法，复制 DataSet 的结构，包括所有 DataTable 架构、关系和约束。不要复制任何数据。

　　新 DataSet，其架构与当前 DataSet 的架构相同，但是不包含任何数据。注意如果已创建这些类的子类，则复本也将属于相同的子类。

　　DataSet.Copy 方法复制该 DataSet 的结构和数据.

　　新的 DataSet，具有与该 DataSet 相同的结构(表架构、关系和约束)和数据。注意如果已创建这些类的子类，则副本也将属于相同的子类。

　　好像既不是浅拷贝,又不是深拷贝，是不是很失望?但是两个结合起来不是我们要的深拷贝吗?看看DataSet的实现，注意序列化接口：ISerializable

　　序列化是将对象或对象图形转换为线性字节序列，以存储或传输到另一个位置的过程。

　　反序列化是接受存储的信息并利用它重新创建对象的过程。

　　二通过 ISerializable 接口，类可以执行其自己的序列化行为。

　　转换为线性字节序列后并利用其重新创建对象的过程是不是和我们的深拷贝的语意“逐位复制”很相像?

　　代码实现如下：

[Serializable]
　　public class Person : ICloneable
　　{
　　public int Age { get; set; }
　　public string Address { get; set; }
　　public Name Name { get; set; }
　　public object Clone()
　　{
　　using (MemoryStream ms = new MemoryStream(1000))
　　{
　　object CloneObject;
　　BinaryFormatter bf = new BinaryFormatter(null, new StreamingContext(StreamingContextStates.Clone));
　　bf.Serialize(ms, this);
　　ms.Seek(0, SeekOrigin.Begin);
　　// 反序列化至另一个对象(即创建了一个原对象的深表副本)
　　CloneObject = bf.Deserialize(ms);
　　// 关闭流
　　ms.Close();
　　return CloneObject;
　　}
　　}
　　}
　　[Serializable]
　　public class Name
　　{
　　public Name(string frisName, string lastName)
　　{
　　FristName = frisName;
　　LastName = lastName;
　　}
　　public string FristName { get; set; }
　　public string LastName { get; set; }
　　}
　　}

　　注意：通过序列化和反序列化实现深拷贝，其和其字段类型必须标记为可序列化类型，既添加特性(Attribute)[Serializable]。

在使用中，发现schema 生成的类，会自动加上

[System.Xml.Serialization.XmlElementAttribute("RequestListItem")]这个标记，因此可以很好的支持序列化和反序列化，但是在wince的.netcf框架下不支持

BinaryFormatter类，所以需要使用如下代码：即把该对象转换成xml再从新序列化得到新的对象：

View Code

/// <summary>
    /// Data from Framework.
    /// </summary>
    [System.SerializableAttribute()]
    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Xml.Serialization.XmlTypeAttribute(Namespace = HHApi.XMLNAMESPACE_DN)]
    [System.Xml.Serialization.XmlRootAttribute("RequestList", Namespace = HHApi.XMLNAMESPACE_DN, IsNullable = false)]
    public partial class RequestListEntity : RequestList
    {

        public RequestListEntity Clone()
        {
            RequestListEntity entity = new RequestListEntity();
            return entity = RequestListEntity.Parse(this.ToXml());
        }
        /// <summary>
        /// 对象转xml
        /// </summary>
        /// <returns></returns>
        public string ToXml()
        {
            using (var ms = new MemoryStream())
            {
                XmlWriter xw = XmlWriter.Create(ms);
                XmlSerializerNamespaces xsn = new XmlSerializerNamespaces();
                xsn.Add("dn", HHApi.XMLNAMESPACE_DN);
                xsn.Add("xsi", HHApi.XMLNAMESPACE_XSI);

                var serializer = new XmlSerializer(this.GetType());
                serializer.Serialize(xw, this, xsn);
                xw.Flush();
                ms.Seek(0, SeekOrigin.Begin);

                string result = string.Empty;
                using (var sr = new StreamReader(ms, Encoding.UTF8))
                {
                    result = sr.ReadToEnd();
                }
                return result;
            }
        }
        /// <summary>
        /// xml序列化
        /// </summary>
        /// <param name="xmlStr"></param>
        /// <returns></returns>
        public static RequestListEntity Parse(string xmlStr)
        {
            using (StringReader sr = new StringReader(xmlStr))
            {
                XmlReader xr = new XmlTextReader(sr);
                RequestListEntity en = Parse(xr);
                return en;
            }
        }

        public static RequestListEntity Parse(Stream stream)
        {
            XmlReader xr = new XmlTextReader(stream);
            return Parse(xr);
        }

        private static RequestListEntity Parse(XmlReader xr)
        {

            XmlSerializer xs = new XmlSerializer(typeof(RequestListEntity), HHApi.XMLNAMESPACE_DN);

            if (!xs.CanDeserialize(xr)) return null;

            object tmp = xs.Deserialize(xr);
            RequestListEntity result = tmp as RequestListEntity;
            return result;

        }

    }

将xml 序列化为对象方法：

View Code

    public class UtilityHelper
    {
        public static T ObjectDeserialize<T>(string xmlStr)
        {
            using (StringReader sr = new StringReader(xmlStr))
            {
                XmlReader xr = new XmlTextReader(sr);
                return ObjectDeserialize<T>(xr);
            }
        }
               private static T ObjectDeserialize<T>(XmlReader xr)
        {
            XmlSerializer xs = new XmlSerializer(typeof(T), HHApi.XMLNAMESPACE_DN);

            if (!xs.CanDeserialize(xr)) return default(T);

            object tmp = xs.Deserialize(xr);
            T result = (T)tmp;
            return result;
        }
}

xml与类RequestListEntity是scham的对应的

RequestListEntity调用 RequestListEntity result = UtilityHelper.ObjectDeserialize<RequestListEntity>(xml);

如下方法可以将对象反序列化为xml：

View Code

        public static string ObjectXmlSerializer<T>(T entity)
        {
            using (var ms = new MemoryStream())
            {
                XmlWriter xw = XmlWriter.Create(ms);
                XmlSerializerNamespaces xsn = new XmlSerializerNamespaces();
                xsn.Add("dn", HHApi.XMLNAMESPACE_DN);
                xsn.Add("xsi", HHApi.XMLNAMESPACE_XSI);

                var serializer = new XmlSerializer(entity.GetType());
                serializer.Serialize(xw, entity, xsn);
                xw.Flush();
                ms.Seek(0, SeekOrigin.Begin);

                using (var sr = new StreamReader(ms, Encoding.UTF8))
                {
                    return sr.ReadToEnd();
                }
            }
        }

　　通过反射实现

　　通过序列化/反序列化方式我们能比较流畅的实现深拷贝，但是涉及到IO操作，托管的的环境中，IO操作比较消耗资源。能不能有更优雅的解决方案。CreateInstance，对，利用反射特性。这个方法大家可以参考这篇博客：http://rubenhak.com/?p=70 文章反射类的Attribute，利用Activator.CreateInstance New一个类出来(有点像DataSet.Clone先获得架构)，然后利用PropertyInfo的SetValue和GetValue方法，遍历的方式进行值填充。

　　代码实现如下：

　public class Person
　　{
　　private List _friends = new List();
　　public string Firstname { get; set; }
　　public string Lastname { get; set; }
　　[Cloneable(CloneableState.Exclude)]
　　[Cloneable(CloneableState.Include, "Friends")]
　　public List Friends { get { return _friends; } }
　　[Cloneable(CloneableState.Exclude)]
　　public PersonManager Manager { get; set; }
　　}