通过XmlSerializer 实现XML的序列化与反序列化

通过XmlSerializer 我们可以十分简单的将Model与XML进行转换

官文在点这里

帮助类

 using System;
 using System.Text;
 using System.Xml.Serialization;
 using System.IO;
 using System.Xml;

 namespace BLL
 {
     public class XmlHelper
     {
         public static T DeSerializeModels<T>(string XMLStr, string eleName)
         {
             XmlRootAttribute Root = new XmlRootAttribute();
             Root.ElementName = eleName;

             XmlSerializer xs = new XmlSerializer(typeof(T), Root);

             StringReader strReader = new StringReader(XMLStr);
             System.Xml.XmlReader r = new System.Xml.XmlTextReader(strReader);
             try
             {
                 T Result = (T)xs.Deserialize(r);
                 return Result;
             }
             finally
             {
                 strReader.Close();
                 r.Close();
             }
         }

         public static string SerializeModels<T>(T Models,string eleName)
         {
             StringBuilder sb = new StringBuilder();
             StringWriter w = new StringWriter(sb);

             XmlRootAttribute Root = new XmlRootAttribute();
             Root.ElementName = eleName;

             XmlSerializer sr = new XmlSerializer(typeof(T), Root);
             sr.Serialize(w, Models);

             w.Close();

             return sb.ToString();
         }

         private static void XmlSerializeInternal(Stream stream, object o, Encoding encoding)
         {
             if (o == null)
                 throw new ArgumentNullException("o");
             if (encoding == null)
                 throw new ArgumentNullException("encoding");

             XmlSerializer serializer = new XmlSerializer(o.GetType());

             XmlWriterSettings settings = new XmlWriterSettings();
             settings.Indent = true;
             settings.NewLineChars = "\r\n";
             settings.Encoding = encoding;
             settings.IndentChars = "    ";

             using (XmlWriter writer = XmlWriter.Create(stream, settings))
             {
                 serializer.Serialize(writer, o);
                 writer.Close();
             }
         }

         /// <summary>
         /// 将一个对象序列化为XML字符串
         /// </summary>
         /// <param name="o">要序列化的对象</param>
         /// <param name="encoding">编码方式</param>
         /// <returns>序列化产生的XML字符串</returns>
         public static string XmlSerialize(object o, Encoding encoding)
         {
             using (MemoryStream stream = new MemoryStream())
             {
                 XmlSerializeInternal(stream, o, encoding);

                 stream.Position = ;
                 using (StreamReader reader = new StreamReader(stream, encoding))
                 {
                     return reader.ReadToEnd();
                 }
             }
         }

         /// <summary>
         /// 将一个对象序列化为XML字符串
         /// </summary>
         /// <param name="o">要序列化的对象</param>
         /// <returns>序列化产生的XML字符串</returns>
         public static string XmlSerialize(object o)
         {
             return XmlSerialize(o, Encoding.UTF8);
         }

         /// <summary>
         /// 将一个对象按XML序列化的方式写入到一个文件
         /// </summary>
         /// <param name="o">要序列化的对象</param>
         /// <param name="UploadPath">保存文件路径</param>
         /// <param name="encoding">编码方式</param>
         public static void XmlSerializeToFile(object o, string path, Encoding encoding)
         {
             if (string.IsNullOrEmpty(path))
                 throw new ArgumentNullException("path");

             using (FileStream file = new FileStream(path, FileMode.Create, FileAccess.Write))
             {
                 XmlSerializeInternal(file, o, encoding);
             }
         }

         /// <summary>
         /// 将一个对象按XML序列化的方式写入到一个文件
         /// </summary>
         /// <param name="o">要序列化的对象</param>
         /// <param name="UploadPath">保存文件路径</param>
         public static void XmlSerializeToFile(object o, string path)
         {
             XmlSerializeToFile(o, path, Encoding.UTF8);
         }

         /// <summary>
         /// 从XML字符串中反序列化对象
         /// </summary>
         /// <typeparam name="T">结果对象类型</typeparam>
         /// <param name="s">包含对象的XML字符串</param>
         /// <param name="encoding">编码方式</param>
         /// <returns>反序列化得到的对象</returns>
         public static T XmlDeserialize<T>(string s, Encoding encoding)
         {
             if (string.IsNullOrEmpty(s))
                 throw new ArgumentNullException("s");
             if (encoding == null)
                 throw new ArgumentNullException("encoding");

             XmlSerializer xs = new XmlSerializer(typeof(T));
             using (MemoryStream ms = new MemoryStream(encoding.GetBytes(s)))
             {
                 using (StreamReader sr = new StreamReader(ms, encoding))
                 {
                     return (T)xs.Deserialize(sr);
                 }
             }
         }

         /// <summary>
         /// 从XML字符串中反序列化对象
         /// </summary>
         /// <typeparam name="T">结果对象类型</typeparam>
         /// <param name="s">包含对象的XML字符串</param>
         /// <returns>反序列化得到的对象</returns>
         public static T XmlDeserialize<T>(string s)
         {
             return XmlDeserialize<T>(s, Encoding.UTF8);
         }

         /// <summary>
         /// 读入一个文件，并按XML的方式反序列化对象。
         /// </summary>
         /// <typeparam name="T">结果对象类型</typeparam>
         /// <param name="UploadPath">文件路径</param>
         /// <param name="encoding">编码方式</param>
         /// <returns>反序列化得到的对象</returns>
         public static T XmlDeserializeFromFile<T>(string path, Encoding encoding)
         {
             if (string.IsNullOrEmpty(path))
                 throw new ArgumentNullException("path");
             if (encoding == null)
                 throw new ArgumentNullException("encoding");

             string xml = File.ReadAllText(path, encoding);
             return XmlDeserialize<T>(xml, encoding);
         }

         /// <summary>
         /// 读入一个文件，并按XML的方式反序列化对象。
         /// </summary>
         /// <typeparam name="T">结果对象类型</typeparam>
         /// <param name="UploadPath">文件路径</param>
         /// <returns>反序列化得到的对象</returns>
         public static T XmlDeserializeFromFile<T>(string path)
         {
             return XmlDeserializeFromFile<T>(path, Encoding.UTF8);
         }
     }
 }

工具类

同时也可以通过设置Model的特性，灵活的控制序列化

using System.Xml.Serialization;
using System;
using System.Collections.Generic;

namespace Model
{
    /// <summary>
    /// 节点名是EleTeacher
    /// </summary>
    [Serializable]
    [XmlType("EleTeacher")]
    public class Teacher
    {
        [XmlElement(ElementName = "user")]
        public string AuthorID { set; get; }

        [XmlIgnore]
        public string Content { set; get; }

        [XmlText]
        public string Value { set; get; }

        [XmlArray("students")]
        public List<Student> sds { set; get; }
    }

    [Serializable]
    public class Student
    {
        [XmlAttribute(AttributeName = "id")]
        public string ID { set; get; }

        [XmlText]
        public string Name { set; get; }
    }
}

Model