Sunday, May 27, 2012

Cloning objects in C#


I want to do something like...




myObject myObj = GetmyObj()//create and fill a new object
myObject newObj = myObj.Clone();



...and then make changes to the new object that are not reflected in the original object.



I don't often need this functionality so when it's been necessary I've resorted to creating a new object and then copying each property individually but it always leaves me with the feeling that there is a better/more elegant way of handling the situation.



How can I clone/deep copy an object so that the cloned object can be modified without any changes being reflected in the original object?


Source: Tips4all

15 comments:

  1. Whilst the standard practice is to inherit from ICloneable (described here, so I wont regurgitate), here's a nice Deep Clone Object copier I found on codeproject a while ago and incorporated it in our stuff.

    As mentioned above, it does require your objects to be Serializable

    /// <summary>
    /// Reference Article http://www.codeproject.com/KB/tips/SerializedObjectCloner.aspx
    ///
    /// Provides a method for performing a deep copy of an object.
    /// Binary Serialization is used to perform the copy.
    /// </summary>

    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);
    }

    IFormatter formatter = new BinaryFormatter();
    Stream stream = new MemoryStream();
    using (stream)
    {
    formatter.Serialize(stream, source);
    stream.Seek(0, SeekOrigin.Begin);
    return (T)formatter.Deserialize(stream);
    }
    }
    }


    The idea behind it is that it serializes your object, then deserializes it into a fresh object. The benefit is that you don't have to concern yourself about cloning everything when an object gets too complex.

    EDIT

    And with the use of extension methods (also from the originally referenced source):

    In case you prefer to use the new Extension methods of C# 3.0, change the method to have the following signature:

    public static T Clone<T>(this T source)
    {
    ...
    }


    Now the method call simply becomes objectBeingCloned.Clone();.

    ReplyDelete
  2. Here's a good resource I've used in the past: C# Object Cloning

    ReplyDelete
  3. The reason not to use ICloneable is not because it doesn't have a generic interface. The reason not to use it is because it's vague. It doesn't make clear whether you're getting a shallow or a deep copy; that's up to the implementer.

    Yes, MemberwiseClone makes a shallow copy, but the opposite of MemberwiseClone isn't Clone; it would be, perhaps, DeepClone, which doesn't exist. When you use an object through its ICloneable interface, you can't know which kind of cloning the underlying object performs. (And XML comments won't make it clear, because you'll get the interface comments rather than the ones on the object's Clone method.)

    What I usually do is simply make a Copy method that does exactly what I want.

    ReplyDelete
  4. I prefer a copy ctor to a clone. The intent is clearer.

    ReplyDelete
  5. Well I was having problems using ICloneable in Silverlight, but I liked the idea of seralization, I can seralize XML, so I did this:

    static public class SerializeHelper
    {
    //Michael White, Holly Springs Consulting, 2009
    //michael@hollyspringsconsulting.com

    public static T DeserializeXML<T>(string xmlData)
    where T:new()
    {
    if (string.IsNullOrEmpty(xmlData))
    return default(T);

    TextReader tr = new StringReader(xmlData);

    T DocItms = new T();

    XmlSerializer xms = new XmlSerializer(DocItms.GetType());

    DocItms = (T)xms.Deserialize(tr);


    return DocItms == null ? default(T) : DocItms;


    }

    public static string SeralizeObjectToXML<T>(T xmlObject)
    {
    StringBuilder sbTR = new StringBuilder();

    XmlSerializer xmsTR = new XmlSerializer(xmlObject.GetType());

    XmlWriterSettings xwsTR = new XmlWriterSettings();

    XmlWriter xmwTR = XmlWriter.Create(sbTR, xwsTR);

    xmsTR.Serialize(xmwTR,xmlObject);

    return sbTR.ToString();

    }

    public static T CloneObject<T>(T objClone)
    where T:new()
    {

    string GetString = SerializeHelper.SeralizeObjectToXML<T>(objClone);

    return SerializeHelper.DeserializeXML<T>(GetString);

    }



    }

    ReplyDelete
  6. Simple extension method to copy all public properties. Works for any objects and does not require class to be [Serializable]. Can be extended for other access level.

    public static void CopyTo( this object S, object T )
    {
    foreach( var pS in S.GetType().GetProperties() )
    {
    foreach( var pT in T.GetType().GetProperties() )
    {
    if( pT.Name != pS.Name ) continue;
    ( pT.GetSetMethod() ).Invoke( T, new object[] { pS.GetGetMethod().Invoke( S, null ) } );
    }
    };
    }

    ReplyDelete
  7. The short answer is you inherit from the ICloneable interface and then implement the .clone function. Clone should do a memberwise copy and perform a deep copy on any member that requires it, then return the resulting object. This is a recursive operation ( it requires that all members of the class you want to clone are either value types or implement ICloneable and that their members are either value types or implement ICloneable, and so on).

    For a more detailed explanation on Cloning using ICloneable, check out this article:

    http://www.ondotnet.com/pub/a/dotnet/2002/11/25/copying.html

    The long answer is "it depends". As mentioned by others, ICloneable is not supported by generics, requires special considerations for circular class references, and is actually viewed by some as a "mistake" in the .NET Framework. The serialization method depends on your objects being serializable, which they may not be and you may have no control over. There is still much debate in the community over which is the "best" practice. In reality, none of the solutions are the one-size fits all best practice for all situations like ICloneable was originally interpreted to be.

    See the this Developer's Corner article for a few more options (credit to Ian):
    http://developerscon.blogspot.com/2008/06/c-object-clone-wars.html

    ReplyDelete
  8. I came up with this to overcome .net shortcoming having to manually deep copy List.

    I use this:

    static public IEnumerable<SpotPlacement> CloneList(List<SpotPlacement> spotPlacements)
    {
    foreach (SpotPlacement sp in spotPlacements)
    {
    yield return (SpotPlacement)sp.Clone();
    }
    }


    And at another place:

    public object Clone()
    {
    OrderItem newOrderItem = new OrderItem();
    ...
    newOrderItem._exactPlacements.AddRange(SpotPlacement.CloneList(_exactPlacements));
    ...
    return newOrderItem;
    }


    I tried to come up with oneliner that does this, but it's not possible, due to yield not working inside anonymous method blocks.

    EDIT:

    Better still, use generic List cloner:

    class Utility<T> where T : ICloneable
    {
    static public IEnumerable<T> CloneList(List<T> tl)
    {
    foreach (T t in tl)
    {
    yield return (T)t.Clone();
    }
    }
    }

    ReplyDelete
  9. In general, you implement the ICloneable interface and implement Clone yourself.
    C# objects have a built-in MemberwiseClone method that performs a shallow copy that can help you out for all the primitives.

    For a deep copy, there is no way it can know how to automatically do it.

    ReplyDelete
  10. Basically you need to implement IClonable interface and then realize object structure copying.
    If it's deep copy of all members, you need to insure (not relating on solution you choose) that all children are clonable as well.
    Sometimes you need to be aware of some restriction during this process, for example if you copying the ORM objects most of frameworks allow only one object attached to the session and you MUST NOT make clones of this object, or if it's possible you need to care about session attaching of these objects.


    Cheers.

    ReplyDelete
  11. Here is a quick example that looks really interesting for duplicating memory...

    http://www.c-sharpcorner.com/UploadFile/sd_surajit/cloning05032007012620AM/cloning.aspx

    ReplyDelete
  12. I've seen it implemented through reflection as well. Basically there was a method that would iterate through the members of an object and appropriately copy them to the new object. When it reached reference types or collections I think it did a recursive call on itself. Reflection is expensive, but it worked pretty well.

    ReplyDelete
  13. Here is a deep copy implementation:

    public static object CloneObject(object opSource)
    {
    //grab the type and create a new instance of that type
    Type opSourceType = opSource.GetType();
    object opTarget = CreateInstanceOfType(opSourceType);

    //grab the properties
    PropertyInfo[] opPropertyInfo = opSourceType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

    //iterate over the properties and if it has a 'set' method assign it from the source TO the target
    foreach (PropertyInfo item in opPropertyInfo)
    {
    if (item.CanWrite)
    {
    //value types can simply be 'set'
    if (item.PropertyType.IsValueType || item.PropertyType.IsEnum || item.PropertyType.Equals(typeof(System.String)))
    {
    item.SetValue(opTarget, item.GetValue(opSource, null), null);
    }
    //object/complex types need to recursively call this method until the end of the tree is reached
    else
    {
    object opPropertyValue = item.GetValue(opSource, null);
    if (opPropertyValue == null)
    {
    item.SetValue(opTarget, null, null);
    }
    else
    {
    item.SetValue(opTarget, CloneObject(opPropertyValue), null);
    }
    }
    }
    }
    //return the new item
    return opTarget;
    }

    ReplyDelete
  14. Define an ISelf<T> with a read-only Self property that returns T, and ICloneable<out T>, which derives from ISelf<T> and includes a Clone() method that returns T. Then define a CloneBase type which implements a protected virtual generic VirtualClone which casts casting MemberwiseClone to the passed-in type. Each derived type should implement VirtualClone by calling the base clone method and then doing whatever needs to be done to properly clone those aspects of the derived type which the parent VirtualClone method hasn't yet handled.

    For maximum inheritance versatility, classes which should expose public cloning functionality should be sealed, but derive from a base class which is otherwise identical except for the lack of cloning. Rather than passing variables of the explicit clonable type, take a parameter of type ICloneable<theNonCloneableType>. This will ensure allow a routine that expects a cloneable derivative of Foo to work with a cloneable derivative of DerivedFoo, but also allow the creation of non-cloneable derivatives of Foo.

    ReplyDelete