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

代码生成器

我们已经看到了很多想法，从序列化到手动实现再到反射，我想使用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;
    }
}

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

编辑：项目已停止

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

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

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

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

基本上，您需要实现ICloneable接口，然后实现对象结构复制。如果它是所有成员的深度拷贝，您需要确保（与您选择的解决方案无关）所有子级都是可克隆的。有时，在这个过程中，您需要注意一些限制，例如，如果您复制ORM对象，大多数框架只允许一个对象附加到会话，并且您不能克隆该对象，或者如果可能，您需要关注这些对象的会话附加。

干杯

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

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

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

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

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

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

我希望这能帮助其他遇到我同样问题的人。