Consider this related question: Deep cloning objects
Is this really the best way to clone an object? (serialize/deserialize). Serialization seems a bit expensive to me.
My idea was to create a second constructor and just assign all variables. Would this approach be faster?
class Test
{
public Test(Test clone)
{
// clone ....
}
}
It depends on what do you want to clone and why. If a shallow clone is fine, then:
private static T CloneShallow<T>(T i) {
return
(T)i.GetType()
.GetMethod(
"MemberwiseClone",
BindingFlags.Instance | BindingFlags.NonPublic
).Invoke(i, null);
}
It's the fastest way to clone simple records of any type.
If you need full copy, but it's not time-critical, then:
private static T CloneFull<T>(T i) {
if (Object.ReferenceEquals(i, null)) return default(T);
var x = new XmlSerializer(i.GetType());
using (var m = new MemoryStream()) {
x.Serialize(m, i);
m.Seek(0, SeekOrigin.Begin);
return (T)x.Deserialize(m);
}
}
The second one is about 70 times slower than the first one.
If you need full copy and the speed is important, consider using protobuf-net as serializer.
There's a lot of answers involving modification of the object you wish to clone, but often you just need to clone a simple record and you don't want to implement anything on it.
And if you wonder how slow CloneFull() is - on my computer (i5 661 @ 3.33GHz) with very simple record it took 360 ticks, which gives 36ns. Which is fast enough in most cases :)
The key phrase is in the accepted answer
The benefit is that you don't have to concern yourself about cloning everything when an object gets too complex.
The serialisation method works for any object of any complexity. While it might well be overkill for smaller, simpler objects it's a scaleable solution.
If you know your object's not going to change and you only want to clone simple objects then your approach is perfectly acceptable. Though implementing the ICloneable interface is the preferred solution.
The question to which you are referring talks about generic cloning that works for anything that supports serialization. When you want cloning just for your specific object, simply implement ICloneable.
class Test : ICloneable {
public object Clone() {
// clone ....
}
}
Serializing is only particularly useful for storing a representation of an object you want to retrieve later/elsewhere. There is an ICloneable interface you should implement if you want an object be able to clone.
to quote:
Supports cloning, which creates a new instance of a class with the same value as an existing instance. The ICloneable interface contains one member, Clone, which is intended to support cloning beyond that supplied by MemberwiseClone. For more information about cloning, deep versus shallow copies, and examples, see the Object.MemberwiseClone method.
If you are talking about using a custom class, the best way is to implement ICloneable. This way your class can provide a standardized way to clone itself.
There are some times when using a 'copy constructor' can be better, but usually only if you can see that it would be simple, and ICloneable doesn't meet your needs adequately.
