我想做一些事情，比如：
MyObject myObj = GetMyObj(); // Create and fill a new object
MyObject newObj = myObj.Clone();
然后对未反映在原始对象中的新对象进行更改。
我通常不需要这个功能，所以当有必要时，我会创建一个新对象，然后单独复制每个属性，但这总是让我觉得有更好或更优雅的方法来处理这种情况。
如何克隆或深度复制对象，以便在原始对象中不反映任何更改的情况下修改克隆的对象？
通常，您实现ICloneable接口并自己实现克隆。C#对象有一个内置的MemberwiseColone方法，该方法执行浅层复制，可以帮助您处理所有原语。
对于深度复制，它无法知道如何自动执行。
基本上，您需要实现ICloneable接口，然后实现对象结构复制。如果它是所有成员的深度拷贝，您需要确保（与您选择的解决方案无关）所有子级都是可克隆的。有时，在这个过程中，您需要注意一些限制，例如，如果您复制ORM对象，大多数框架只允许一个对象附加到会话，并且您不能克隆该对象，或者如果可能，您需要关注这些对象的会话附加。
干杯
简单的答案是从ICloneable接口继承，然后实现.clone函数。克隆应该按成员进行复制，并对任何需要它的成员执行深度复制，然后返回结果对象。这是一个递归操作（它要求您要克隆的类的所有成员都是值类型或实现ICloneable，并且它们的成员是值类型或者实现IClonea，依此类推）。
有关使用ICloneable克隆的详细说明，请参阅本文。
长篇大论的答案是“视情况而定”。正如其他人所提到的，ICloneable不受泛型支持，需要对循环类引用进行特殊考虑，并且实际上被一些人视为.NET Framework中的“错误”。序列化方法取决于对象是否可序列化，而这些对象可能不可序列化，并且您可能无法控制。对于哪种做法是“最佳”做法，社会上仍有很多争论。事实上，没有一个解决方案是适用于所有情况的一刀切的最佳实践，就像ICloneable最初被解释的那样。
请参阅本开发者角文章，了解更多选项（归功于Ian）。
虽然一种方法是实现ICloneable接口（在这里描述，所以我不会反悔），但这里有一个很好的深度克隆对象复制器，我不久前在代码项目中找到了它，并将其合并到我们的代码中。如其他地方所述，它要求您的对象是可序列化的。
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（）；。
EDIT（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);
}
不使用ICloneable的原因不是因为它没有通用接口。不使用它的原因是因为它很模糊。它不清楚你得到的是浅拷贝还是深拷贝；这取决于实施者。
是的，MemberwiseColone生成一个浅拷贝，但MemberwiseClone的反面不是克隆；可能是DeepClone，但它并不存在。当您通过对象的ICloneable接口使用对象时，您无法知道底层对象执行哪种克隆。（而且XML注释不会很清楚，因为您将得到接口注释，而不是对象的Clone方法上的注释。）
我通常只做一个Copy方法，它完全符合我的要求。
我提出这一点是为了克服.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();
}
}
}
我在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);
}
}
我也通过反思看到了它的实现。基本上，有一种方法可以遍历对象的成员，并将它们适当地复制到新对象中。当它到达引用类型或集合时，我认为它对自己进行了递归调用。反射是昂贵的，但效果很好。
复制所有公共财产的简单扩展方法。适用于任何对象，不要求类为[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 ) } );
}
};
}
下面是一个深度拷贝实现：
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;
}
遵循以下步骤：
使用返回T的只读Self属性和ICloneable＜out T＞定义ISelf＜T＞，ICloneale＜out T＜派生自ISelf＞并包含方法T Clone（）。然后定义一个CloneBase类型，该类型实现了一个受保护的虚拟泛型VirtualClone，将MemberwiseClone转换为传入的类型。每个派生类型都应该通过调用基本克隆方法来实现VirtualClone，然后执行所需的操作来正确克隆父VirtualClone方法尚未处理的派生类型的那些方面。
为了实现最大的继承通用性，公开公共克隆功能的类应该是密封的，但派生自一个基类，该基类在其他方面是相同的，除非缺少克隆。不要传递显式可克隆类型的变量，而是采用ICloneable＜theNonCloneableType＞类型的参数。这将允许期望Foo的可克隆衍生物与DerivedFoo的可克隆衍生物一起工作的例程，但也允许创建Foo的不可克隆衍生物。
在大量阅读了这里链接的许多选项以及这个问题的可能解决方案之后，我相信所有选项都在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
注意，如果我们对对象的数量进行计数，这里实现的克隆将保持正确的对象数量计数。
如果您已经在使用第三方应用程序（如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深度克隆示例。
我想要一个克隆器，用于非常简单的对象，主要是基元和列表。如果您的对象是开箱即用的JSON可串行化的，那么这个方法就可以了。这不需要修改或实现克隆类上的接口，只需要一个JSON序列化程序，如JSON.NET。
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);
}
}
这将把一个对象的所有可读写财产复制到另一个对象。
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);
我刚刚创建了CloneExtensions库项目。它使用表达式树运行时代码编译生成的简单赋值操作执行快速、深度克隆。
如何使用它？
不用在字段和财产之间使用赋值基调编写自己的Clone或Copy方法，而是让程序使用Expression Tree自己完成。标记为扩展方法的GetClone＜T＞（）方法允许您在实例上简单地调用它：
var newInstance = source.GetClone();
您可以使用CloningFlags枚举选择应该从源复制到newInstance的内容：
var newInstance
= source.GetClone(CloningFlags.Properties | CloningFlags.CollectionItems);
什么可以克隆？
原语（int、uint、byte、double、char等），已知不可变类型（DateTime、TimeSpan、String）和委托（包括动作、功能等）可为空T[]阵列自定义类和结构，包括泛型类和结构。
以下类/结构成员在内部克隆：
公共字段而非只读字段的值具有get和set访问器的公共财产的值实现ICollection的类型的集合项
它有多快？
该解决方案比反射更快，因为在GetClone＜T＞首次用于给定类型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方法吗？
我已经创建了一个可接受答案的版本，该版本同时适用于“[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;
}
}
在一个方法中重铸怎么样基本上应该调用自动复制构造函数
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>();
}
似乎对我有用
要克隆类对象，可以使用object.MemberswiseColone方法，
只需将此函数添加到类中：
public class yourClass
{
// ...
// ...
public yourClass DeepCopy()
{
yourClass othercopy = (yourClass)this.MemberwiseClone();
return othercopy;
}
}
然后要执行深度独立复制，只需调用DeepCopy方法：
yourClass newLine = oldLine.DeepCopy();
希望这有帮助。
编辑：项目已停止
如果您想真正克隆到未知类型，可以查看fastclone。
这是基于表达式的克隆，其工作速度比二进制序列化快10倍，并保持完整的对象图完整性。
这意味着：如果多次引用层次结构中的同一对象，克隆也将引用一个实例。
不需要对正在克隆的对象进行接口、属性或任何其他修改。
我喜欢这样的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));
}
}
如果您有更多内容要复制，请添加它们
如果您的对象树是可序列化的，您也可以使用以下内容
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;
}
请注意，此解决方案非常简单，但它不像其他解决方案那样高效。
请确保，如果类增长，仍然只有那些字段被克隆，这些字段也会被序列化。
使用IClonable接口可以花费多少精力是令人难以置信的，尤其是当您有大量的类层次结构时。MemberwiseColone的工作方式也很奇怪——它甚至不能完全克隆普通的List类型的结构。
当然，串行化最有趣的困境是串行化反向引用——例如，具有子-父关系的类层次结构。我怀疑二进制序列化程序能否在这种情况下帮助您。（最终将导致递归循环+堆栈溢出）。
不知怎么的，我喜欢这里提出的解决方案：如何在.NET（特别是C#）中对对象进行深度复制？
然而，它不支持Lists，并补充说，该支持还考虑到了重新养育子女的问题。对于我制定的仅为父项的规则，该字段或属性应命名为“parent”，则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
}
}
问：我为什么选择这个答案？
如果您想要.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与上面的手工编码一样快，甚至更快。我可能需要看看它们与探查器的比较。
当使用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);
}
}
这将检查[ProtoControl]属性的存在，并使用protobufs自己的格式化程序来序列化对象。
好的，这篇文章中有一些明显的反射示例，但反射通常很慢，直到你开始正确缓存它。
如果你能正确缓存它，那么它将以4.6s的速度深度克隆1000000个对象（由Watcher测量）。
static readonly Dictionary<Type, PropertyInfo[]> ProperyList = new Dictionary<Type, PropertyInfo[]>();
而不是获取缓存的财产或将新属性添加到字典并简单使用它们
foreach (var prop in propList)
{
var value = prop.GetValue(source, null);
prop.SetValue(copyInstance, value, null);
}
在另一个答案中查看我的帖子中的完整代码
https://stackoverflow.com/a/34365709/4711853
由于我在不同的项目中找不到满足我所有需求的克隆器，我创建了一个可以配置并适应不同代码结构的深度克隆器，而不是调整我的代码以满足克隆器的需求。这是通过向要克隆的代码添加注释来实现的，或者您只需保留代码的默认行为。它使用反射、类型缓存并基于fasterflect。对于大量数据和高对象层次结构（与其他基于反射/序列化的算法相比），克隆过程非常快。
https://github.com/kalisohn/CloneBehave
也可作为nuget包提供：https://www.nuget.org/packages/Clone.Behave/1.0.0
例如：以下代码将执行deepCloneAddress，但只执行_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
这个方法为我解决了问题：
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）；
保持简单，并使用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();
代码生成器
我们已经看到了很多想法，从序列化到手动实现再到反射，我想使用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;
}
}
注意：最新版本有更多的空检查，但为了更好地理解，我省略了它们。
这里有一个快速而简单的解决方案，不依赖于序列化/反序列化。
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();
}
最好是实现一个扩展方法，如
public static T DeepClone<T>(this T originalObject)
{ /* the cloning code */ }
然后在解决方案中的任何地方使用它
var copy = anyObject.DeepClone();
我们可以有以下三种实现：
按序列化（最短代码）通过反射-速度提高5倍通过表达式树-速度快20倍
所有相关的方法都运行良好，并经过了深入测试。
我想你可以试试这个。
MyObject myObj = GetMyObj(); // Create and fill a new object
MyObject newObj = new MyObject(myObj); //DeepClone it
我知道，这个问题和答案在这里停留了一段时间，下面不是很好的答案，而是观察，最近我在检查是否确实没有克隆隐私（如果没有，我就不会是我自己了；）时，我很高兴地复制了粘贴的@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。在这里和这里的代码中可以找到一些线索。
要旨
我知道这不是很常见的情况，示例代码有点滥用，但嘿！当我检查灌木丛中是否有龙在等着跳出来咬我的屁股时，我大吃一惊；）
映射器执行深度复制。为对象的每个成员创建一个新对象并分配其所有值。它递归地处理每个非基元内部成员。
我建议您选择目前发展最快、最活跃的产品之一。我建议使用UltraMapperhttps://github.com/maurosampietro/UltraMapper
Nuget软件包：https://www.nuget.org/packages/UltraMapper/
我找到了一种新的方法，那就是Emit。
我们可以使用Emit将IL添加到应用程序并运行它。但我认为这不是一个好方法，因为我想完善这一点，所以我写了我的答案。
Emit可以看到官方文件和指南
你应该学习一些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太难了，我做不到。
另一个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;
}
}
}
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()
通用方法在技术上都是有效的，但我只想补充一点，因为我们实际上很少需要真正的深度复制，我强烈反对在实际的业务应用程序中使用通用深度复制，因为这使得您可能会在许多地方复制对象，然后显式修改，这很容易丢失。
在大多数实际情况下，您还希望对复制过程进行尽可能多的粒度控制，因为您不仅耦合到数据访问框架，而且在实践中，复制的业务对象几乎不应该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
};
}
}
如果有人在研究如何在保持对复制过程的完全控制的同时构建对象实例化，这是我个人非常成功的解决方案。受保护的构造函数也使其成为可能，其他开发人员被迫使用工厂方法，该方法提供了一个简洁的单点对象实例化，封装了对象内部的构造逻辑。如果需要，您还可以重载该方法，并为不同的位置提供多个克隆逻辑。
由于这个问题的几乎所有答案都不令人满意，或者在我的情况下显然不起作用，我编写了AnyClone，它完全通过反思实现，并解决了这里的所有需求。我无法让序列化在结构复杂的复杂场景中工作，IClonable也不太理想——事实上，它甚至没有必要。
使用[IgnoreDataMember]、[NonSerialized]支持标准忽略属性。支持复杂集合、不带setter的财产、只读字段等。
我希望这能帮助其他遇到我同样问题的人。
深度克隆就是复制状态。对于.net state，表示字段。
假设有一个层次结构：
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
注意，所有新对象的随机字段都有随机值，但克隆与图像完全匹配
演示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
注意，事件支持字段也被复制，客户端也订阅了克隆的事件。
使用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所取代。
我不确定这是否适用于私人领域。
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）
免责声明：我是上述包裹的作者。
我很惊讶2019年这个问题的顶级答案仍然使用序列化或反射。
序列化是有限的（需要属性、特定构造函数等），而且非常慢
BinaryFormatter需要Serializable属性，JsonConverter需要无参数构造函数或属性，既不能很好地处理只读字段或接口，两者都比需要的慢10-30x。
表达式树
您可以改为使用表达式树或Reflection.Emit仅生成一次克隆代码，然后使用编译后的代码，而不是缓慢的反射或序列化。
我自己遇到了这个问题，但没有找到令人满意的解决方案，因此我决定创建一个包，它可以做到这一点，并且可以处理所有类型的代码，而且速度几乎与自定义编写的代码一样快。
您可以在GitHub上找到该项目：https://github.com/marcelltoth/ObjectCloner
用法
您可以从NuGet安装它。获取ObjectCloner包并将其用作：
var clone = ObjectCloner.DeepClone(original);
或者如果您不介意用扩展名污染对象类型，请获取ObjectCloner.extensions，并写下：
var clone = original.DeepClone();
表演
克隆类层次结构的简单基准测试显示，性能比使用Reflection快约3倍，比Newtonsoft.Json序列化快约12倍，比强烈建议的BinaryFormatter快约36倍。
最短的方式，但需要依赖：
using Newtonsoft.Json;
public static T Clone<T>(T source) =>
JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source));
对于克隆过程，可以先将对象转换为字节数组，然后再转换回对象。
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();
创建扩展：
public static T Clone<T>(this T theObject)
{
string jsonData = JsonConvert.SerializeObject(theObject);
return JsonConvert.DeserializeObject<T>(jsonData);
}
这样称呼：
NewObject = OldObject.Clone();
对@Konrad和@craastad的添加，使用内置的System.Text.Json for.NET>5
https://learn.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);
}
}
使用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);
}
}
C#9.0引入了需要记录的with关键字（谢谢Mark Nading）。这应该允许非常简单的对象克隆（如果需要，还可以进行突变），只需要很少的样板，但只需要一个记录。
您似乎无法通过将类放入通用记录来克隆（按值）类；
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
（令人难以置信的是，上面的方法可以正确地用于结构！https://dotnetfiddle.net/469NJv)
但克隆一条记录似乎确实可以按值进行缩进和克隆。
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://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/with-expression
我对当前的答案做了一些基准测试，发现了一些有趣的事实。
使用BinarySerializer=>https://stackoverflow.com/a/78612/6338072
使用XmlSerializer=>https://stackoverflow.com/a/50150204/6338072
使用Activator.CreateInstance=>https://stackoverflow.com/a/56691124/6338072
这些是结果
BenchmarkDotNet=v0.13.1, OS=Windows 10.0.18363.1734 (1909/November2019Update/19H2)
Intel Core i5-6200U CPU 2.30GHz（Skylake），1个CPU，4个逻辑核和2个物理核[主机]：.NET Framework 4.8（4.8.4400.0），X86 LegacyJIT默认作业：.NET Framework 4.8（4.8.4400.0），X86 LegacyJIT
| Method | Mean | Error | StdDev | Gen 0 | Allocated |
|---|---|---|---|---|---|
| BinarySerializer | 220.69 us | 4.374 us | 9.963 us | 49.8047 | 77 KB |
| XmlSerializer | 182.72 us | 3.619 us | 9.405 us | 21.9727 | 34 KB |
| Activator.CreateInstance | 49.99 us | 0.992 us | 2.861 us | 1.9531 | 3 KB |
我将使用下面的简单方法来实现这一点。只需创建一个抽象类和实现方法以再次序列化和反序列化并返回。
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();
}
除了这里的一些精彩答案外，您可以在C#9.0及更高版本中完成以下操作（假设您可以将类转换为记录）：
record Record
{
public int Property1 { get; set; }
public string Property2 { get; set; }
}
然后，只需使用with运算符将一个对象的值复制到新对象。
var object1 = new Record()
{
Property1 = 1,
Property2 = "2"
};
var object2 = object1 with { };
// object2 now has Property1 = 1 & Property2 = "2"
我希望这有助于：）
基于@craastad的答案，对于派生类。
在最初的答案中，如果调用者在基类对象上调用DeepCopy，则克隆的对象属于基类。但下面的代码将返回派生类。
using Newtonsoft.Json;
public static T DeepCopy<T>(this T source)
{
return (T)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(source), source.GetType());
}
如果使用net.core并且对象是可序列化的，则可以使用
var jsonBin = BinaryData.FromObjectAsJson(yourObject);
then
var yourObjectCloned = jsonBin.ToObjectFromJson<YourType>();
BinaryData在dotnet中，因此您不需要第三方库。它还可以处理类上的属性为Object类型的情况（属性中的实际数据仍然需要可序列化）
在我使用的代码库中，我们有一个来自GitHub项目Burtsev Alexey/net对象深度副本的ObjectExtension.cs文件副本。它已经9岁了。虽然我们后来意识到，对于更大的对象结构来说，它是非常慢的，但它还是有效的。
相反，我们在GitHub项目jpmikkers/Baksteen.Extensions.DeepCopy中找到了ObjectExtension.cs文件的一个分支。以前对大型数据结构的深度复制操作需要大约30分钟，现在感觉几乎是瞬间完成的。
此改进版本包含以下文档：
用于快速对象克隆的C#扩展方法。这是Alexey Burtsev深度复印机的速度优化叉。根据您的使用情况，这将比原始版本快2倍-3倍。它还修复了原始代码中存在的一些错误。与经典的二进制序列化/反序列化深度克隆技术相比，此版本的速度大约快七倍（对象包含的数组越多，加速因子越大）。通过以下技术实现加速：缓存对象反射结果不要深度复制原语或不可变结构&类（例如枚举和字符串）为了提高引用的局部性，处理内部循环中的“快速”维度或多维数组使用编译的lambda表达式调用MemberwiseClone如何使用：使用Baksteen.Extensions.DeepCopy；...var myobject=新建SomeClass（）；...var myclone=myobject.DepCopy（）！；//创建原始对象的新深度副本注意：只有在项目中启用了可为null的引用类型时，才需要感叹号（null原谅运算符）
