深度克隆对象

Question

我想做类似的事情：

MyObject myObj = GetMyObj(); // Create and fill a new object
MyObject newObj = myObj.Clone();

然后对原 object 中未反映的新 object 进行更改。

我并不经常需要这个功能，所以当有必要时，我求助于创建一个新的 object 然后单独复制每个属性，但它总是让我觉得有更好或更优雅的处理方式情况。

如何克隆或深度复制 object 以便可以修改克隆的 object 而不会在原始 object 中反映任何更改？

Answer 1

一种方法是实现ICloneable接口（ 这里描述，所以我不会反驳），这是我不久前在The Code Project上找到的一个很好的深度克隆对象复制器，并将其合并到我们的代码中。 正如其他地方提到的，它要求您的对象是可序列化的。

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// Reference Article http://www.codeproject.com/KB/tips/SerializedObjectCloner.aspx
/// Provides a method for performing a deep copy of an object.
/// Binary Serialization is used to perform the copy.
/// </summary>
public static class ObjectCopier
{
    /// <summary>
    /// Perform a deep copy of the object via serialization.
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>A deep copy of the object.</returns>
    public static T Clone<T>(T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("The type must be serializable.", nameof(source));
        }

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

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

这个想法是它序列化您的对象，然后将其反序列化为一个新对象。 好处是当对象变得太复杂时，您不必担心克隆所有内容。

如果您更喜欢使用 C# 3.0 的新扩展方法，请将方法更改为具有以下签名：

public static T Clone<T>(this T source)
{
   // ...
}

现在方法调用简单地变成objectBeingCloned.Clone(); .

编辑（2015 年 1 月 10 日）我想我会重新审视这个，提到我最近开始使用（Newtonsoft）Json 来做到这一点，它应该更轻，并且避免了 [Serializable] 标签的开销。 （ NB @atconway 在评论中指出私有成员不是使用 JSON 方法克隆的）

/// <summary>
/// Perform a deep Copy of the object, using Json as a serialization method. NOTE: Private members are not cloned using this method.
/// </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 CloneJson<T>(this T source)
{            
    // Don't serialize a null object, simply return the default for that object
    if (ReferenceEquals(source, null)) return default;

    // initialize inner objects individually
    // for example in default constructor some list property initialized with some values,
    // but in 'source' these items are cleaned -
    // without ObjectCreationHandling.Replace default constructor values will be added to result
    var deserializeSettings = new JsonSerializerSettings {ObjectCreationHandling = ObjectCreationHandling.Replace};

    return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source), deserializeSettings);
}

Answer 2

我想要一个克隆器，用于非常简单的对象，主要是基元和列表。 如果您的对象是开箱即用的 JSON 可序列化，那么此方法将起作用。 这不需要修改或实现克隆类上的接口，只需要像 JSON.NET 这样的 JSON 序列化程序。

public static T Clone<T>(T source)
{
    var serialized = JsonConvert.SerializeObject(source);
    return JsonConvert.DeserializeObject<T>(serialized);
}

此外，您可以使用此扩展方法

public static class SystemExtension
{
    public static T Clone<T>(this T source)
    {
        var serialized = JsonConvert.SerializeObject(source);
        return JsonConvert.DeserializeObject<T>(serialized);
    }
}

Answer 3

不使用的原因ICloneable是不是因为它没有一个通用的接口。 不使用它的原因是因为它含糊不清。 不清楚你得到的是浅拷贝还是深拷贝； 这取决于实施者。

是的， MemberwiseClone是一个浅拷贝，但MemberwiseClone的反面不是Clone ； 它可能是DeepClone ，它不存在。 当您通过其 ICloneable 接口使用对象时，您无法知道底层对象执行哪种克隆。 （并且 XML 注释不会说清楚，因为您将获得接口注释而不是对象的 Clone 方法上的注释。）

我通常做的只是制作一个完全符合我要求的Copy方法。

Answer 4

在大量阅读此处链接的许多选项以及此问题的可能解决方案之后，我相信所有选项都在Ian P的链接中得到了很好的总结（所有其他选项都是这些选项的变体），最佳解决方案由Pedro77关于问题评论的链接。

因此，我将在此处复制这 2 个参考文献的相关部分。 这样我们就可以有：

在 C 语言中克隆对象的最佳方法！

首先，这些都是我们的选择：

• 手动使用ICloneable ，这是浅的而不是类型安全的
• MemberwiseClone ，它使用 ICloneable
• 使用Activator.CreateInstance和递归 MemberwiseClone 进行反射
• 序列化，正如johnc 的首选答案所指出的
• 中级语言，我不知道它是如何工作的
• 扩展方法，例如Havard Straden 的这个自定义克隆框架
• 表达式树

文章 Fast Deep Copy by Expression Trees也有通过 Serialization、Reflection 和 Expression Trees 进行克隆的性能比较。

为什么我选择ICloneable （即手动）

Venkat Subramaniam 先生（此处为冗余链接）详细解释了原因。

他的所有文章都围绕一个尝试适用于大多数情况的示例，使用 3 个对象： Person 、 Brain和City 。 我们要克隆一个人，这个人有自己的大脑，但同一座城市。 您可以想象上述任何其他方法可以带来的所有问题或阅读文章。

这是我对他的结论稍加修改的版本：

通过指定New后跟类名来复制对象通常会导致代码不可扩展。 使用克隆，原型模式的应用，是实现这一点的更好方法。 但是，使用 C#（和 Java）中提供的 clone 也可能存在很大问题。 最好提供一个受保护的（非公共）复制构造函数并从 clone 方法调用它。 这使我们能够将创建对象的任务委托给类本身的实例，从而提供可扩展性，并且使用受保护的复制构造函数安全地创建对象。

希望这个实现可以让事情变得清晰：

public class Person : ICloneable
{
    private final Brain brain; // brain is final since I do not want 
                // any transplant on it once created!
    private int age;
    public Person(Brain aBrain, int theAge)
    {
        brain = aBrain; 
        age = theAge;
    }
    protected Person(Person another)
    {
        Brain refBrain = null;
        try
        {
            refBrain = (Brain) another.brain.clone();
            // You can set the brain in the constructor
        }
        catch(CloneNotSupportedException e) {}
        brain = refBrain;
        age = another.age;
    }
    public String toString()
    {
        return "This is person with " + brain;
        // Not meant to sound rude as it reads!
    }
    public Object clone()
    {
        return new Person(this);
    }
    …
}

现在考虑从 Person 派生一个类。

public class SkilledPerson extends Person
{
    private String theSkills;
    public SkilledPerson(Brain aBrain, int theAge, String skills)
    {
        super(aBrain, theAge);
        theSkills = skills;
    }
    protected SkilledPerson(SkilledPerson another)
    {
        super(another);
        theSkills = another.theSkills;
    }

    public Object clone()
    {
        return new SkilledPerson(this);
    }
    public String toString()
    {
        return "SkilledPerson: " + super.toString();
    }
}

您可以尝试运行以下代码：

public class User
{
    public static void play(Person p)
    {
        Person another = (Person) p.clone();
        System.out.println(p);
        System.out.println(another);
    }
    public static void main(String[] args)
    {
        Person sam = new Person(new Brain(), 1);
        play(sam);
        SkilledPerson bob = new SkilledPerson(new SmarterBrain(), 1, "Writer");
        play(bob);
    }
}

产生的输出将是：

This is person with Brain@1fcc69
This is person with Brain@253498
SkilledPerson: This is person with SmarterBrain@1fef6f
SkilledPerson: This is person with SmarterBrain@209f4e

请注意，如果我们保持对对象数量的计数，则此处实现的克隆将保持对对象数量的正确计数。

Answer 5

我更喜欢复制构造函数而不是克隆。 意图更加明确。

Answer 6

复制所有公共属性的简单扩展方法。 适用于任何对象，并且不需要类为[Serializable] 。 可以扩展为其他访问级别。

public static void CopyTo( this object S, object T )
{
    foreach( var pS in S.GetType().GetProperties() )
    {
        foreach( var pT in T.GetType().GetProperties() )
        {
            if( pT.Name != pS.Name ) continue;
            ( pT.GetSetMethod() ).Invoke( T, new object[] 
            { pS.GetGetMethod().Invoke( S, null ) } );
        }
    };
}

Answer 7

如果您已经使用像一个第三方应用程序ValueInjecter或Automapper ，你可以这样做：

MyObject oldObj; // The existing object to clone

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

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

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

Answer 8

