/// <summary>
        /// Attempt to convert one object to another via deserialization
        /// </summary>
        /// <typeparam name="T">Destination type</typeparam>
        /// <param name="target">Object to convert</param>
        /// <returns>A new object of the Destination type</returns>
        public static T convert<T>( object target ) where T : new()
        {
            T returnValue;
            try
            {
                XmlDocument sourceDocument = serialize( target );
                XmlAttribute attribute = sourceDocument.CreateAttribute("xmlns");
                
                attribute.Value = getSerializedNamespace( typeof(T) );
                sourceDocument.DocumentElement.SetAttributeNode(attribute);
                
                returnValue = deSerialize<T>( sourceDocument );
            }
            catch
            {
                returnValue = new T();
            }
            return returnValue;
        }
 
 
        /// <summary>
        /// Serializes an object to an XML string
        /// </summary>
        /// <param name="target">Object to be serialized</param>
        /// <returns>string containing the serialized object</returns>
        public static string serializeToString( object target )
        {
            return serializeToString( target, null );
        }
 
        /// <summary>
        /// Serializes an object to an XML string
        /// </summary>
        /// <param name="target">Object to be serialized</param>
        /// <param name="namespaces">Namespaces to add to the document</param>
        /// <returns>string containing the serialized object</returns>
        public static string serializeToString( object target, XmlSerializerNamespaces namespaces )
        {
            string returnValue = null;
            if ( null != target )
            {
                XmlSerializer serializer = new XmlSerializer( target.GetType() );
                using (MemoryStream stream = new MemoryStream())
                {
                    XmlWriterSettings settings = new XmlWriterSettings();
                    settings.Encoding = Encoding.UTF8;
 
                    using (XmlWriter writer = XmlWriter.Create( stream, settings ))
                    {
                        if ( null != namespaces )
                        {
                            serializer.Serialize( writer, target, namespaces );
                        }
                        else
                        {
                            serializer.Serialize( writer, target );
                        }
                    }
                    returnValue = Encoding.UTF8.GetString( stream.ToArray() ).Trim();
                }
            }
            return returnValue;
        }
 
        /// <summary>
        /// Serialize an object to an XML Document
        /// </summary>
        /// <param name="target">Object to be serialized</param>
        /// <returns>XmlDocument containing the serialized object</returns>
        public static XmlDocument serialize( object target )
        {
            XmlDocument returnValue = new XmlDocument();
            if ( null != target )
            {
                returnValue.LoadXml( serializeToString( target ) );
            }
            return returnValue;
        }
 
        /// <summary>
        /// Factory method for deserializing an object from an XML document
        /// </summary>
        /// <param name="sourceDocument">document to deserialize</param>
        /// <returns>Object from deserialized XML Document</returns>
        public static T deSerialize<T>( XmlDocument sourceDocument )
        {
            T returnValue;
 
            XmlSerializer deserializer = new XmlSerializer( typeof(T) );
 
            using (MemoryStream stream = new MemoryStream( Encoding.UTF8.GetBytes( sourceDocument.DocumentElement.OuterXml ) ))
            {
                    object result = deserializer.Deserialize( stream );
                    returnValue = (T) result;
            }
 
            return returnValue;
        }
 
 
        /// <summary>
        /// Gets the namespace an object will use for serialization
        /// </summary>
        /// <param name="objectType">Type to get the namesapce from</param>
        /// <returns>String containing the Namespace used for serialization</returns>
        public static string getSerializedNamespace( Type objectType )
        {
            string returnValue = objectType.Namespace;
            Attribute[] attributes = Attribute.GetCustomAttributes( objectType );
 
            foreach ( Attribute attribute in attributes )
            {
                if ( attribute is XmlTypeAttribute )
                {
                    XmlTypeAttribute xmlType = (XmlTypeAttribute) attribute;
                    returnValue = xmlType.Namespace;
                    break;
                }
            }
 
            return returnValue;
        }
    }