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

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

换言之，除非您有需要解决的性能瓶颈，并且您可以使用分析器来证明这一点，否则请使用另一个答案。

比其他方法快10倍

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

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

方法。。。

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

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

下面是显示100000个克隆的相对性能差异的代码输出：

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

在类上使用Nested MemberwiseColone几乎与复制结构一样快，而且复制结构的速度非常接近.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 MemberwiseColone进行深度复制，则必须为类中的每个嵌套级别手动实现ShallowCopy，以及调用所有所述ShallowCopy方法以创建完整克隆的DeepCopy。这很简单：总共只有几行，请参见上面的演示代码。

值类型与引用类型

请注意，在克隆对象时，“结构”和“类”之间有很大的区别：

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

请参见值类型和引用类型之间的差异。

帮助调试的校验和

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

对于将许多线程与许多其他线程分离非常有用

该代码的一个优秀用例是将嵌套类或结构的克隆送入队列，以实现生产者/消费者模式。

我们可以让一个（或多个）线程修改自己拥有的类，然后将该类的完整副本推送到并发队列中。然后，我们有一个（或多个）线程将这些类的副本拉出并处理它们。

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

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

使现代化

显然，ExpressMapper与上面的手工编码一样快，甚至更快。我可能需要看看它们与探查器的比较。

保持简单，并使用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();

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

所以我将在这里复制这两个参考文献的相关部分。这样我们就可以：

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

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

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

通过表达式树进行快速深度复制一文还对通过序列化、反射和表达式树进行克隆的性能进行了比较。

为什么选择ICloneable（即手动）

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

他的所有文章都围绕着一个例子，试图适用于大多数情况，使用三个对象：人、大脑和城市。我们想克隆一个人，这个人将拥有自己的大脑，但同样的城市。你可以想象上面任何其他方法都会带来的所有问题，也可以阅读本文。

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

通过指定New后跟类名来复制对象通常会导致代码不可扩展。使用克隆（原型模式的应用）是实现这一点的更好方法。然而，使用C#（和Java）中提供的克隆也会有很大的问题。最好提供一个受保护的（非公共的）复制构造函数，并从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

注意，如果我们对对象的数量进行计数，这里实现的克隆将保持正确的对象数量计数。

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

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

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

var copy = anyObject.DeepClone();

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

按序列化（最短代码）通过反射-速度提高5倍通过表达式树-速度快20倍

所有相关的方法都运行良好，并经过了深入测试。

复制所有公共财产的简单扩展方法。适用于任何对象，不要求类为[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 ) } );
        }
    };
}

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