我刚刚创建了CloneExtensions库项目。 它使用表达式树运行时代码编译生成的简单赋值操作执行快速、深度克隆。

如何使用它？

不是用字段和属性之间的赋值语气编写自己的Clone或Copy方法，而是让程序自己做，使用表达式树。 标记为扩展方法的GetClone<T>()方法允许您在实例上简单地调用它：

var newInstance = source.GetClone();

您可以使用CloningFlags枚举选择应该从source复制到newInstance CloningFlags ：

var newInstance 
    = source.GetClone(CloningFlags.Properties | CloningFlags.CollectionItems);

什么可以克隆？

• 原始类型（int、uint、byte、double、char 等）、已知的不可变类型（DateTime、TimeSpan、String）和委托（包括 Action、Func 等）
• 可空
• T[] 数组
• 自定义类和结构，包括通用类和结构。

以下类/结构成员在内部克隆：

• 公共字段的值，而不是只读字段
• 具有 get 和 set 访问器的公共属性的值
• 实现 ICollection 的类型的集合项

它有多快？

该解决方案比反射更快，因为在第一次为给定类型T使用GetClone<T>之前，必须只收集一次成员信息。

当您克隆多个相同类型T实例时，它也比基于序列化的解决方案更快。

和更多...

在文档中阅读有关生成的表达式的更多信息。

List<int>示例表达式调试列表：

