对象深度克隆实现

Question

我必须实现通用扩展 deepclone 方法，该方法可以与任何引用类型实例一起使用以获取其深层副本。我将其实现为以下

static class ClassCopy
{
    static public T DeepClone<T> (this T instance)
    {
        if (instance == null) return null;
        var type = instance.GetType();
        T copy;
        var flags = BindingFlags.FlattenHierarchy | BindingFlags.Public | BindingFlags.NonPublic |
                    BindingFlags.Instance;

        var fields = type.GetFields(flags);

        // If type is serializable - create instance copy using BinaryFormatter
        if (type.IsSerializable)
        {
            using (var stream = new MemoryStream())
            {
                var formatter = new BinaryFormatter();
                formatter.Serialize(stream, instance);
                stream.Position = 0;
                copy = (T) formatter.Deserialize(stream);
            }

            // Copy all fiels  which are not marked as serializable 
            foreach (var field in fields)
            {
                if (!field.IsNotSerialized) continue;
                var value = field.GetValue(instance);

                //Recursion!!!
                //for each embedded object also create deep copy
                value = value != null  ? value.DeepClone() : value;
                field.SetValue(copy, value);
            }
        }
        else
        {
            // If type is not serializable - create instance copy using Activator
            //(if there is default constructor)
            // or FormatterServices ( if there is no constractor)

            copy = CreateInstance<T>(type);
            foreach (var field in fields)
            {
                var value = field.GetValue(instance);

                //Recursion!!!
                value = value != null  ? value.DeepClone() : value;
                field.SetValue(copy, value);
            }
        }

        //Copy all properties 
        //In order to copy all backing fields  for auto-implemented properties

        var properties = type.GetProperties(flags|BindingFlags.SetProperty);
        foreach (var property in properties)
        {
            if (property.CanWrite)
            {
                var value = property.GetValue(instance);

                //Recursion!!!
                value = value != null ? value.DeepClone() : null;
                property.SetValue(copy, value);
            }
        }
        return copy;
    }

    private static T CreateInstance<T>(Type t) where T: class
    {
        T instance;
        var constructor = t.GetConstructor(Type.EmptyTypes);
        if (constructor != null)
        {
            instance = Activator.CreateInstance(t) as T;
            return instance;
        }
        instance = FormatterServices.GetUninitializedObject(t) as T;
        return instance;
    }
}

效果很好。但是，如果要克隆的对象及其引用类型字段具有相互引用，则此代码会导致无限循环。 例如

private static void Main(string[] args)
{
    var parent = new Parent();
    parent.Child = new Child();
    parent.Child.Parent = parent;
    //Infinite Loop!!!
    var parent1 = parent.DeepClone();
}

class Parent
{
    public Child Child { get; set; }
}
class Child
{
    public Parent Parent { get; set; }
}

有谁知道如何实现这个任务？它应该按字面意思实施，不允许有任何变化（这是一个实习）。非常感谢任何提示！

Answer 1

深度克隆对象的一个​​老技巧是序列化和反序列化它们，从而创建新实例。

public T deepClone<T>(T toClone) where T : class
{
    string tmp = JsonConvert.SerializeObject(toClone);
    return JsonConvert.DeserializeObject<T>(tmp);            
}

我与Newtonsoft.Json 进行了广泛的合作，它为您的问题提供了内置解决方案。默认情况下，它会检测对象是否已经被序列化并抛出异常。但是，您可以将其配置为序列化对对象的引用以绕过循环引用。它不是内联序列化对象，而是序列化对该对象的引用，并保证对对象的每个引用只序列化一次。

此外，默认情况下仅序列化公共字段/属性。还有一个用于序列化私有字段的附加设置。

public T deepClone<T>(T toClone) where T : class
{
    JsonSerializerSettings settings = new JsonSerializerSettings();
    settings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;

    DefaultContractResolver dcr = new DefaultContractResolver();
    dcr.DefaultMembersSearchFlags |= System.Reflection.BindingFlags.NonPublic;
    settings.ContractResolver = dcr;

    string tmp = JsonConvert.SerializeObject(toClone, settings);
    return JsonConvert.DeserializeObject<T>(tmp);
}

因此，您可以“作弊”并使用这样的代码，也可以复制它的工作原理来实现保留引用的克隆。您给出的父母/孩子的例子只是一种难以克隆的方式。 1对多是另一个。

Answer 2

您可以做的是传递映射到其克隆的项目的Dictionary。现在该方法将如下所示：

static private T DeepClone<T> (this T instance, IDictionary<object, object> originalToAlreadyCloned) where T: class

现在您在if (instance == null) return null; 之后要做的第一件事是检查instance 是否存在于originalToAlreadyCloned 中，如果存在，则返回它。

为了填充它，在

之后

1. copy = (T) formatter.Deserialize(stream);
2. copy = CreateInstance<T>(type);

致电originalToAlreadyCloned.Add(instance, copy);

最后，提供一个新的顶层方法：

static private T DeepClone<T> (this T instance) where T: class 简单地调用DeepClone(instance, new Dictionary<object, object>());

顺便说一句，value = value != null && value.GetType().IsClass? value.DeepClone() : null; 似乎是错误的。您的意思是，如果value 不是一个类，请将其设置为空。但是如果不是类，一般不能设置为null。我不知道你为什么不只克隆这些项目，以及为什么 DeepClone 仅限于类。