深度克隆对象

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.

---

6 年前已关闭。

• 编辑问题以包含所需行为、特定问题或错误以及重现问题所需的最短代码。这将有助于其他人回答问题。
• 我们不允许提出寻求软件库、教程、工具、书籍或其他场外资源推荐的问题。您可以编辑问题，以便用事实和引文来回答。

Answer 1

我可以建议几种方法，但它们实施起来并不一定超级简单。我个人选择的两种方法是：

1. 使用代码生成（例如 T4）来生成克隆对象图的代码。 T4 是 Visual Studio 2008 和 Visual Studio 2010 的一部分，Oleg Sych 有一些很棒的 T4 文档： http://www.olegsych.com/2007/12/text-template-transformation-toolkit/

2. 使用System.Linq.Expression 在运行时生成克隆对象的委托。一般来说，由于 GetValue/SetValue 的原因，反射速度很慢。然而，System.Linq.Expression 允许您从反射生成针对您的类“硬编码”的方法。然后，您可以缓存这些方法，从而只需为反射付出一次代价。

这两种方法都应该为您提供与手动编码深度克隆逻辑相当的性能。

使深度克隆的生活变得复杂的事情：

1. 接口字段
2. 抽象类字段
3. 具有私有构造函数的类（有关帮助，请参阅 http://msdn.microsoft.com/nb-no/library/system.runtime.serialization.formatterservices.getuninitializedobject.aspx)
4. 集合字段

编写成熟的深度克隆程序是有点毛茸茸的，但当你知道你的领域时，你也许可以对问题做一些简化。

附言。我个人更喜欢 T4 而不是 System.Linq.Expression，因为它不那么“神奇”

Answer 2

如果您可以接受稍微装饰一下对象图，您可以使用 protobuf-net。
（例如，您可以使用 nuget 获取它）

一个简单的示例：

[Serializable]
[ProtoContract]
public class TestObject
{
    [ProtoMember(1)]
    public string TestProperty { get; set; }
}

public static class ObjectCopier
{
    /// <summary>
    /// Perform a deep Copy of the object.
    /// </summary>
    /// <typeparam name="T">The type of object being copied.</typeparam>
    /// <param name="source">The object instance to copy.</param>
    /// <returns>The copied object.</returns>
    public static T Clone<T>(T source)
    {
        if (!typeof(T).IsSerializable)
        {
            throw new ArgumentException("The type must be serializable.", "source");
        }

        // Don't serialize a null object, simply return the default for that object
        if (Object.ReferenceEquals(source, null))
        {
            return default(T);
        }

        Stream stream = new MemoryStream();
        using (stream)
        {
            Serializer.Serialize<T>(stream, source);
            stream.Seek(0, SeekOrigin.Begin);
            return Serializer.Deserialize<T>(stream);
        }
    }
}

注意：序列化器实际上有一个 DeepClone 方法，该方法似乎适合于此，但我发现它比执行序列化和反序列化要慢。

更新：
关于马克的问题，这确实看起来很奇怪。这是我的（非常有限的）测试，使用深度克隆似乎始终慢 30% 左右。 （注意：即使以不同的顺序运行测试并且不并行运行它们）

    [TestMethod]
    public void TestWithStream()
    {
        var objects = Enumerable.Range(0, 1000000).Select(_ => new TestObject { TestProperty = Guid.NewGuid().ToString() }).ToList();

        Stopwatch w = Stopwatch.StartNew();

        for (int i = 0; i < objects.Count; ++i)
        {
            ObjectCopier.CloneWithStream(objects[i]);
        }
        Console.WriteLine(w.Elapsed);
    }

    [TestMethod]
    public void TestWithDeepClone()
    {
        var objects = Enumerable.Range(0, 1000000).Select(_ => new TestObject { TestProperty = Guid.NewGuid().ToString() }).ToList();

        Stopwatch w = Stopwatch.StartNew();

        for (int i = 0; i < objects.Count; ++i)
        {
            ObjectCopier.CloneWithDeepClone(objects[i]);
        }
        Console.WriteLine(w.Elapsed);
    }

    public static class ObjectCopier
    {
        public static T CloneWithStream<T>(T source)
        {
            if (!typeof(T).IsSerializable)
            {
                throw new ArgumentException("The type must be serializable.", "source");
            }

            if (Object.ReferenceEquals(source, null))
            {
                return default(T);
            }

            Stream stream = new MemoryStream();
            using (stream)
            {
                Serializer.Serialize<T>(stream, source);
                stream.Seek(0, SeekOrigin.Begin);
                return Serializer.Deserialize<T>(stream);
            }
        }

        public static T CloneWithDeepClone<T>(T source)
        {
            if (!typeof(T).IsSerializable)
            {
                throw new ArgumentException("The type must be serializable.", "source");
            }

            if (Object.ReferenceEquals(source, null))
            {
                return default(T);
            }

            return Serializer.DeepClone(source);
        }
    }

