问。为什么我会选择这个答案？
- 如果您想要 .NET 能够提供的最快速度，请选择此答案。
- 如果您想要一种非常非常简单的克隆方法，请忽略此答案。
换句话说，go with another answer unless you have a performance bottleneck that needs fixing, and you can prove it with a profiler。
比其他方法快 10 倍
以下执行深度克隆的方法是：
- 比任何涉及序列化/反序列化的方法快 10 倍；
- 非常接近 .NET 的理论最大速度。
还有方法……
为了获得极快的速度，您可以使用Nested MemberwiseClone 进行深层复制。它与复制值结构的速度几乎相同，并且比 (a) 反射或 (b) 序列化（如本页其他答案中所述）快得多。
请注意，如果您使用 Nested MemberwiseClone 进行深层复制，您必须为类中的每个嵌套级别手动实现 ShallowCopy，以及调用所有的 DeepCopy表示创建完整克隆的 ShallowCopy 方法。这很简单：总共只有几行，见下面的演示代码。
这是显示 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，以及一个 DeepCopy调用所有所说的 ShallowCopy 方法来创建一个完整的克隆。这很简单：总共只有几行代码，见上面的演示代码。
值类型与引用类型
请注意，在克隆对象时，“struct”和“class”之间存在很大差异：
见differences between value types and references types。
校验和帮助调试
- 错误地克隆对象会导致非常难以确定的错误。在生产代码中，我倾向于实施校验和来仔细检查对象是否已正确克隆，并且没有被另一个引用损坏。可以在发布模式下关闭此校验和。
- 我发现这种方法非常有用：通常，您只想克隆对象的一部分，而不是整个对象。
对于将许多线程与许多其他线程解耦非常有用
此代码的一个极好的用例是将嵌套类或结构的克隆提供给队列，以实现生产者/消费者模式。
- 我们可以让一个（或多个）线程修改他们拥有的类，然后将该类的完整副本推送到
ConcurrentQueue。
- 然后我们有一个（或多个）线程提取这些类的副本并处理它们。
这在实践中非常有效，并且允许我们将许多线程（生产者）与一个或多个线程（消费者）分离。
而且这种方法也非常快：如果我们使用嵌套结构，它比序列化/反序列化嵌套类快 35 倍，并且允许我们利用机器上所有可用的线程。
更新
显然，ExpressMapper 与上述手动编码一样快，甚至更快。我可能需要看看他们如何与分析器进行比较。