xml和对象直接的序列化和反序列化

public class XmlSerializerHelper
    {
        /// <summary>
        /// 从字符串反序列化
        /// </summary>
        /// <typeparam name="T">要反序列化出的类型</typeparam>
        /// <param name="SerializerStr">要序列化的串</param>
        /// <param name="rootElementName">根节点元素名称</param>
        /// <returns>返回序列化出的对象</returns>
        public static T Deserializer<T>(string serializerStr, string rootElementName)
        {            
            XmlRootAttribute xmlRootAttribute = new XmlRootAttribute(rootElementName);
            xmlRootAttribute.Namespace = ExXmlDocument.NameSpace;

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T), xmlRootAttribute);
            StringReader sr = new StringReader(serializerStr);
            
            XmlReader xmlReader = XmlReader.Create(sr);
            return (T)xmlSerializer.Deserialize(xmlReader);
        }

        /// <summary>
        /// 从字符串反序列化
        /// </summary>
        /// <typeparam name="T">要反序列化出的类型</typeparam>
        /// <param name="SerializerStr">要序列化的串</param>        
        /// <returns>返回序列化出的对象</returns>
        public static T Deserializer<T>(string serializerStr)
        {
            return Deserializer<T>(serializerStr, "");
        }

        /// <summary>
        /// 从文件反序列化
        /// </summary>
        /// <typeparam name="T">要反序列化出的类型</typeparam>
        /// <param name="file">要序列化的文件</param>
        /// <param name="rootElementName">根节点元素名称</param>
        /// <returns>返回序列化出的对象</returns>
        public static T DeserializerFromFile<T>(string file, string rootElementName)
        {
            //
            //XmlReader xmlTextReader = XmlReader.Create(file);
            XmlTextReader xmlTextReader = new XmlTextReader(file);
            //Console.WriteLine(xmlTextReader.Encoding);
            //XmlReader xmlReader = XmlReader.Create(file);
            T result = (T)Deserializer<T>(xmlTextReader, rootElementName);
            xmlTextReader.Close();
            return result;
        }

        /// <summary>
        /// 从文件反序列化
        /// </summary>
        /// <typeparam name="T">要反序列化出的类型</typeparam>
        /// <param name="file">要序列化的文件</param>
        /// <param name="rootElementName">根节点元素名称</param>
        /// <returns>返回序列化出的对象</returns>
        public static T DeserializerFromFile<T>(string file)
        {
            return (T)DeserializerFromFile<T>(file, "");
        }        

        /// <summary>
        /// 从XmlReader反序列化
        /// </summary>
        /// <typeparam name="T">要反序列化出的类型</typeparam>
        /// <param name="SerializerStr">要反序列化的XmlReader对象</param>
        /// <param name="rootElementName">根节点元素名称</param>
        /// <returns>返回序列化出的对象</returns>
        public static T Deserializer<T>(XmlReader xmlReader, string rootElementName)
        {
            XmlRootAttribute xmlRootAttribute = new XmlRootAttribute(rootElementName);
            xmlRootAttribute.Namespace = ExXmlDocument.NameSpace;

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T), xmlRootAttribute);            
            return (T)xmlSerializer.Deserialize(xmlReader);
        }

        /// <summary>
        /// 从XmlReader反序列化
        /// </summary>
        /// <typeparam name="T">要反序列化出的类型</typeparam>
        /// <param name="SerializerStr">要反序列化的XmlReader对象</param>
        /// <param name="rootElementName">根节点元素名称</param>
        /// <returns>返回序列化出的对象</returns>
        public static T Deserializer<T>(XmlReader xmlReader)
        {
            return Deserializer<T>(xmlReader, "");
        }

        /// <summary>
        /// 序列化到字符串
        /// </summary>
        /// <typeparam name="T">要序列化的类型</typeparam>
        /// <param name="serializerObj">要序列化的对象</param>
        /// <param name="rootElementName">根节点的名称</param>
        /// <returns>序列化的串</returns>
        public static string Serializer<T>(T serializerObj, string rootElementName)
        {
            //根节点属性
            XmlRootAttribute xmlRootAttribute = new XmlRootAttribute(rootElementName);            
            xmlRootAttribute.Namespace = ExXmlDocument.NameSpace;            
            
            // 命名空间 
            XmlSerializerNamespaces xmlSerializerNamespaces = new XmlSerializerNamespaces();
            xmlSerializerNamespaces.Add("", CommonLibrary.XML.ExXmlDocument.NameSpace);

            //建立序列化对象并序列化
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T), xmlRootAttribute);

            //内存流方式
            MemoryStream memoryStream = new MemoryStream();
            XmlTextWriter xmlSink = new XmlTextWriter(memoryStream, Encoding.UTF8);
            xmlSerializer.Serialize(xmlSink, serializerObj, xmlSerializerNamespaces);
            //内在流reader转码方式
            memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
            System.IO.StreamReader reader = new System.IO.StreamReader(memoryStream, Encoding.UTF8);
            return reader.ReadToEnd();
            //内存流直接转码方式
            //byte[] utf8EncodedData = memoryStream.GetBuffer();
            //return System.Text.Encoding.UTF8.GetString(utf8EncodedData);


            ////旧序列化 经测试设置Encoding无效 一直默认为UTF16 此设置只对stream输出有效
            //StringBuilder sb = new StringBuilder();
            //XmlWriterSettings settings = new XmlWriterSettings();
            //settings.Encoding = Encoding.UTF8;
            //settings.Indent = true;
            //XmlWriter xw = XmlWriter.Create(sb, settings);

            //xmlSerializer.Serialize(xw, serializerObj, xmlSerializerNamespaces);

            //return sb.ToString();            
        }

        /// <summary>
        /// 序列化到字符串
        /// </summary>
        /// <typeparam name="T">要序列化的类型</typeparam>
        /// <param name="serializerObj">要序列化的对象</param>        
        /// <returns>序列化的串</returns>
        public static string Serializer<T>(T serializerObj)
        {
            return Serializer<T>(serializerObj, "");
        }

        /// <summary>
        /// 序列化到XmlWriter
        /// </summary>
        /// <typeparam name="T">要序列化的类型</typeparam>
        /// <param name="serializerObj">要序列化的对象</param>
        /// <param name="rootElementName">根元素的名称</param>
        /// <param name="xmlWriter">要写入序列化内容的对象 注意Encoding</param>
        public static void Serializer<T>(T serializerObj, string rootElementName, XmlWriter xmlWriter)
        {
            //根节点属性
            XmlRootAttribute xmlRootAttribute = new XmlRootAttribute(rootElementName);
            xmlRootAttribute.Namespace = ExXmlDocument.NameSpace;

            // 命名空间 
            XmlSerializerNamespaces xmlSerializerNamespaces = new XmlSerializerNamespaces();
            xmlSerializerNamespaces.Add("", CommonLibrary.XML.ExXmlDocument.NameSpace);

            //建立序列化对象并序列化            
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T), xmlRootAttribute);
            xmlSerializer.Serialize(xmlWriter, serializerObj, xmlSerializerNamespaces);             
        }

        /// <summary>
        /// 从XmlWriter序列化
        /// </summary>
        /// <typeparam name="T">要序列化的类型</typeparam>
        /// <param name="serializerObj">要序列化的对象</param>        
        /// <param name="xmlWriter">要写入序列化内容的对象</param>
        public static void Serializer<T>(T serializerObj, XmlWriter xmlWriter)
        {
            Serializer<T>(serializerObj, "", xmlWriter);
        }

        /// <summary>
        /// 序列化到文件
        /// </summary>
        /// <typeparam name="T">要序列化的类型</typeparam>
        /// <param name="serializerObj">要序列化的对象</param>
        /// <param name="rootElementName">根元素的名称</param>
        /// <param name="file">要写入的文件</param>
        public static void SerializerToFile<T>(T serializerObj, string rootElementName, string file)
        {
            //用XML Writer
            //XmlWriterSettings xws = new XmlWriterSettings();
            //xws.Encoding = System.Text.Encoding.UTF8;            
            //XmlWriter xmlWriter = XmlWriter.Create(file, xws);

            //用XMLTextWriter
            XmlTextWriter xmlTextWriter = new XmlTextWriter(file, System.Text.Encoding.UTF8);
            xmlTextWriter.Formatting = Formatting.Indented;
            xmlTextWriter.Indentation = 1;

            Serializer<T>(serializerObj, rootElementName, xmlTextWriter);
            xmlTextWriter.Close();
        }

        /// <summary>
        /// 序列化到文件
        /// </summary>
        /// <typeparam name="T">要序列化的类型</typeparam>
        /// <param name="serializerObj">要序列化的对象</param>        
        /// <param name="file">要写入的文件</param>
        public static void SerializerToFile<T>(T serializerObj, string file)
        {            
            SerializerToFile<T>(serializerObj, "", file);
        }
    }