我提出这一点是为了克服.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();
        }
    }
}

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

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

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

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

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

遵循以下步骤：

使用返回T的只读Self属性和ICloneable＜out T＞定义ISelf＜T＞，ICloneale＜out T＜派生自ISelf＞并包含方法T Clone（）。然后定义一个CloneBase类型，该类型实现了一个受保护的虚拟泛型VirtualClone，将MemberwiseClone转换为传入的类型。每个派生类型都应该通过调用基本克隆方法来实现VirtualClone，然后执行所需的操作来正确克隆父VirtualClone方法尚未处理的派生类型的那些方面。

为了实现最大的继承通用性，公开公共克隆功能的类应该是密封的，但派生自一个基类，该基类在其他方面是相同的，除非缺少克隆。不要传递显式可克隆类型的变量，而是采用ICloneable＜theNonCloneableType＞类型的参数。这将允许期望Foo的可克隆衍生物与DerivedFoo的可克隆衍生物一起工作的例程，但也允许创建Foo的不可克隆衍生物。

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

下面是一个深度拷贝实现：

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