代码生成器

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

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

深度克隆就是复制状态。对于.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

注意，事件支持字段也被复制，客户端也订阅了克隆的事件。

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 T DeepClone<T>(this T originalObject)
{ /* the cloning code */ }

然后在解决方案中的任何地方使用它

var copy = anyObject.DeepClone();

我们可以有以下三种实现：

按序列化（最短代码）通过反射-速度提高5倍通过表达式树-速度快20倍

所有相关的方法都运行良好，并经过了深入测试。

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

通用方法在技术上都是有效的，但我只想补充一点，因为我们实际上很少需要真正的深度复制，我强烈反对在实际的业务应用程序中使用通用深度复制，因为这使得您可能会在许多地方复制对象，然后显式修改，这很容易丢失。

在大多数实际情况下，您还希望对复制过程进行尽可能多的粒度控制，因为您不仅耦合到数据访问框架，而且在实践中，复制的业务对象几乎不应该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
            };
        }
    }

如果有人在研究如何在保持对复制过程的完全控制的同时构建对象实例化，这是我个人非常成功的解决方案。受保护的构造函数也使其成为可能，其他开发人员被迫使用工厂方法，该方法提供了一个简洁的单点对象实例化，封装了对象内部的构造逻辑。如果需要，您还可以重载该方法，并为不同的位置提供多个克隆逻辑。