.Lambda #Lambda1<System.Func`4[System.Collections.Generic.List`1[System.Int32],CloneExtensions.CloningFlags,System.Collections.Generic.IDictionary`2[System.Type,System.Func`2[System.Object,System.Object]],System.Collections.Generic.List`1[System.Int32]]>(
    System.Collections.Generic.List`1[System.Int32] $source,
    CloneExtensions.CloningFlags $flags,
    System.Collections.Generic.IDictionary`2[System.Type,System.Func`2[System.Object,System.Object]] $initializers) {
    .Block(System.Collections.Generic.List`1[System.Int32] $target) {
        .If ($source == null) {
            .Return #Label1 { null }
        } .Else {
            .Default(System.Void)
        };
        .If (
            .Call $initializers.ContainsKey(.Constant<System.Type>(System.Collections.Generic.List`1[System.Int32]))
        ) {
            $target = (System.Collections.Generic.List`1[System.Int32]).Call ($initializers.Item[.Constant<System.Type>(System.Collections.Generic.List`1[System.Int32])]
            ).Invoke((System.Object)$source)
        } .Else {
            $target = .New System.Collections.Generic.List`1[System.Int32]()
        };
        .If (
            ((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(Fields)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(Fields)
        ) {
            .Default(System.Void)
        } .Else {
            .Default(System.Void)
        };
        .If (
            ((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(Properties)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(Properties)
        ) {
            .Block() {
                $target.Capacity = .Call CloneExtensions.CloneFactory.GetClone(
                    $source.Capacity,
                    $flags,
                    $initializers)
            }
        } .Else {
            .Default(System.Void)
        };
        .If (
            ((System.Byte)$flags & (System.Byte).Constant<CloneExtensions.CloningFlags>(CollectionItems)) == (System.Byte).Constant<CloneExtensions.CloningFlags>(CollectionItems)
        ) {
            .Block(
                System.Collections.Generic.IEnumerator`1[System.Int32] $var1,
                System.Collections.Generic.ICollection`1[System.Int32] $var2) {
                $var1 = (System.Collections.Generic.IEnumerator`1[System.Int32]).Call $source.GetEnumerator();
                $var2 = (System.Collections.Generic.ICollection`1[System.Int32])$target;
                .Loop  {
                    .If (.Call $var1.MoveNext() != False) {
                        .Call $var2.Add(.Call CloneExtensions.CloneFactory.GetClone(
                                $var1.Current,
                                $flags,


                         $initializers))
                } .Else {
                    .Break #Label2 { }
                }
            }
            .LabelTarget #Label2:
        }
    } .Else {
        .Default(System.Void)
    };
    .Label
        $target
    .LabelTarget #Label1:
}

}

什么与以下 c# 代码具有相同的含义：

(source, flags, initializers) =>
{
    if(source == null)
        return null;

    if(initializers.ContainsKey(typeof(List<int>))
        target = (List<int>)initializers[typeof(List<int>)].Invoke((object)source);
    else
        target = new List<int>();

    if((flags & CloningFlags.Properties) == CloningFlags.Properties)
    {
        target.Capacity = target.Capacity.GetClone(flags, initializers);
    }

    if((flags & CloningFlags.CollectionItems) == CloningFlags.CollectionItems)
    {
        var targetCollection = (ICollection<int>)target;
        foreach(var item in (ICollection<int>)source)
        {
            targetCollection.Add(item.Clone(flags, initializers));
        }
    }

    return target;
}

是不是很像您为List<int>编写自己的Clone方法？

Answer 9

好吧，我在 Silverlight 中使用 ICloneable 时遇到了问题，但我喜欢序列化的想法，我可以序列化 XML，所以我这样做了：

static public class SerializeHelper
{
    //Michael White, Holly Springs Consulting, 2009
    //michael@hollyspringsconsulting.com
    public static T DeserializeXML<T>(string xmlData) where T:new()
    {
        if (string.IsNullOrEmpty(xmlData))
            return default(T);

        TextReader tr = new StringReader(xmlData);
        T DocItms = new T();
        XmlSerializer xms = new XmlSerializer(DocItms.GetType());
        DocItms = (T)xms.Deserialize(tr);

        return DocItms == null ? default(T) : DocItms;
    }

    public static string SeralizeObjectToXML<T>(T xmlObject)
    {
        StringBuilder sbTR = new StringBuilder();
        XmlSerializer xmsTR = new XmlSerializer(xmlObject.GetType());
        XmlWriterSettings xwsTR = new XmlWriterSettings();

        XmlWriter xmwTR = XmlWriter.Create(sbTR, xwsTR);
        xmsTR.Serialize(xmwTR,xmlObject);

        return sbTR.ToString();
    }

    public static T CloneObject<T>(T objClone) where T:new()
    {
        string GetString = SerializeHelper.SeralizeObjectToXML<T>(objClone);
        return SerializeHelper.DeserializeXML<T>(GetString);
    }
}

Answer 10

最好是实现一个扩展方法，如

public static T DeepClone<T>(this T originalObject)
{ /* the cloning code */ }

然后在解决方案中的任何地方使用它

var copy = anyObject.DeepClone();

我们可以有以下三种实现：

1. 通过序列化（最短的代码）
2. 通过反射-快 5 倍
3. 通过表达式树-快 20 倍

所有链接的方法都运行良好并经过深入测试。

Answer 11

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

有关使用 ICloneable 进行克隆的更详细说明，请查看这篇文章。

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

有关更多选项，请参阅此开发人员角文章（归功于 Ian）。

Answer 12

1. 基本上你需要实现ICloneable接口，然后实现对象结构复制。
2. 如果它是所有成员的深层副本，则您需要确保（与您选择的解决方案无关）所有子项也是可克隆的。
3. 有时您需要注意此过程中的一些限制，例如，如果您复制 ORM 对象，大多数框架只允许将一个对象附加到会话，并且您不得复制此对象，或者如果可能您需要注意关于这些对象的会话附加。

干杯。

Answer 13

编辑：项目已停止

如果您想真正克隆到未知类型，您可以查看fastclone 。

这是基于表达式的克隆比二进制序列化快 10 倍并保持完整的对象图完整性。

这意味着：如果您多次引用层次结构中的同一个对象，则克隆也将引用单个实例。

不需要对被克隆的对象进行接口、属性或任何其他修改。

Answer 14

DeepCloner：解决克隆的快速、简单、有效的 NuGet 包

阅读完所有答案后，我很惊讶没有人提到这个出色的软件包：

DeepCloner GitHub 项目

DeepCloner NuGet 包

详细介绍一下它的 README，以下是我们在工作中选择它的原因：

• 可以深拷贝也可以浅拷贝
• 在深度克隆中，所有对象图都得到维护。
• 在运行时使用代码生成，因为结果克隆非常快
• 由内部结构复制的对象，没有调用方法或构造函数
• 您不需要以某种方式标记类（例如 Serializable-attribute 或实现接口）
• 不需要为克隆指定对象类型。 对象可以转换为接口或抽象对象（例如，您可以将整数数组克隆为抽象数组或 IEnumerable；甚至可以克隆 null，而不会出现任何错误）
• 克隆的对象没有任何能力确定他是克隆的（除非有非常具体的方法）

用法：

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

表现：

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

要求：

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

Answer 15

保持简单并像其他人提到的那样使用AutoMapper ，它是一个简单的小库，可以将一个对象映射到另一个对象......要将一个对象复制到另一个具有相同类型的对象，您只需要三行代码：

MyType source = new MyType();
Mapper.CreateMap<MyType, MyType>();
MyType target = Mapper.Map<MyType, MyType>(source);

目标对象现在是源对象的副本。 不够简单？ 创建一个扩展方法以在解决方案中的任何地方使用：

public static T Copy<T>(this T source)
{
    T copy = default(T);
    Mapper.CreateMap<T, T>();
    copy = Mapper.Map<T, T>(source);
    return copy;
}

扩展方法可以如下使用：

MyType copy = source.Copy();

Answer 16

我想出了这个来克服.NET必须手动深度复制 List<T> 的缺点。

我用这个：

static public IEnumerable<SpotPlacement> CloneList(List<SpotPlacement> spotPlacements)
{
    foreach (SpotPlacement sp in spotPlacements)
    {
        yield return (SpotPlacement)sp.Clone();
    }
}

在另一个地方：

public object Clone()
{
    OrderItem newOrderItem = new OrderItem();
    ...
    newOrderItem._exactPlacements.AddRange(SpotPlacement.CloneList(_exactPlacements));
    ...
    return newOrderItem;
}

我试图提出这样做​​的 oneliner，但这是不可能的，因为 yield 不能在匿名方法块内工作。

更好的是，使用通用 List<T> 克隆器：

class Utility<T> where T : ICloneable
{
    static public IEnumerable<T> CloneList(List<T> tl)
    {
        foreach (T t in tl)
        {
            yield return (T)t.Clone();
        }
    }
}

Answer 17

通常，您实现 ICloneable 接口并自己实现 Clone。 C# 对象有一个内置的 MemberwiseClone 方法，该方法执行浅拷贝，可以帮助您处理所有基元。

对于深拷贝，它无法知道如何自动执行。

Answer 18

问：为什么我会选择这个答案？

• 如果您想要 .NET 能够达到的最快速度，请选择此答案。
• 如果您想要一种非常非常简单的克隆方法，请忽略此答案。

换句话说，除非您有需要修复的性能瓶颈，否则请选择另一个答案，并且您可以使用 profiler 证明这一点。

比其他方法快 10 倍

以下执行深度克隆的方法是：

• 比任何涉及序列化/反序列化的东西快 10 倍；
• 非常接近 .NET 所能达到的理论最大速度。

而且方法...

为了最终的速度，您可以使用Nested MemberwiseClone 进行深度复制。 它的速度几乎与复制值结构相同，并且比 (a) 反射或 (b) 序列化快得多（如本页其他答案所述）。

请注意，如果您将Nested MemberwiseClone 用于深层复制，则必须为类中的每个嵌套级别手动实现 ShallowCopy，以及调用所有上述 ShallowCopy 方法以创建完整克隆的 DeepCopy。 这很简单：总共只有几行，请参阅下面的演示代码。

以下是显示 100,000 个克隆的相对性能差异的代码输出：

• 嵌套结构上的嵌套 MemberwiseClone 为 1.08 秒
• 嵌套类上的 Nested MemberwiseClone 为 4.77 秒
• 序列化/反序列化 39.93 秒

在类上使用 Nested MemberwiseClone 几乎与复制结构一样快，并且复制结构非常接近 .NET 能够达到的理论最大速度。

Demo 1 of shallow and deep copy, using classes and MemberwiseClone:
  Create Bob
    Bob.Age=30, Bob.Purchase.Description=Lamborghini
  Clone Bob >> BobsSon
  Adjust BobsSon details
    BobsSon.Age=2, BobsSon.Purchase.Description=Toy car
  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:
    Bob.Age=30, Bob.Purchase.Description=Lamborghini
  Elapsed time: 00:00:04.7795670,30000000

Demo 2 of shallow and deep copy, using structs and value copying:
  Create Bob
    Bob.Age=30, Bob.Purchase.Description=Lamborghini
  Clone Bob >> BobsSon
  Adjust BobsSon details:
    BobsSon.Age=2, BobsSon.Purchase.Description=Toy car
  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:
    Bob.Age=30, Bob.Purchase.Description=Lamborghini
  Elapsed time: 00:00:01.0875454,30000000

Demo 3 of deep copy, using class and serialize/deserialize:
  Elapsed time: 00:00:39.9339425,30000000

要了解如何使用 MemberwiseCopy 进行深度复制，以下是用于生成上述时间的演示项目：

// Nested MemberwiseClone example. 
// Added to demo how to deep copy a reference class.
[Serializable] // Not required if using MemberwiseClone, only used for speed comparison using serialization.
public class Person
{
    public Person(int age, string description)
    {
        this.Age = age;
        this.Purchase.Description = description;
    }
    [Serializable] // Not required if using MemberwiseClone
    public class PurchaseType
    {
        public string Description;
        public PurchaseType ShallowCopy()
        {
            return (PurchaseType)this.MemberwiseClone();
        }
    }
    public PurchaseType Purchase = new PurchaseType();
    public int Age;
    // Add this if using nested MemberwiseClone.
    // This is a class, which is a reference type, so cloning is more difficult.
    public Person ShallowCopy()
    {
        return (Person)this.MemberwiseClone();
    }
    // Add this if using nested MemberwiseClone.
    // This is a class, which is a reference type, so cloning is more difficult.
    public Person DeepCopy()
    {
            // Clone the root ...
        Person other = (Person) this.MemberwiseClone();
            // ... then clone the nested class.
        other.Purchase = this.Purchase.ShallowCopy();
        return other;
    }
}
// Added to demo how to copy a value struct (this is easy - a deep copy happens by default)
public struct PersonStruct
{
    public PersonStruct(int age, string description)
    {
        this.Age = age;
        this.Purchase.Description = description;
    }
    public struct PurchaseType
    {
        public string Description;
    }
    public PurchaseType Purchase;
    public int Age;
    // This is a struct, which is a value type, so everything is a clone by default.
    public PersonStruct ShallowCopy()
    {
        return (PersonStruct)this;
    }
    // This is a struct, which is a value type, so everything is a clone by default.
    public PersonStruct DeepCopy()
    {
        return (PersonStruct)this;
    }
}
// Added only for a speed comparison.
public class MyDeepCopy
{
    public static T DeepCopy<T>(T obj)
    {
        object result = null;
        using (var ms = new MemoryStream())
        {
            var formatter = new BinaryFormatter();
            formatter.Serialize(ms, obj);
            ms.Position = 0;
            result = (T)formatter.Deserialize(ms);
            ms.Close();
        }
        return (T)result;
    }
}

然后，从 main 调用演示：

void MyMain(string[] args)
{
    {
        Console.Write("Demo 1 of shallow and deep copy, using classes and MemberwiseCopy:\n");
        var Bob = new Person(30, "Lamborghini");
        Console.Write("  Create Bob\n");
        Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
        Console.Write("  Clone Bob >> BobsSon\n");
        var BobsSon = Bob.DeepCopy();
        Console.Write("  Adjust BobsSon details\n");
        BobsSon.Age = 2;
        BobsSon.Purchase.Description = "Toy car";
        Console.Write("    BobsSon.Age={0}, BobsSon.Purchase.Description={1}\n", BobsSon.Age, BobsSon.Purchase.Description);
        Console.Write("  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:\n");
        Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
        Debug.Assert(Bob.Age == 30);
        Debug.Assert(Bob.Purchase.Description == "Lamborghini");
        var sw = new Stopwatch();
        sw.Start();
        int total = 0;
        for (int i = 0; i < 100000; i++)
        {
            var n = Bob.DeepCopy();
            total += n.Age;
        }
        Console.Write("  Elapsed time: {0},{1}\n\n", sw.Elapsed, total);
    }
    {               
        Console.Write("Demo 2 of shallow and deep copy, using structs:\n");
        var Bob = new PersonStruct(30, "Lamborghini");
        Console.Write("  Create Bob\n");
        Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);
        Console.Write("  Clone Bob >> BobsSon\n");
        var BobsSon = Bob.DeepCopy();
        Console.Write("  Adjust BobsSon details:\n");
        BobsSon.Age = 2;
        BobsSon.Purchase.Description = "Toy car";
        Console.Write("    BobsSon.Age={0}, BobsSon.Purchase.Description={1}\n", BobsSon.Age, BobsSon.Purchase.Description);
        Console.Write("  Proof of deep copy: If BobsSon is a true clone, then adjusting BobsSon details will not affect Bob:\n");
        Console.Write("    Bob.Age={0}, Bob.Purchase.Description={1}\n", Bob.Age, Bob.Purchase.Description);                
        Debug.Assert(Bob.Age == 30);
        Debug.Assert(Bob.Purchase.Description == "Lamborghini");
        var sw = new Stopwatch();
        sw.Start();
        int total = 0;
        for (int i = 0; i < 100000; i++)
        {
            var n = Bob.DeepCopy();
            total += n.Age;
        }
        Console.Write("  Elapsed time: {0},{1}\n\n", sw.Elapsed, total);
    }
    {
        Console.Write("Demo 3 of deep copy, using class and serialize/deserialize:\n");
        int total = 0;
        var sw = new Stopwatch();
        sw.Start();
        var Bob = new Person(30, "Lamborghini");
        for (int i = 0; i < 100000; i++)
        {
            var BobsSon = MyDeepCopy.DeepCopy<Person>(Bob);
            total += BobsSon.Age;
        }
        Console.Write("  Elapsed time: {0},{1}\n", sw.Elapsed, total);
    }
    Console.ReadKey();
}

再次注意，如果您使用Nested MemberwiseClone 进行深层复制，则必须为类中的每个嵌套级别手动实现 ShallowCopy，以及调用所有上述 ShallowCopy 方法以创建完整克隆的 DeepCopy。 这很简单：总共只有几行，参见上面的演示代码。

值类型与引用类型

请注意，在克隆对象时，“ struct ”和“ class ”之间存在很大差异：

• 如果您有一个“ struct ”，它是一个值类型，因此您可以复制它，并且内容将被克隆（但除非您使用本文中的技术，否则它只会进行浅层克隆）。
• 如果你有一个“类”，它是一个引用类型，所以如果你复制它，你所做的就是复制指向它的指针。 要创建真正的克隆，您必须更有创意，并使用值类型和引用类型之间的差异，从而在内存中创建原始对象的另一个副本。

查看值类型和引用类型之间的区别。

校验和以帮助调试

• 错误地克隆对象会导致非常难以确定的错误。 在生产代码中，我倾向于实现一个校验和来仔细检查对象是否已正确克隆，并且没有被另一个引用损坏。 此校验和可以在发布模式下关闭。
• 我发现这种方法非常有用：通常，您只想克隆对象的一部分，而不是整个对象。

对于将许多线程与许多其他线程解耦非常有用

这段代码的一个很好的用例是将嵌套类或结构的克隆提供给队列，以实现生产者/消费者模式。

• 我们可以让一个（或多个）线程修改它们拥有的类，然后将此类的完整副本推送到ConcurrentQueue 。
• 然后我们有一个（或多个）线程拉出这些类的副本并处理它们。

这在实践中非常有效，并且允许我们将多个线程（生产者）与一个或多个线程（消费者）解耦。

而且这个方法也非常快：如果我们使用嵌套结构，它比序列化/反序列化嵌套类快 35 倍，并且允许我们利用机器上的所有可用线程。

更新

显然，ExpressMapper 与上面的手动编码一样快，甚至更快。 我可能需要看看他们如何与分析器进行比较。

Answer 19

免责声明：我是上述包的作者。

我很惊讶 2019 年这个问题的最佳答案仍然使用序列化或反射。

序列化是有限制的（需要属性、特定的构造函数等）并且非常慢

BinaryFormatter需要Serializable属性， JsonConverter需要一个无参数的构造函数或属性，两者都不能很好地处理只读字段或接口，并且两者都比所需的慢 10-30 倍。

表达式树

您可以改为使用Expression Trees或Reflection.Emit只生成一次克隆代码，然后使用该编译代码而不是慢速反射或序列化。

我自己遇到了这个问题并且没有看到令人满意的解决方案，我决定创建一个包，它可以做到这一点并且适用于所有类型，并且几乎与自定义编写的代码一样快。

您可以在 GitHub 上找到该项目： https : //github.com/marcelltoth/ObjectCloner

用法

您可以从 NuGet 安装它。 获取ObjectCloner包并将其用作：

var clone = ObjectCloner.DeepClone(original);

或者如果您不介意使用扩展名污染您的对象类型，也可以获取ObjectCloner.Extensions并编写：

var clone = original.DeepClone();

表现

克隆类层次结构的简单基准测试显示，性能比使用反射快约 3 倍，比 Newtonsoft.Json 序列化快约 12 倍，比强烈建议的BinaryFormatter快约 36 倍。

Answer 20

由于我在不同的项目中找不到满足我所有要求的克隆器，因此我创建了一个可以配置和适应不同代码结构的深度克隆器，而不是调整我的代码以满足克隆器的要求。 它通过向应克隆的代码添加注释来实现，或者您只需保留代码以具有默认行为即可。 它使用反射、类型缓存并基于fastflect 。 对于大量数据和高对象层次结构（与其他基于反射/序列化的算法相比），克隆过程非常快。

https://github.com/kalisohn/CloneBehave

也可用作 nuget 包： https ://www.nuget.org/packages/Clone.Behave/1.0.0

例如：下面的代码将deepClone Address，但只执行_currentJob字段的浅拷贝。

public class Person 
{
  [DeepClone(DeepCloneBehavior.Shallow)]
  private Job _currentJob;      

  public string Name { get; set; }

  public Job CurrentJob 
  { 
    get{ return _currentJob; }
    set{ _currentJob = value; }
  }

  public Person Manager { get; set; }
}

public class Address 
{      
  public Person PersonLivingHere { get; set; }
}

Address adr = new Address();
adr.PersonLivingHere = new Person("John");
adr.PersonLivingHere.BestFriend = new Person("James");
adr.PersonLivingHere.CurrentJob = new Job("Programmer");

Address adrClone = adr.Clone();

//RESULT
adr.PersonLivingHere == adrClone.PersonLivingHere //false
adr.PersonLivingHere.Manager == adrClone.PersonLivingHere.Manager //false
adr.PersonLivingHere.CurrentJob == adrClone.PersonLivingHere.CurrentJob //true
adr.PersonLivingHere.CurrentJob.AnyProperty == adrClone.PersonLivingHere.CurrentJob.AnyProperty //true

Answer 21

我也看到它是通过反射实现的。 基本上有一种方法可以遍历对象的成员并将它们适当地复制到新对象。 当它到达引用类型或集合时，我认为它对自己进行了递归调用。 反射很昂贵，但效果很好。

Answer 22

这是一个深拷贝实现：

public static object CloneObject(object opSource)
{
    //grab the type and create a new instance of that type
    Type opSourceType = opSource.GetType();
    object opTarget = CreateInstanceOfType(opSourceType);

    //grab the properties
    PropertyInfo[] opPropertyInfo = opSourceType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

    //iterate over the properties and if it has a 'set' method assign it from the source TO the target
    foreach (PropertyInfo item in opPropertyInfo)
    {
        if (item.CanWrite)
        {
            //value types can simply be 'set'
            if (item.PropertyType.IsValueType || item.PropertyType.IsEnum || item.PropertyType.Equals(typeof(System.String)))
            {
                item.SetValue(opTarget, item.GetValue(opSource, null), null);
            }
            //object/complex types need to recursively call this method until the end of the tree is reached
            else
            {
                object opPropertyValue = item.GetValue(opSource, null);
                if (opPropertyValue == null)
                {
                    item.SetValue(opTarget, null, null);
                }
                else
                {
                    item.SetValue(opTarget, CloneObject(opPropertyValue), null);
                }
            }
        }
    }
    //return the new item
    return opTarget;
}

Answer 23

代码生成器

我们已经看到了很多想法，从手动实现的序列化到反射，我想提出一种使用CGbR 代码生成器的完全不同的方法。 生成克隆方法具有内存和 CPU 效率，因此比标准 DataContractSerializer 快 300 倍。

您所需要的只是一个带有ICloneable的部分类定义，其余的由生成器完成：

public partial class Root : ICloneable
{
    public Root(int number)
    {
        _number = number;
    }
    private int _number;

    public Partial[] Partials { get; set; }

    public IList<ulong> Numbers { get; set; }

    public object Clone()
    {
        return Clone(true);
    }

    private Root()
    {
    }
} 

public partial class Root
{
    public Root Clone(bool deep)
    {
        var copy = new Root();
        // All value types can be simply copied
        copy._number = _number; 
        if (deep)
        {
            // In a deep clone the references are cloned 
            var tempPartials = new Partial[Partials.Length];
            for (var i = 0; i < Partials.Length; i++)
            {
                var value = Partials[i];
                value = value.Clone(true);
                tempPartials[i] = value;
            }
            copy.Partials = tempPartials;
            var tempNumbers = new List<ulong>(Numbers.Count);
            for (var i = 0; i < Numbers.Count; i++)
            {
                var value = Numbers[i];
                tempNumbers.Add(value);
            }
            copy.Numbers = tempNumbers;
        }
        else
        {
            // In a shallow clone only references are copied
            copy.Partials = Partials; 
            copy.Numbers = Numbers; 
        }
        return copy;
    }
}

注意：最新版本有更多的空检查，但为了更好地理解，我把它们省略了。

Answer 24

创建扩展：

public static T Clone<T>(this T theObject)
{
    string jsonData = JsonConvert.SerializeObject(theObject);
    return JsonConvert.DeserializeObject<T>(jsonData);
}

并这样称呼它：

NewObject = OldObject.Clone();

Answer 25

我喜欢这样的 Copyconstructors：

    public AnyObject(AnyObject anyObject)
    {
        foreach (var property in typeof(AnyObject).GetProperties())
        {
            property.SetValue(this, property.GetValue(anyObject));
        }
        foreach (var field in typeof(AnyObject).GetFields())
        {
            field.SetValue(this, field.GetValue(anyObject));
        }
    }

如果您有更多要复制的内容，请添加它们

Answer 26

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

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);

Answer 27

这是一个快速简便的解决方案，对我有用，无需中继序列化/反序列化。

public class MyClass
{
    public virtual MyClass DeepClone()
    {
        var returnObj = (MyClass)MemberwiseClone();
        var type = returnObj.GetType();
        var fieldInfoArray = type.GetRuntimeFields().ToArray();

        foreach (var fieldInfo in fieldInfoArray)
        {
            object sourceFieldValue = fieldInfo.GetValue(this);
            if (!(sourceFieldValue is MyClass))
            {
                continue;
            }

            var sourceObj = (MyClass)sourceFieldValue;
            var clonedObj = sourceObj.DeepClone();
            fieldInfo.SetValue(returnObj, clonedObj);
        }
        return returnObj;
    }
}

编辑：需要

    using System.Linq;
    using System.Reflection;

我就是这样用的

public MyClass Clone(MyClass theObjectIneededToClone)
{
    MyClass clonedObj = theObjectIneededToClone.DeepClone();
}

Answer 28

我想你可以试试这个。

MyObject myObj = GetMyObj(); // Create and fill a new object
MyObject newObj = new MyObject(myObj); //DeepClone it

Answer 29

由于这个问题的几乎所有答案都不令人满意或在我的情况下显然不起作用，因此我编写了AnyClone ，它完全通过反射实现并解决了这里的所有需求。 我无法在具有复杂结构的复杂场景中进行序列化，并且IClonable不太理想 - 事实上它甚至没有必要。

使用[IgnoreDataMember] 、 [NonSerialized]支持标准忽略属性。 支持复杂的集合、没有 setter 的属性、只读字段等。

我希望它可以帮助那些遇到同样问题的人。

Answer 30

按着这些次序：

• 使用返回T的只读Self属性和ICloneable<out T>定义一个ISelf<T> ，它派生自ISelf<T>并包含一个方法T Clone() 。
• 然后定义一个CloneBase类型，它实现一个protected virtual generic VirtualClone将MemberwiseClone转换为传入的类型。
• 每个派生类型都应该通过调用基本 clone 方法来实现VirtualClone ，然后做任何需要做的事情来正确克隆父 VirtualClone 方法尚未处理的派生类型的那些方面。

为了最大限度地继承通用性，公开公共克隆功能的类应该是sealed ，但从基类派生，除了缺少克隆之外，该基类在其他方面是相同的。 而不是传递显式可克隆类型的变量，而是采用ICloneable<theNonCloneableType>类型的参数。 这将允许期望Foo可DerivedFoo衍生物的DerivedFoo与DerivedFoo衍生物DerivedFoo ，但也允许创建Foo的不可克隆衍生物。

Answer 31

我创建了一个适用于“[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;
    }

} 

Answer 32

要克隆您的类对象，可以使用Object.MemberwiseClone方法，

只需将此函数添加到您的班级：

public class yourClass
{
    // ...
    // ...

    public yourClass DeepCopy()
    {
        yourClass othercopy = (yourClass)this.MemberwiseClone();
        return othercopy;
    }
}

然后执行深层独立副本，只需调用DeepCopy方法：

yourClass newLine = oldLine.DeepCopy();

希望这可以帮助。

Answer 33

如果您的对象树是可序列化的，那么您也可以使用类似的东西

static public MyClass Clone(MyClass myClass)
{
    MyClass clone;
    XmlSerializer ser = new XmlSerializer(typeof(MyClass), _xmlAttributeOverrides);
    using (var ms = new MemoryStream())
    {
        ser.Serialize(ms, myClass);
        ms.Position = 0;
        clone = (MyClass)ser.Deserialize(ms);
    }
    return clone;
}

知道此解决方案非常简单，但性能不如其他解决方案高。

并且请确保如果Class增加，那么仍然只会克隆那些字段，并且这些字段也会被序列化。

Answer 34

我想做类似的事情：

MyObject myObj = GetMyObj(); // Create and fill a new object
MyObject newObj = myObj.Clone();

然后对未反映在原始对象中的新对象进行更改。

我通常不需要此功能，因此在必要时我会先创建一个新对象，然后分别复制每个属性，但是它总是让我感到有更好或更优雅的处理方式情况。

如何克隆或深度复制对象，以便可以修改克隆的对象而不会在原始对象中反映任何更改？

Answer 35

映射器执行深拷贝。 Foreach 对象的成员，它会创建一个新对象并为其分配所有值。 它递归地作用于每个非原始内部成员。

我建议你选择最快的，目前正在积极开发的之一。 我建议 UltraMapper https://github.com/maurosampietro/UltraMapper

Nuget 包： https ://www.nuget.org/packages/UltraMapper/

Answer 36

最短的方法但需要依赖：

using Newtonsoft.Json;
    public static T Clone<T>(T source) =>
        JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source));

Answer 37

令人难以置信的是，您可以在 IClonable 接口上花费多少精力 - 特别是如果您有繁重的类层次结构。 此外，MemberwiseClone 的工作方式很奇怪——它甚至不能完全克隆正常的 List 类型的结构。

当然，序列化最有趣的困境是序列化反向引用——例如，您具有子父关系的类层次结构。 在这种情况下，我怀疑二进制序列化程序能否为您提供帮助。 （最终会出现递归循环 + 堆栈溢出）。

我以某种方式喜欢这里提出的解决方案： How do you do a deep copy of an object in .NET (specifically C#)?

但是 - 它不支持列表，补充说支持，还考虑了重新养育。 对于我已将该字段或属性命名为“父级”的仅育儿规则，DeepClone 将忽略该规则。 您可能想要决定自己的反向引用规则 - 对于树层次结构，它可能是“左/右”等......

这是整个代码片段，包括测试代码：

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

namespace TestDeepClone
{
    class Program
    {
        static void Main(string[] args)
        {
            A a = new A();
            a.name = "main_A";
            a.b_list.Add(new B(a) { name = "b1" });
            a.b_list.Add(new B(a) { name = "b2" });

            A a2 = (A)a.DeepClone();
            a2.name = "second_A";

            // Perform re-parenting manually after deep copy.
            foreach( var b in a2.b_list )
                b.parent = a2;


            Debug.WriteLine("ok");

        }
    }

    public class A
    {
        public String name = "one";
        public List<String> list = new List<string>();
        public List<String> null_list;
        public List<B> b_list = new List<B>();
        private int private_pleaseCopyMeAsWell = 5;

        public override string ToString()
        {
            return "A(" + name + ")";
        }
    }

    public class B
    {
        public B() { }
        public B(A _parent) { parent = _parent; }
        public A parent;
        public String name = "two";
    }


    public static class ReflectionEx
    {
        public static Type GetUnderlyingType(this MemberInfo member)
        {
            Type type;
            switch (member.MemberType)
            {
                case MemberTypes.Field:
                    type = ((FieldInfo)member).FieldType;
                    break;
                case MemberTypes.Property:
                    type = ((PropertyInfo)member).PropertyType;
                    break;
                case MemberTypes.Event:
                    type = ((EventInfo)member).EventHandlerType;
                    break;
                default:
                    throw new ArgumentException("member must be if type FieldInfo, PropertyInfo or EventInfo", "member");
            }
            return Nullable.GetUnderlyingType(type) ?? type;
        }

        /// <summary>
        /// Gets fields and properties into one array.
        /// Order of properties / fields will be preserved in order of appearance in class / struct. (MetadataToken is used for sorting such cases)
        /// </summary>
        /// <param name="type">Type from which to get</param>
        /// <returns>array of fields and properties</returns>
        public static MemberInfo[] GetFieldsAndProperties(this Type type)
        {
            List<MemberInfo> fps = new List<MemberInfo>();
            fps.AddRange(type.GetFields());
            fps.AddRange(type.GetProperties());
            fps = fps.OrderBy(x => x.MetadataToken).ToList();
            return fps.ToArray();
        }

        public static object GetValue(this MemberInfo member, object target)
        {
            if (member is PropertyInfo)
            {
                return (member as PropertyInfo).GetValue(target, null);
            }
            else if (member is FieldInfo)
            {
                return (member as FieldInfo).GetValue(target);
            }
            else
            {
                throw new Exception("member must be either PropertyInfo or FieldInfo");
            }
        }

        public static void SetValue(this MemberInfo member, object target, object value)
        {
            if (member is PropertyInfo)
            {
                (member as PropertyInfo).SetValue(target, value, null);
            }
            else if (member is FieldInfo)
            {
                (member as FieldInfo).SetValue(target, value);
            }
            else
            {
                throw new Exception("destinationMember must be either PropertyInfo or FieldInfo");
            }
        }

        /// <summary>
        /// Deep clones specific object.
        /// Analogue can be found here: https://stackoverflow.com/questions/129389/how-do-you-do-a-deep-copy-an-object-in-net-c-specifically
        /// This is now improved version (list support added)
        /// </summary>
        /// <param name="obj">object to be cloned</param>
        /// <returns>full copy of object.</returns>
        public static object DeepClone(this object obj)
        {
            if (obj == null)
                return null;

            Type type = obj.GetType();

            if (obj is IList)
            {
                IList list = ((IList)obj);
                IList newlist = (IList)Activator.CreateInstance(obj.GetType(), list.Count);

                foreach (object elem in list)
                    newlist.Add(DeepClone(elem));

                return newlist;
            } //if

            if (type.IsValueType || type == typeof(string))
            {
                return obj;
            }
            else if (type.IsArray)
            {
                Type elementType = Type.GetType(type.FullName.Replace("[]", string.Empty));
                var array = obj as Array;
                Array copied = Array.CreateInstance(elementType, array.Length);

                for (int i = 0; i < array.Length; i++)
                    copied.SetValue(DeepClone(array.GetValue(i)), i);

                return Convert.ChangeType(copied, obj.GetType());
            }
            else if (type.IsClass)
            {
                object toret = Activator.CreateInstance(obj.GetType());

                MemberInfo[] fields = type.GetFieldsAndProperties();
                foreach (MemberInfo field in fields)
                {
                    // Don't clone parent back-reference classes. (Using special kind of naming 'parent' 
                    // to indicate child's parent class.
                    if (field.Name == "parent")
                    {
                        continue;
                    }

                    object fieldValue = field.GetValue(obj);

                    if (fieldValue == null)
                        continue;

                    field.SetValue(toret, DeepClone(fieldValue));
                }

                return toret;
            }
            else
            {
                // Don't know that type, don't know how to clone it.
                if (Debugger.IsAttached)
                    Debugger.Break();

                return null;
            }
        } //DeepClone
    }

}

Answer 38

另一个 JSON.NET 答案。 此版本适用于未实现 ISerializable 的类。

public static class Cloner
{
    public static T Clone<T>(T source)
    {
        if (ReferenceEquals(source, null))
            return default(T);

        var settings = new JsonSerializerSettings { ContractResolver = new ContractResolver() };

        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source, settings), settings);
    }

    class ContractResolver : DefaultContractResolver
    {
        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
        {
            var props = type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
                .Select(p => base.CreateProperty(p, memberSerialization))
                .Union(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
                    .Select(f => base.CreateProperty(f, memberSerialization)))
                .ToList();
            props.ForEach(p => { p.Writable = true; p.Readable = true; });
            return props;
        }
    }
}

Answer 39

通用方法在技术上都是有效的，但我只是想添加我自己的注释，因为我们实际上很少需要真正的深拷贝，而且我强烈反对在实际业务应用程序中使用通用深拷贝，因为这使得你可能有很多对象被复制然后显式修改的地方，很容易迷路。

在大多数实际情况下，您还希望对复制过程进行尽可能多的细粒度控制，因为您不仅与数据访问框架耦合，而且在实践中复制的业务对象很少应该 100% 相同。 想想 ORM 用来标识对象引用的示例 referenceId，一个完整的深拷贝也会复制这个 id，所以在内存中对象会有所不同，一旦你将它提交到数据存储，它就会抱怨，所以你会无论如何都必须在复制后手动修改此属性，如果对象发生变化，您需要在所有使用通用深度复制的地方对其进行调整。

使用 ICloneable 扩展@cregox 答案，究竟什么是深拷贝？ 它只是堆上一个新分配的对象，与原始对象相同，但占用不同的内存空间，因此与其使用通用克隆功能，为什么不创建一个新对象呢？

我个人在我的域对象上使用静态工厂方法的想法。

例子：

    public class Client
    {
        public string Name { get; set; }

        protected Client()
        {
        }

        public static Client Clone(Client copiedClient)
        {
            return new Client
            {
                Name = copiedClient.Name
            };
        }
    }

    public class Shop
    {
        public string Name { get; set; }

        public string Address { get; set; }

        public ICollection<Client> Clients { get; set; }

        public static Shop Clone(Shop copiedShop, string newAddress, ICollection<Client> clients)
        {
            var copiedClients = new List<Client>();
            foreach (var client in copiedShop.Clients)
            {
                copiedClients.Add(Client.Clone(client));
            }

            return new Shop
            {
                Name = copiedShop.Name,
                Address = newAddress,
                Clients = copiedClients
            };
        }
    }

如果有人正在研究如何构建对象实例化，同时保持对复制过程的完全控制，那么这是我个人非常成功的解决方案。 受保护的构造函数也是如此，其他开发人员被迫使用工厂方法，它提供了一个简洁的对象实例化单点，封装了对象内部的构造逻辑。 如有必要，您还可以重载该方法并为不同的地方设置多个克隆逻辑。

Answer 40

除了此处的一些出色答案之外，您可以在 C# 9.0 及更高版本中执行以下操作（假设您可以将 class 转换为记录）：

record Record
{
    public int Property1 { get; set; }

    public string Property2 { get; set; }
}

然后，只需使用with 运算符将一个 object 的值复制到新的。

var object1 = new Record()
{
    Property1 = 1,
    Property2 = "2"
};

var object2 = object1 with { };
// object2 now has Property1 = 1 & Property2 = "2"

我希望这有帮助：）

Answer 41

这会将一个对象的所有可读和可写属性复制到另一个对象。

 public class PropertyCopy<TSource, TTarget> 
                        where TSource: class, new()
                        where TTarget: class, new()
        {
            public static TTarget Copy(TSource src, TTarget trg, params string[] properties)
            {
                if (src==null) return trg;
                if (trg == null) trg = new TTarget();
                var fulllist = src.GetType().GetProperties().Where(c => c.CanWrite && c.CanRead).ToList();
                if (properties != null && properties.Count() > 0)
                    fulllist = fulllist.Where(c => properties.Contains(c.Name)).ToList();
                if (fulllist == null || fulllist.Count() == 0) return trg;

                fulllist.ForEach(c =>
                    {
                        c.SetValue(trg, c.GetValue(src));
                    });

                return trg;
            }
        }

这就是你如何使用它：

 var cloned = Utils.PropertyCopy<TKTicket, TKTicket>.Copy(_tmp, dbsave,
                                                            "Creation",
                                                            "Description",
                                                            "IdTicketStatus",
                                                            "IdUserCreated",
                                                            "IdUserInCharge",
                                                            "IdUserRequested",
                                                            "IsUniqueTicketGenerated",
                                                            "LastEdit",
                                                            "Subject",
                                                            "UniqeTicketRequestId",
                                                            "Visibility");

或复制所有内容：

var cloned = Utils.PropertyCopy<TKTicket, TKTicket>.Copy(_tmp, dbsave);

Answer 42

只是在应该调用基本上自动复制构造函数的方法中重铸怎么样

T t = new T();
T t2 = (T)t;  //eh something like that

        List<myclass> cloneum;
        public void SomeFuncB(ref List<myclass> _mylist)
        {
            cloneum = new List<myclass>();
            cloneum = (List < myclass >) _mylist;
            cloneum.Add(new myclass(3));
            _mylist = new List<myclass>();
        }

似乎对我有用

Answer 43

当使用 Marc Gravells protobuf-net 作为您的序列化程序时，接受的答案需要一些轻微的修改，因为要复制的对象不会归因于[Serializable] ，因此不可序列化并且 Clone 方法将引发异常。
我修改了它以与 protobuf-net 一起使用：

public static T Clone<T>(this T source)
{
    if(Attribute.GetCustomAttribute(typeof(T), typeof(ProtoBuf.ProtoContractAttribute))
           == null)
    {
        throw new ArgumentException("Type has no ProtoContract!", "source");
    }

    if(Object.ReferenceEquals(source, null))
    {
        return default(T);
    }

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

这会检查[ProtoContract]属性是否存在，并使用 protobufs 自己的格式化程序来序列化对象。

Answer 44

我找到了一种新的方法，那就是 Emit。

我们可以使用 Emit 将 IL 添加到应用程序并运行它。 但我不认为这是我想完善我写答案的好方法。

Emit可以看官方文档和Guide

你应该学习一些 IL 来阅读代码。 我将编写可以在类中复制属性的代码。

public static class Clone
{        
    // ReSharper disable once InconsistentNaming
    public static void CloneObjectWithIL<T>(T source, T los)
    {
        //see http://lindexi.oschina.io/lindexi/post/C-%E4%BD%BF%E7%94%A8Emit%E6%B7%B1%E5%85%8B%E9%9A%86/
        if (CachedIl.ContainsKey(typeof(T)))
        {
            ((Action<T, T>) CachedIl[typeof(T)])(source, los);
            return;
        }
        var dynamicMethod = new DynamicMethod("Clone", null, new[] { typeof(T), typeof(T) });
        ILGenerator generator = dynamicMethod.GetILGenerator();

        foreach (var temp in typeof(T).GetProperties().Where(temp => temp.CanRead && temp.CanWrite))
        {
            //do not copy static that will except
            if (temp.GetAccessors(true)[0].IsStatic)
            {
                continue;
            }

            generator.Emit(OpCodes.Ldarg_1);// los
            generator.Emit(OpCodes.Ldarg_0);// s
            generator.Emit(OpCodes.Callvirt, temp.GetMethod);
            generator.Emit(OpCodes.Callvirt, temp.SetMethod);
        }
        generator.Emit(OpCodes.Ret);
        var clone = (Action<T, T>) dynamicMethod.CreateDelegate(typeof(Action<T, T>));
        CachedIl[typeof(T)] = clone;
        clone(source, los);
    }

    private static Dictionary<Type, Delegate> CachedIl { set; get; } = new Dictionary<Type, Delegate>();
}

代码可以是深层复制，但它可以复制属性。 如果你想把它做成深拷贝，你可以为 IL 改变它太难了，我做不到。

Answer 45

C# 扩展也将支持“not ISerializable ”类型。

 public static class AppExtensions
 {                                                                      
       public static T DeepClone<T>(this T a)
       {
           using (var stream = new MemoryStream())
           {
               var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));

               serializer.Serialize(stream, a);
               stream.Position = 0;
               return (T)serializer.Deserialize(stream);
           }
       }                                                                    
 }

用法

       var obj2 = obj1.DeepClone()

Answer 46

深度克隆是关于复制状态。 对于.net状态意味着fields 。

假设有一个层次结构：

static class RandomHelper
{
    private static readonly Random random = new Random();

    public static int Next(int maxValue) => random.Next(maxValue);
}

class A
{
    private readonly int random = RandomHelper.Next(100);

    public override string ToString() => $"{typeof(A).Name}.{nameof(random)} = {random}";
}

class B : A
{
    private readonly int random = RandomHelper.Next(100);

    public override string ToString() => $"{typeof(B).Name}.{nameof(random)} = {random} {base.ToString()}";
}

class C : B
{
    private readonly int random = RandomHelper.Next(100);

    public override string ToString() => $"{typeof(C).Name}.{nameof(random)} = {random} {base.ToString()}";
}

可以进行克隆：

static class DeepCloneExtension
{
    // consider instance fields, both public and non-public
    private static readonly BindingFlags bindingFlags =
        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;

    public static T DeepClone<T>(this T obj) where T : new()
    {
        var type = obj.GetType();
        var result = (T)Activator.CreateInstance(type);

        do
            // copy all fields
            foreach (var field in type.GetFields(bindingFlags))
                field.SetValue(result, field.GetValue(obj));
        // for every level of hierarchy
        while ((type = type.BaseType) != typeof(object));

        return result;
    }
}

演示1 ：

Console.WriteLine(new C());
Console.WriteLine(new C());

var c = new C();
Console.WriteLine($"{Environment.NewLine}Image: {c}{Environment.NewLine}");

Console.WriteLine(new C());
Console.WriteLine(new C());

Console.WriteLine($"{Environment.NewLine}Clone: {c.DeepClone()}{Environment.NewLine}");

Console.WriteLine(new C());
Console.WriteLine(new C());

结果：

C.random = 92 B.random = 66 A.random = 71
C.random = 36 B.random = 64 A.random = 17

Image: C.random = 96 B.random = 18 A.random = 46

C.random = 60 B.random = 7 A.random = 37
C.random = 78 B.random = 11 A.random = 18

Clone: C.random = 96 B.random = 18 A.random = 46

C.random = 33 B.random = 63 A.random = 38
C.random = 4 B.random = 5 A.random = 79

请注意，所有新对象具有随机值random领域，但clone完全匹配的image

演示2 ：

class D
{
    public event EventHandler Event;
    public void RaiseEvent() => Event?.Invoke(this, EventArgs.Empty);
}

// ...

var image = new D();
Console.WriteLine($"Created obj #{image.GetHashCode()}");

image.Event += (sender, e) => Console.WriteLine($"Event from obj #{sender.GetHashCode()}");
Console.WriteLine($"Subscribed to event of obj #{image.GetHashCode()}");

image.RaiseEvent();
image.RaiseEvent();

var clone = image.DeepClone();
Console.WriteLine($"obj #{image.GetHashCode()} cloned to obj #{clone.GetHashCode()}");

clone.RaiseEvent();
image.RaiseEvent();

结果：

Created obj #46104728
Subscribed to event of obj #46104728
Event from obj #46104728
Event from obj #46104728
obj #46104728 cloned to obj #12289376
Event from obj #12289376
Event from obj #46104728

注意，事件支持字段也被复制，客户端也订阅了克隆的事件。

Answer 47

使用System.Text.Json ：

https://devblogs.microsoft.com/dotnet/try-the-new-system-text-json-apis/

public static T DeepCopy<T>(this T source)
{
    return source == null ? default : JsonSerializer.Parse<T>(JsonSerializer.ToString(source));
}

新 API 使用Span<T> 。 这应该很快，做一些基准测试会很好。

注意：不需要像 Json.NET 中的ObjectCreationHandling.Replace因为它会默认替换集合值。 你现在应该忘记 Json.NET，因为一切都将被新的官方 API 取代。

我不确定这是否适用于私有字段。

Answer 48

我对当前答案做了一些基准测试，发现了一些有趣的事实。

使用 BinarySerializer => https:\/\/stackoverflow.com\/a\/78612\/6338072<\/a>

使用 XmlSerializer => https:\/\/stackoverflow.com\/a\/50150204\/6338072<\/a>

使用 Activator.CreateInstance => https:\/\/stackoverflow.com\/a\/56691124\/6338072<\/a>

这些是结果

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.18363.1734 (1909/November2019Update/19H2)

Answer 49

对于克隆过程，可以先将对象转换为字节数组，然后再转换回对象。

public static class Extentions
{
    public static T Clone<T>(this T obj)
    {
        byte[] buffer = BinarySerialize(obj);
        return (T)BinaryDeserialize(buffer);
    }

    public static byte[] BinarySerialize(object obj)
    {
        using (var stream = new MemoryStream())
        {
            var formatter = new BinaryFormatter(); 
            formatter.Serialize(stream, obj); 
            return stream.ToArray();
        }
    }

    public static object BinaryDeserialize(byte[] buffer)
    {
        using (var stream = new MemoryStream(buffer))
        {
           var formatter = new BinaryFormatter(); 
           return formatter.Deserialize(stream);
        }
    }
}

必须为序列化过程序列化对象。

[Serializable]
public class MyObject
{
    public string Name  { get; set; }
}

用法：

MyObject myObj  = GetMyObj();
MyObject newObj = myObj.Clone();

Answer 50

使用内置System.Text.Json for .NET >5对 @Konrad 和 @craastad 的补充

https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-how-to?pivots=dotnet-5-0

方法：

public static T Clone<T>(T source)
{
    var serialized = JsonSerializer.Serialize(source);
    return JsonSerializer.Deserialize<T>(serialized);
}

扩展方法：

public static class SystemExtension
{
    public static T Clone<T>(this T source)
    {
        var serialized = JsonSerializer.Serialize(source);
        return JsonSerializer.Deserialize<T>(serialized);
    }
}

Answer 51

C# 9.0 引入了需要record的with关键字（感谢 Mark Nading）。 这应该允许使用很少的样板进行非常简单的对象克隆（如果需要，还可以进行突变），但只能使用record 。

您似乎无法通过将类放入通用record来克隆（按值）类；

using System;
                
public class Program
{
    public class Example
    {
        public string A { get; set; }
    }
    
    public record ClonerRecord<T>(T a)
    {
    }

    public static void Main()
    {
        var foo = new Example {A = "Hello World"};
        var bar = (new ClonerRecord<Example>(foo) with {}).a;
        foo.A = "Goodbye World :(";
        Console.WriteLine(bar.A);
    }
}

这写“再见世界 :(”- 该字符串是通过引用复制的（不需要的） 。https://dotnetfiddle.net/w3IJgG

（令人难以置信的是，上面的struct可以正常工作！ https://dotnetfiddle.net/469NJv ）

但是克隆record似乎确实可以缩进，按值克隆。

using System;

public class Program
{
    public record Example
    {
        public string A { get; set; }
    }
    
    public static void Main()
    {
        var foo = new Example {A = "Hello World"};
        var bar = foo with {};
        foo.A = "Goodbye World :(";
        Console.WriteLine(bar.A);
    }
}

这将返回“Hello World”，该字符串是按值复制的！ https://dotnetfiddle.net/MCHGEL

更多信息可以在博客文章中找到：

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/operators/with-expression

Answer 52

我将使用以下简单的方法来实现这一点。 只需创建一个抽象类并实现方法以再次序列化和反序列化并返回。

public abstract class CloneablePrototype<T>
{
    public T DeepCopy()
    {
        string result = JsonConvert.SerializeObject(this);
        return JsonConvert.DeserializeObject<T>(result);
    }
}
public class YourClass : CloneablePrototype< YourClass>
…
…
…

并像这样使用它来创建深层副本。

YourClass newObj = (YourClass)oldObj.DeepCopy();

如果您还需要实现浅拷贝方法，此解决方案也很容易扩展。

只需在抽象类中实现一个新方法。

public T ShallowCopy()
{
    return (T)this.MemberwiseClone();
}

Answer 53

以@craastad 的答案为基础，用于派生类。

在原始答案中，如果调用者在基础 class object 上调用DeepCopy ，则克隆的 object 是基础 ZA2F214F8EBC2CCDBB4 但以下代码将返回派生的 class。

using Newtonsoft.Json;

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

Answer 54

在我正在使用的代码库中，我们有一份来自 GitHub 项目Burtsev-Alexey/net-object-deep-copy的文件ObjectExtensions.cs的副本。 它是 9 岁。 它起作用了，尽管我们后来意识到它对于较大的 object 结构非常慢。

相反，我们在 GitHub 项目jpmikkers/Baksteen.Extensions.DeepCopy中找到了文件ObjectExtensions.cs的一个分支。 以前需要大约 30 分钟的大型数据结构的深度复制操作，现在感觉几乎是瞬间完成的。

此改进版本具有以下文档：

用于快速 object 克隆的 C# 扩展方法。

这是 Alexey Burtsev 的深度复印机的速度优化分支。 根据您的用例，这将比原来的速度快 2 到 3 倍。 它还修复了原始代码中存在的一些错误。 与经典的二进制序列化/反序列化深度克隆技术相比，这个版本快了大约 7 倍（对象包含的 arrays 越多，加速因子越大）。

加速是通过以下技术实现的：

• object 反射结果被缓存
• 不要深度复制原语或不可变结构和类（例如枚举和字符串）
• 为了提高参考的局部性，在内部循环中处理“快速”尺寸或多维 arrays
• 使用已编译的 Lamba 表达式调用 MemberwiseClone

如何使用：

 using Baksteen.Extensions.DeepCopy; ... var myobject = new SomeClass(); ... var myclone = myobject.DeepCopy();; // creates a new deep copy of the original object

注意：仅当您在项目中启用可为空的引用类型时，才需要感叹号（允许空的运算符）

Answer 55

使用 System.Text.Json;

public static class CloneExtensions
{
    public static T Clone<T>(this T cloneable) where T : new()
    {
        var toJson = JsonSerializer.Serialize(cloneable);
        return JsonSerializer.Deserialize<T>(toJson);
    }
}

Answer 56

找到了这个包，与它相比，它似乎比DeepCloner<\/code>更快，并且没有依赖关系。

https:\/\/github.com\/AlenToma\/FastDeepCloner<\/a>

Answer 57

如果你使用 net.core 并且 object 是可序列化的，你可以使用

var jsonBin = BinaryData.FromObjectAsJson(yourObject);

然后

var yourObjectCloned = jsonBin.ToObjectFromJson<YourType>();

BinaryData 在 dotnet 中，因此您不需要第三方库。 它还可以处理您的class 上的属性为Object 类型的情况（您的属性中的实际数据仍然需要可序列化）

Answer 58

我知道这个问题和答案在这里有一段时间了，以下不是答案而是观察，我最近在检查私人是否确实没有被克隆时遇到了这个问题（如果我没有，我就不会是我自己;) 当我愉快地复制粘贴@johnc更新答案时。

我只是让自己扩展方法（这几乎是上述答案的复制粘贴形式）：

public static class CloneThroughJsonExtension
{
    private static readonly JsonSerializerSettings DeserializeSettings = new JsonSerializerSettings { ObjectCreationHandling = ObjectCreationHandling.Replace };

    public static T CloneThroughJson<T>(this T source)
    {
        return ReferenceEquals(source, null) ? default(T) : JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source), DeserializeSettings);
    }
}

