【Stack Overflow -- 原创加工、原创整理、生产实战】-- 深度复制

索引：

目录索引

一、说明

　　1.本程序的核心代码不是我原创的，是我在Stack Overflow上搜集后加工出来的，原作者已忘记了~

　　2.这段程序是我在上海携程(2014年左右)上班时整理并在生产环境应用的，先后经历了三家公司项目中使用，稳定可靠，放心使用

　　3.扩展方法部分可根据自己实际需要修改，流可以搞个static，pool，也可以每次 new，根据项目性能需求自己定制就行了

二、代码

　　代码如下：

　　核心类  NonSerialiazableTypeSurrogateSelector ：　　

    /// <summary>
    /// 深度复制 / Surrogate
    /// </summary>
    public class NonSerialiazableTypeSurrogateSelector : ISerializationSurrogate, ISurrogateSelector
    {
        /// <summary>
        /// _nextSelector
        /// </summary>
        ISurrogateSelector _nextSelector;

        #region ISerializationSurrogate / 实现
        /// <summary>
        /// GetObjectData
        /// </summary>
        public void GetObjectData(object obj, SerializationInfo info, StreamingContext context)
        {
            FieldInfo[] fieldInfos = obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            foreach (var fi in fieldInfos)
            {
                if (IsKnownType(fi.FieldType))
                {
                    info.AddValue(fi.Name, fi.GetValue(obj));
                }
                else if (fi.FieldType.IsClass)
                {
                    info.AddValue(fi.Name, fi.GetValue(obj));
                }
            }
        }

        /// <summary>
        /// SetObjectData
        /// </summary>
        public object SetObjectData(object obj, SerializationInfo info, StreamingContext context, ISurrogateSelector selector)
        {
            FieldInfo[] fieldInfos = obj.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            foreach (var fi in fieldInfos)
            {
                if (IsKnownType(fi.FieldType))
                {
                    if (IsNullableType(fi.FieldType))
                    {
                        Type argumentValueForTheNullableType = GetFirstArgumentOfGenericType(fi.FieldType);
                        fi.SetValue(obj, info.GetValue(fi.Name, argumentValueForTheNullableType));
                    }
                    else
                    {
                        fi.SetValue(obj, info.GetValue(fi.Name, fi.FieldType));
                    }
                }
                else if (fi.FieldType.IsClass)
                {
                    fi.SetValue(obj, info.GetValue(fi.Name, fi.FieldType));
                }
            }
            return obj;
        }
        #endregion

        #region ISurrogateSelector / 实现
        /// <summary>
        /// ChainSelector
        /// </summary>
        public void ChainSelector(ISurrogateSelector selector)
        {
            this._nextSelector = selector;
        }

        /// <summary>
        /// GetNextSelector
        /// </summary>
        public ISurrogateSelector GetNextSelector()
        {
            return _nextSelector;
        }

        /// <summary>
        /// GetSurrogate
        /// </summary>
        public ISerializationSurrogate GetSurrogate(Type type, StreamingContext context, out ISurrogateSelector selector)
        {
            if (IsKnownType(type))
            {
                selector = null;
                return null;
            }
            else if (type.IsClass || type.IsValueType)
            {
                selector = this;
                return this;
            }
            else
            {
                selector = null;
                return null;
            }
        }
        #endregion

        #region 私有方法
        /// <summary>
        /// 是否为已知类型 / String,Primitive,Serializable
        /// </summary>
        private bool IsKnownType(Type type)
        {
            return type == typeof(string) || type.IsPrimitive || type.IsSerializable;
        }

        /// <summary>
        /// 是否为可空类型
        /// </summary>
        private bool IsNullableType(Type type)
        {
            if (type.IsGenericType)
            {
                return type.GetGenericTypeDefinition() == typeof(Nullable<>);
            }
            return false;
        }

        /// <summary>
        /// GetFirstArgumentOfGenericType
        /// </summary>
        private Type GetFirstArgumentOfGenericType(Type type)
        {
            return type.GetGenericArguments()[0];
        }
        #endregion
    }

　　扩展类 ObjectMethodExtensions ：

    public static class ObjectMethodExtensions
    {
        /// <summary>
        /// 深度复制 (值类型/包装类型/引用类型/序列化/非序列化/标识序列化/非标识序列化,皆可深度复制)
        /// </summary>
        public static T DeepClone<T>(this T obj)
        {
            var result = default(T);
            try
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.SurrogateSelector = new SurrogateSelector();
                formatter.SurrogateSelector.ChainSelector(new NonSerialiazableTypeSurrogateSelector());
                var ms = new MemoryStream();
                formatter.Serialize(ms, obj);
                ms.Position = 0;
                result = (T)formatter.Deserialize(ms);
            }
            catch (Exception ex)
            {
                throw new Exception("方法:DeepClone<T>(this T obj)出错.", ex);
            }
            return result;
        }
    }

　　

三、.Net 内置类 与 代码说明

　　BinaryFormatter：

　　以二进制格式序列化和反序列化对象或连接对象的整个图形。

　　https://msdn.microsoft.com/zh-cn/library/system.runtime.serialization.formatters.binary.binaryformatter.aspx 

　　SurrogateSelector：

　　可帮助您选择要委派序列化或反序列化到的进程的序列化代理项中的格式化程序。

　　https://msdn.microsoft.com/zh-cn/library/system.runtime.serialization.surrogateselector(v=vs.110).aspx

　　MemoryStream ：

　　创建一个流，其后备存储为内存。

　　https://msdn.microsoft.com/zh-cn/library/system.io.memorystream.aspx

　　ISerializationSurrogate ：

　　Implements a serialization surrogate selector that allows one object to perform serialization and deserialization of another.

　　（自己翻译~）

　　https://msdn.microsoft.com/en-us/library/system.runtime.serialization.iserializationsurrogate(v=vs.110).aspx

　　ISurrogateSelector：

　　指示序列化代理项选择器类。

　　https://msdn.microsoft.com/zh-cn/library/system.runtime.serialization.isurrogateselector

四、使用方式

　　直接在要深度复制的实例对象后.DeepClone()即可，如：

　　当然如果你不嫌麻烦，也可以指定类型，如：

　　使用，是就是这样使用就行了，其中 扩展方法部分 可根据使用的频次做性能优化~

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　蒙

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　2017-07-11 19:07  周二