Clone Serializable Objects

Introduction

Clone, anyone? Well, I need some cloning to retain old reference. Based on some guy's work he posted over the web, I manage to extend my love for generics and create a generic clone for serializable objects.

The Cloner

using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using RFFactory.Bus.SampleRunner.Abstracts;
 
namespace RFFactory.Bus.SampleRunner.Runners
{
    public class CloneRunner : SampleRunnerBase
    {
        #region Overrides of SampleRunnerBase
        /// <summary>
        /// Runs implementer object
        /// </summary>
        public override void RunSample()
        {
            FirstClone me = new FirstClone {FirstName = "Rizky", LastName = "Farhan"};
            FirstClone myOther = me;
            FirstClone myClone = me.Clone<FirstClone>();
            me.FirstName = "Rice Key";
            Console.WriteLine("Me :  {0}, {1}\nMy Other Reference: {2}, {3}\nMy Clone: {4}, {5}", me.FirstName,me.LastName,myOther.FirstName,myOther.LastName,myClone.FirstName,myClone.LastName);
 
    }
 
        /// <summary>
        /// Gets the execution order of Runner
        /// </summary>
        public override uint ExecutionOrder
        {
            get { return 15; }
        }
        #endregion
    }
 
    [Serializable]
    internal abstract class CloneBase
    {
        public T Clone<T>() where T : CloneBase
        {
            return DeserializeByte<T>(Serialize(this));
        }
 
        private static Byte[] Serialize<T>(T serializableData)
        {
            MemoryStream ms = null;
            Byte[] byteArray;
            try
            {
                BinaryFormatter serializer = new BinaryFormatter();
                ms = new MemoryStream();
                serializer.Serialize(ms, serializableData);
                byteArray = ms.ToArray();
            }
            finally
            {
                if (ms != null)
                {
                    ms.Close();
                }
            }
            return byteArray;
        }
 
        private static T DeserializeByte<T>(Byte[] serializedData)
        {
            MemoryStream ms = null;
            T deserialisedArray;
            try
            {
                BinaryFormatter serializer = new BinaryFormatter();
                ms = new MemoryStream();
                ms.Write(serializedData, 0, serializedData.Length);
                ms.Position = 0;
                deserialisedArray = (T)serializer.Deserialize(ms);
            }
            finally
            {
                if (ms != null)
                {
                    ms.Close();
                }
            }
            return deserialisedArray;
        }
    }
 
    [Serializable]
    internal class FirstClone : CloneBase
    {
        internal string FirstName
        {
            get;
            set;
        }
 
        internal string LastName
        {
            get;
            set;
        }
    }
 
    [Serializable]
    internal class SecondClone : CloneBase
    {
        internal IList<FirstClone> FirstClones
        {
            get;
            set;
        }
 
        internal string AllOtherNames
        {
            get;
            set;
        }
    }
 
}
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License