Implement Copy constructor using Serialization or Reflecton

and was adviced by Tim Hibbard to use reflection like this.
 
I’ve created Copy method to copy Fields(not only properties, and found that  the private fields of any base class are not copied.
The article Where are my fields? « Andrew Smith explains that it’s required to iterate base classes.
But when looking in the Google for the solution,I’ve found the suggestion for serializable objects:
 




MemberInfo
[]
sm
=
FormatterServices
.
GetSerializableMembers
(
typeof
(
From
));






 object[] data =FormatterServices.GetObjectData(from, sm);





 FormatterServices.PopulateObjectMembers(to, sm, data);


 



It seems to solve my requirement better than the reflection approach:


 


 

        ///<summary>
        /// Inspired by http://geekswithblogs.net/thibbard/archive/2007/05/04/Architecture-thoughts-and-Reflection.aspx
        ///</summary>
        ///<param name="from"></param>
        ///<param name="from"></param>
        ///<returns></returns>
        publicstaticbool CopyFleldsFromBaseClass(object from,object to)
        {
            bool rv = false;
            try
            {
                if (from == null)
                {
                    thrownewApplicationException("from is null");
                }
                if (to == null)
                {
                    thrownewApplicationException("to is null");
                }
                //http://agsmith.wordpress.com/2007/12/13/where-are-my-fields/
                System.Type typeFrom = from.GetType();
                System.Type typeTo = from.GetType();
                BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public ;
                //Debug.Assert(typeTo is typeFrom);
                //iterate through each property of this
                foreach (FieldInfo prop in typeFrom.GetFields(bindingFlags))
                {
                    //get the name of the current property
                    string memberName = prop.Name;
                    //make sure this property is writeable and the obj property is readable
                    //if (prop.CanRead && to.GetType().GetFields(memberName).CanWrite)
                    if (typeTo.GetField(memberName, bindingFlags) != null)
                    {
                        //Get the value of this current property from obj
                        object objValue = typeFrom.GetField(memberName, bindingFlags).GetValue(from);
                        //Set the value of this property from obj
                        prop.SetValue(to, objValue);
                    }
                }
                //if we are here, everything worked
                rv = true;
            }
            catch (Exception exc)
            {
                Debug.Assert(false,exc.ToString());
 
                //something bad happened, return false
                rv = false;
            }
            return rv;
        }
 
By the way, my original idea was to create a derived class, when I have an object of base class. 
Later I understood that it's better to create the derived object using factory at the start, 
rather than create the base class and then convert it to derived one. 
Related link on Rick Strahl's Blog    Simplistic Object Copying in .NET
Similar Reflection approach to implement ToString is described here

Advertisements