8

首先，我们可能都同意最好的方法是在自定义对象/实体中实现 Copy 功能。但是考虑一下这种情况。我们没有这个选项，我们不想编写将精确复制实体的特定函数，因为将来实体将被更改，因此我们的复制函数将失败。

这是当前实体的简化版本：

[Serializable]
class MyEntity
{
    public MyEntity()
    { 
    }

    public MyEntity(int id, string name)
    {
        this.Id = id;
        this.Name = name; 
    }

    public int Id { get; set; }

    public string Name { get; set; }

    public MyEntity Copy()
    {
        throw new NotImplementedException();
    }
}

为了满足上述所有要求，我提出了两个解决方案：

        //original...
        MyEntity original = new MyEntity() { Id = 1, Name = "demo1" };

        //first way to copy object...
        List<MyEntity> list = new List<MyEntity>() { original};
        MyEntity copy1 = list.ConvertAll(entity => new MyEntity(entity.Id, entity.Name))[0];

        //second way to copy object...
        byte[] bytes = SerializeEntity(original);
        MyEntity copy2 = (MyEntity)DeserializeData(bytes);


    byte[] SerializeEntity(object data)
    {
        byte[] result = null;
        using (MemoryStream ms = new MemoryStream())
        {
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(ms, data);
            result = ms.ToArray();
        }
        return result;
    }

    object DeserializeData(byte[] data)
    {
        object result = null;
        using(MemoryStream ms = new MemoryStream(data))
        {
           BinaryFormatter formatter = new BinaryFormatter();
           result = formatter.Deserialize(ms); 
        }
        return result;
    }

现在的问题。幕后最佳解决方案是什么，为什么是第一还是第二？考虑到上述要求，有没有更好的方法来进行精确复制？将大量复制。

PS注意： 我知道第一种方式基本上已经是Honza指出的复制功能。我有点像序列化和自定义复制功能一样快的东西。

4

3 回答 3

7

首先，我们可能都同意最好的方法是在自定义对象/实体中实现 Copy 功能。

我不同意。我讨厌每次都写这样的方法。这是我使用扩展方法的建议：

public static T Copy<T>(this T obj)
    where T : class
{
    using (MemoryStream stream = new MemoryStream())
    {
        BinaryFormatter formatter = new BinaryFormatter();
        formatter.Serialize(stream, obj);

        stream.Seek(0, SeekOrigin.Begin);
        return formatter.Deserialize(stream) as T;
    }
}

这基本上是您的第二个解决方案，但略有优化。无需将 MemoryStream 复制到字节数组，然后从中创建另一个 MemoryStream。

最好的事情是它是通用的，可以与具有该[Serializable]属性的每个对象一起使用。而且我很确定它比您必须访问每个属性的第一个解决方案更快（尽管我没有测量）。

编辑：

好的，我现在确实做了一些测量。我对性能的第一个假设是完全错误的！

我用随机值创建了 1000000 个 MyEntity 对象，然后复制了它们（我还考虑Honza Brestan了关于深拷贝和浅拷贝的提示）：

带二进制格式化程序的
深拷贝：14.727 秒 带复制方法的深拷贝：0.490 秒
带反射的浅拷贝：5.499 秒
带复制方法的浅拷贝：0.144 秒

于 2012-12-23T01:19:04.833 回答
1

第一次尝试和编写自己的 Copy 方法有什么区别？

public MyEntity Copy()
{
    return new MyEntity(this.Id, this.Name);
}

对我来说，这看起来比你的收集尝试更好，无论如何它完全一样 - 在这两种情况下你都必须明确命名所有属性。

如果你不能修改实体类本身，你仍然可以创建一个扩展方法（放置在一个你想使用复制逻辑的地方可见的静态类中）

public static MyEntity Copy(this MyEntity source)
{
    return new MyEntity(source.Id, source.Name);
}

至于第二次尝试，你考虑过两者的不同吗？它们并不完全相同。第一个创建一个浅拷贝，而第二个（假设整个对象树是可序列化的）产生一个深拷贝。不同之处在于它的属性是否也被复制，或者原始对象和它的副本都引用相同的对象。这同样适用于 pescolino 的版本，顺便说一句，它看起来非常不错。

所以问题是你想要/需要哪个副本。

对于真正动态（但可能不太有效）的浅拷贝方法，我认为您需要使用反射，枚举所有属性并将它们的值从原始对象复制到副本。非完整的演示版本可能如下所示：

public static MyEntity Copy(this MyEntity source)
{
    var result = new MyEntity();

    var properties = source.GetType().GetProperties(
          BindingFlags.Instance | BindingFlags.Public);

    foreach (var property in properties)
    {
        var val = property.GetValue(source, null);
        property.SetValue(result, val, null);
    }

    return result;
}

这种方法有其自身的问题，即性能，偶尔需要处理特殊情况（索引器，非公共属性......），但可以完成工作并且也适用于不可序列化的对象。通用版本也很容易做到——这取决于你，你是否需要它。

同样值得注意的是，因为我和 pescolino 都建议使用扩展方法，所以它们可能存在问题。如果您的实体确实包含Copy与扩展具有相同签名的方法，编译器将决定使用它而不是扩展。这显然会NotImplementedException在调用时抛出。因此，如果是这种情况（而且不仅仅是您的示例代码），它可能是一个严重的“陷阱”。在这种情况下，唯一的解决方案是更改扩展方法的签名，最好是更改其名称。

于 2012-12-23T01:45:28.630 回答
1

您可以尝试使用AutoMapper：

Mapper.CreateMap<MyEntity, MyEntity>();

...

var copy3 = Mapper.Map<MyEntity, MyEntity>(original);
于 2012-12-23T04:28:35.930 回答