并像这样天真地放弃了课程（实际上还有更多，但它们无关）：

public class WhatTheHeck
{
    public string PrivateSet { get; private set; } // matches ctor param name

    public string GetOnly { get; } // matches ctor param name

    private readonly string _indirectField;
    public string Indirect => $"Inception of: {_indirectField} "; // matches ctor param name
    public string RealIndirectFieldVaule => _indirectField;

    public WhatTheHeck(string privateSet, string getOnly, string indirect)
    {
        PrivateSet = privateSet;
        GetOnly = getOnly;
        _indirectField = indirect;
    }
}

和这样的代码：

var clone = new WhatTheHeck("Private-Set-Prop cloned!", "Get-Only-Prop cloned!", "Indirect-Field clonned!").CloneThroughJson();
Console.WriteLine($"1. {clone.PrivateSet}");
Console.WriteLine($"2. {clone.GetOnly}");
Console.WriteLine($"3.1. {clone.Indirect}");
Console.WriteLine($"3.2. {clone.RealIndirectFieldVaule}");

导致：

1. Private-Set-Prop cloned!
2. Get-Only-Prop cloned!
3.1. Inception of: Inception of: Indirect-Field cloned!
3.2. Inception of: Indirect-Field cloned!

我整个人就像：什么鬼......所以我抓住了 Newtonsoft.Json Github repo 并开始挖掘。 结果是：在反序列化恰好只有一个 ctor 并且其参数名称匹配（ 不区分大小写）公共属性名称的类型时，它们将作为这些参数传递给 ctor。 可以在此处和此处的代码中找到一些线索。

底线

我知道这不是常见的情况，示例代码有点滥用，但是嘿！ 当我检查灌木丛中是否有龙等着跳出来咬我的屁股时，这让我感到惊讶。 ;)