Answer 3

如果不使用通用序列化程序（例如 BinaryFormatter）或为整个层次结构实现手动复制，则无法创建通用 clr 对象的深层副本。如果 BinaryFormatter 太慢，您必须要么退回到手动序列化，要么找到/实现更快的格式化程序。请注意，大多数 protobuf 实现无法在一般对象图（序列化委托、单例、空集合等）中开箱即用。因此，首先调查您的图是否允许 protobuf 序列化，您可能可以使用 BinaryFormatter 进行序列化，并在可能的情况下对某些子图使用 protobuf 或手动二进制写入（使用 ISerialized 存储）

Answer 4

您可以使用反射来获取对象的所有私有字段。创建一个函数来循环访问对象的私有字段。获取任何值类型并复制该值。如果该对象支持 ICloneable 接口，则调用该接口。对类中的引用类型递归调用此克隆函数。

编辑，这是代码：我相信我从互联网上的某个地方获得了 CloneDictionary，但我现在不记得在哪里了。另外，我刚刚将其从 VB.net 转换为 C#。

  public static object GenericClone(object Obj)
{


object Out = null;
Out = Activator.CreateInstance(Obj.GetType());

Type mytype = Obj.GetType();
while (mytype != null) {

    foreach (System.Reflection.FieldInfo item in mytype.GetFields(System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)) {
        object itemValue = item.GetValue(Obj);
        object newvalue = null;
        if (itemValue != null) {
            if (typeof(System.ICloneable).IsAssignableFrom(itemValue.GetType())) {
                newvalue = ((System.ICloneable)itemValue).Clone();
            } else {
                if (itemValue.GetType().IsValueType) {
                    newvalue = itemValue;
                } else {
                    if (itemValue.GetType().Name == "Dictionary`2") {
                        newvalue = DataInterface.CloneDictionary(itemValue);
                    } else if (object.ReferenceEquals(itemValue.GetType(), typeof(System.Text.StringBuilder))) {
                        newvalue = new System.Text.StringBuilder(((System.Text.StringBuilder)itemValue).ToString());
                    } else if (itemValue.GetType().Name == "List`1") {
                        newvalue = DataInterface.CloneList(itemValue);
                    } else {
                        throw (new Exception(item.Name + ", member of " + mytype.Name + " is not cloneable or of value type."));
                    }
                }
            }
        }
        //set new obj copied data
        mytype.GetField(item.Name, System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance).SetValue(Out, newvalue);
    }
    //must move up to base type, GetFields does not return inherited fields
    mytype = mytype.BaseType;
}

return Out;
}

public static Dictionary<K, V> CloneDictionary<K, V>(Dictionary<K, V> dict)
{
Dictionary<K, V> newDict = null;

// The clone method is immune to the source dictionary being null.
if (dict != null) {
    // If the key and value are value types, clone without serialization.
    if (((typeof(K).IsValueType || object.ReferenceEquals(typeof(K), typeof(string))) && (typeof(V).IsValueType) || object.ReferenceEquals(typeof(V), typeof(string)))) {
        newDict = new Dictionary<K, V>();
        // Clone by copying the value types.
        foreach (KeyValuePair<K, V> kvp in dict) {
            newDict[kvp.Key] = kvp.Value;
        }
    } else {
        newDict = new Dictionary<K, V>();
        // Clone by copying the value types.
        foreach (KeyValuePair<K, V> kvp in dict) {
            newDict[kvp.Key] = DataInterface.GenericClone(kvp.Value);
        }
    }
}

return newDict;
}

public static List<T> CloneList<T>(List<T> list)
{

List<T> Out = new List<T>();
if (typeof(System.ICloneable).IsAssignableFrom(typeof(T))) {
    return (from x in list(T)((ICloneable)x).Clone()).ToList;
} else if (typeof(T).IsValueType) {
    return (from x in list(T)x).ToList;
} else {
    throw new InvalidOperationException("List elements not of value or cloneable type.");
}

}