我对当前的答案做了一些基准测试，发现了一些有趣的事实。

使用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

通常，您实现ICloneable接口并自己实现克隆。C#对象有一个内置的MemberwiseColone方法，该方法执行浅层复制，可以帮助您处理所有原语。

对于深度复制，它无法知道如何自动执行。

我刚刚创建了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方法吗？

不使用ICloneable的原因不是因为它没有通用接口。不使用它的原因是因为它很模糊。它不清楚你得到的是浅拷贝还是深拷贝；这取决于实施者。

是的，MemberwiseColone生成一个浅拷贝，但MemberwiseClone的反面不是克隆；可能是DeepClone，但它并不存在。当您通过对象的ICloneable接口使用对象时，您无法知道底层对象执行哪种克隆。（而且XML注释不会很清楚，因为您将得到接口注释，而不是对象的Clone方法上的注释。）

我通常只做一个Copy方法，它完全符合我的要求。

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

在一个方法中重铸怎么样基本上应该调用自动复制构造函数

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

似乎对我有用