如果您的对象树是可序列化的，您也可以使用以下内容

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

请注意，此解决方案非常简单，但它不像其他解决方案那样高效。

请确保，如果类增长，仍然只有那些字段被克隆，这些字段也会被序列化。

当使用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自己的格式化程序来序列化对象。

我知道，这个问题和答案在这里停留了一段时间，下面不是很好的答案，而是观察，最近我在检查是否确实没有克隆隐私（如果没有，我就不会是我自己了；）时，我很高兴地复制了粘贴的@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。在这里和这里的代码中可以找到一些线索。

要旨

我知道这不是很常见的情况，示例代码有点滥用，但嘿！当我检查灌木丛中是否有龙在等着跳出来咬我的屁股时，我大吃一惊；）

在我使用的代码库中，我们有一个来自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原谅运算符）

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

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

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

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

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

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