DeepClonner：快速、简单、有效的NuGet包解决克隆问题

看完所有的答案后，我很惊讶没有人提到这个优秀的包：

DeepCloner GitHub项目

DeepCloner NuGet包

详细介绍一下它的README，下面是我们选择它的原因：

它可以深层或浅层复制在深度克隆中，维护所有对象图。在运行时使用代码生成，因为结果克隆非常快由内部结构复制的对象，未调用方法或构造函数您不需要以某种方式标记类（如Serializable属性或实现接口）无需为克隆指定对象类型。对象可以被强制转换为接口或抽象对象（例如，您可以将int数组克隆为抽象array或IEnumerable；甚至可以克隆null而不出错）克隆的对象没有任何能力确定他是克隆的（除非使用非常特定的方法）

用法：

var deepClone = new { Id = 1, Name = "222" }.DeepClone();
var shallowClone = new { Id = 1, Name = "222" }.ShallowClone();

性能：

README包含各种克隆库和方法的性能比较：DeepCloner性能。

要求：

.NET 4.0或更高版本或.NET Standard 1.3（.NET Core）需要完全信任权限集或反射权限（MemberAccess）

我已经创建了一个可接受答案的版本，该版本同时适用于“[Serializable]”和“[DataContract]”。我写它已经有一段时间了，但如果我没有记错，[DataContract]需要一个不同的序列化程序。

需要System、System.IO、System.Runtime.Serialization、System.Runtime.Serialization.Formatters.Binary、System.Xml；

public static class ObjectCopier
{

    /// <summary>
    /// Perform a deep Copy of an object that is marked with '[Serializable]' or '[DataContract]'
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>The copied object.</returns>
    public static T Clone<T>(T source)
    {
        if (typeof(T).IsSerializable == true)
        {
            return CloneUsingSerializable<T>(source);
        }

        if (IsDataContract(typeof(T)) == true)
        {
            return CloneUsingDataContracts<T>(source);
        }

        throw new ArgumentException("The type must be Serializable or use DataContracts.", "source");
    }


    /// <summary>
    /// Perform a deep Copy of an object that is marked with '[Serializable]'
    /// </summary>
    /// <remarks>
    /// Found on http://stackoverflow.com/questions/78536/cloning-objects-in-c-sharp
    /// Uses code found on CodeProject, which allows free use in third party apps
    /// - http://www.codeproject.com/KB/tips/SerializedObjectCloner.aspx
    /// </remarks>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>The copied object.</returns>
    public static T CloneUsingSerializable<T>(T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("The type must be serializable.", "source");
        }

        // Don't serialize a null object, simply return the default for that object
        if (Object.ReferenceEquals(source, null))
        {
            return default(T);
        }

        IFormatter formatter = new BinaryFormatter();
        Stream stream = new MemoryStream();
        using (stream)
        {
            formatter.Serialize(stream, source);
            stream.Seek(0, SeekOrigin.Begin);
            return (T)formatter.Deserialize(stream);
        }
    }


    /// <summary>
    /// Perform a deep Copy of an object that is marked with '[DataContract]'
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>The copied object.</returns>
    public static T CloneUsingDataContracts<T>(T source)
    {
        if (IsDataContract(typeof(T)) == false)
        {
            throw new ArgumentException("The type must be a data contract.", "source");
        }

        // ** Don't serialize a null object, simply return the default for that object
        if (Object.ReferenceEquals(source, null))
        {
            return default(T);
        }

        DataContractSerializer dcs = new DataContractSerializer(typeof(T));
        using(Stream stream = new MemoryStream())
        {
            using (XmlDictionaryWriter writer = XmlDictionaryWriter.CreateBinaryWriter(stream))
            {
                dcs.WriteObject(writer, source);
                writer.Flush();
                stream.Seek(0, SeekOrigin.Begin);
                using (XmlDictionaryReader reader = XmlDictionaryReader.CreateBinaryReader(stream, XmlDictionaryReaderQuotas.Max))
                {
                    return (T)dcs.ReadObject(reader);
                }
            }
        }
    }


    /// <summary>
    /// Helper function to check if a class is a [DataContract]
    /// </summary>
    /// <param name="type">The type of the object to check.</param>
    /// <returns>Boolean flag indicating if the class is a DataContract (true) or not (false) </returns>
    public static bool IsDataContract(Type type)
    {
        object[] attributes = type.GetCustomAttributes(typeof(DataContractAttribute), false);
        return attributes.Length == 1;
    }

} 

如果您已经在使用第三方应用程序（如ValueInjector或Automapper），可以执行以下操作：

MyObject oldObj; // The existing object to clone

MyObject newObj = new MyObject();
newObj.InjectFrom(oldObj); // Using ValueInjecter syntax

使用此方法，您不必在对象上实现ISerializable或ICloneable。这在MVC/MVVM模式中很常见，因此已经创建了这样的简单工具。

请参阅GitHub上的ValueInjecter深度克隆示例。

这个方法为我解决了问题：

private static MyObj DeepCopy(MyObj source)
        {

            var DeserializeSettings = new JsonSerializerSettings { ObjectCreationHandling = ObjectCreationHandling.Replace };

            return JsonConvert.DeserializeObject<MyObj >(JsonConvert.SerializeObject(source), DeserializeSettings);

        }

这样使用：MyObj a=DeepCopy（b）；

简单的答案是从ICloneable接口继承，然后实现.clone函数。克隆应该按成员进行复制，并对任何需要它的成员执行深度复制，然后返回结果对象。这是一个递归操作（它要求您要克隆的类的所有成员都是值类型或实现ICloneable，并且它们的成员是值类型或者实现IClonea，依此类推）。

有关使用ICloneable克隆的详细说明，请参阅本文。

长篇大论的答案是“视情况而定”。正如其他人所提到的，ICloneable不受泛型支持，需要对循环类引用进行特殊考虑，并且实际上被一些人视为.NET Framework中的“错误”。序列化方法取决于对象是否可序列化，而这些对象可能不可序列化，并且您可能无法控制。对于哪种做法是“最佳”做法，社会上仍有很多争论。事实上，没有一个解决方案是适用于所有情况的一刀切的最佳实践，就像ICloneable最初被解释的那样。

请参阅本开发者角文章，了解更多选项（归功于Ian）。

基于@craastad的答案，对于派生类。

在最初的答案中，如果调用者在基类对象上调用DeepCopy，则克隆的对象属于基类。但下面的代码将返回派生类。

using Newtonsoft.Json;

public static T DeepCopy<T>(this T source)
{
    return (T)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(source), source.GetType());
}