XmlSerializer 序列化再反序列化

Question

我有一个需求,是使用XmlSerializer 序列化后,通过拼接后,再反序列化回来
希望能提供基本思路,有源码示例更好,在网上搜索了,源码跑不起来,刚接触.net,希望得到帮助大体意思就是将XmlDocument类型的XML,重新拼接后,再返回一个XmlDocument格式的XML例:
原XML
<?xml version="1.0" encoding="utf-8" ?>
<students>
  <student name="张平" sex="15" num="1001">
    <courses>
      <course name="语文">
        <teacherComment>
          这里是语文老师的批注
        </teacherComment>      
      </course>
 
      <course name="数学">
        <teacherComment>
          这里是数学老师的批注
        </teacherComment>
      </course>
    </courses>
  </student>
</students>
根据需要进行改变
<?xml version="1.0" encoding="utf-8" ?>
<students_a>
  <student_a name="张平">
<student_a sex="15" num="1001">
      <courses_a>
        <course_yw name="语文">
          <teacherComment>
            这里是语文老师的批注
          </teacherComment>      
        </course_yw>
 
        <course_sx name="数学">
          <teacherComment>
            这里是数学老师的批注
          </teacherComment>
        </course_sx>
      </courses_a>
</student_a>
  </student_a>
</students_a>

Answer 1

public static string XMLSerialize<T>(T t)
        {
            using (StringWriter sw = new StringWriter())
            {
                XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
                ns.Add(string.Empty, string.Empty);//Add an empty namespace and empty value
                XmlSerializer xz = new XmlSerializer(t.GetType());
                xz.Serialize(sw, t, ns);
                return sw.ToString();
            }
        }        public static T XMLDeserialize<T>(string xml) where T : new()
        {
            T t = new T();
            using (StringReader sr = new StringReader(xml))
            {
                XmlSerializer xz = new XmlSerializer(t.GetType());
                return (T)xz.Deserialize(sr);
            }
        }

Answer 2

 /// <summary>
     /// 序列化成字符串
     /// </summary>
     /// <param name="obj"></param>
     /// <returns>序列化后的字符串</returns>
     public static string Serialiaze(object obj)
      {
         XmlSerializer xs = new XmlSerializer(obj.GetType());
         MemoryStream ms = new MemoryStream();
         XmlTextWriter xtw = new XmlTextWriter(ms, System.Text.Encoding.UTF8);
         xtw.Formatting = Formatting.Indented;
         xs.Serialize(xtw, obj);
         ms.Seek(0, SeekOrigin.Begin);
         StreamReader sr = new StreamReader(ms);
         string str = sr.ReadToEnd();
         xtw.Close();
         ms.Close();
         return str;
     }
 
      /// <summary>
     /// 反序列化 从字符串
     /// </summary>
     /// <param name="xml">xml字符串</param>
     /// <param name="type">要生成的对象类型</param>
     /// <returns>反序列化后的对象</returns>
     public static object Deserialize(string xml, Type type)
      {
         XmlSerializer xs = new XmlSerializer(type);
         StringReader sr = new StringReader(xml);
         object obj = xs.Deserialize(sr);
         return obj;
     }
using System;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;namespace DotNet.Common.Utilities
{
    public class SerializeObj
    {
        public SerializeObj()
        { }        /// <summary>
        /// 序列化 对象到字符串
        /// </summary>
        /// <param name="obj">泛型对象</param>
        /// <returns>序列化后的字符串</returns>
        public static string Serialize<T>(T obj)
        {
            try
            {
                IFormatter formatter = new BinaryFormatter();
                MemoryStream stream = new MemoryStream();
                formatter.Serialize(stream, obj);
                stream.Position = 0;
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                stream.Flush();
                stream.Close();
                return Convert.ToBase64String(buffer);
            }
            catch (Exception ex)
            {
                throw new Exception("序列化失败,原因:" + ex.Message);
            }
        }        /// <summary>
        /// 反序列化 字符串到对象
        /// </summary>
        /// <param name="obj">泛型对象</param>
        /// <param name="str">要转换为对象的字符串</param>
        /// <returns>反序列化出来的对象</returns>
        public static T Desrialize<T>(T obj, string str)
        {
            try
            {
                obj = default(T);
                IFormatter formatter = new BinaryFormatter();
                byte[] buffer = Convert.FromBase64String(str);
                MemoryStream stream = new MemoryStream(buffer);
                obj = (T)formatter.Deserialize(stream);
                stream.Flush();
                stream.Close();
            }
            catch (Exception ex)
            {
                throw new Exception("反序列化失败,原因:" + ex.Message);
            }
            return obj;
        }
    }
}

Answer 3

研究了一下,终于知道该怎么问了以下是输出的结果,代码在下边
想要的效果是:
修改代码,可以将cats,也就是根节点可以加属性,例如:"<item color="White">"中,color="White"就是属性
还有子节点items也加属性
还有<items>可以再嵌套一个<items>,例如:"<items><items></items></items>"
<saying>可以加属性我现在不知道怎么查Serialization这个方法真没用,都有哪些方法,和怎么去使用他的哪些好像是实体类的class?能否告知?谢谢```<?xml version="1.0" encoding="gb2312"?>
<cats xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <items>
    <item color="White">
      <saying>
        White or black,  so long as the cat can catch mice,  it is a goodcat
      </saying>
    </item>
    <item color="Black">
      <saying>
        White or black,  so long as the cat can catch mice,  it is a goodcat
      </saying>
    </item>
  </items>
</cats>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;using System.Xml.Serialization;namespace UseXmlSerialization
{
    class Program
    {
        static void Main(string[] args)
        {
            //声明一个猫咪对象
            var cWhite = new Cat { Ttst = "ttttsdfasdf", Color = "White", Speed = 10, Saying = "White or black,  so long as the cat can catch mice,  it is a good cat" };
            var cBlack = new Cat { Ttst = "ttttsdfasdf", Color = "Black", Speed = 10, Saying = "White or black,  so long as the cat can catch mice,  it is a good cat" };            CatCollection cc = new CatCollection { Cats = new Cat[] { cWhite, cBlack } };            //序列化这个对象
            XmlSerializer serializer = new XmlSerializer(typeof(CatCollection));            //将对象序列化输出到控制台
            serializer.Serialize(Console.Out, cc);            Console.Read();
        }
    }    [XmlRoot("cats")]
    public class CatCollection
    {
        [XmlArray("items"), XmlArrayItem("item")]
        public Cat[] Cats { get; set; }        
    }    [XmlRoot("cat")]
    public class Cat
    {
        //定义Color属性的序列化为cat节点的属性
        [XmlAttribute("color")]
        public string Color { get; set; }        //要求不序列化Speed属性
        [XmlIgnore]
        public int Speed { get; set; }        //设置Saying属性序列化为Xml子元素
        [XmlElement("saying")]
        public string Saying { get; set; }
    }
}

Answer 4

[XmlRoot]
    public class Cats
    {        [XmlAttribute("color")]
        public string Color { get; set; }        [XmlElement]
        public List<item> items { get; set; }        
    }Pulic class item
{
        [XmlAttribute("color")]
        public string Color { get; set; }        [XmlElement]
        public string saying { get; set; }   
}

Answer 5

http://msdn.microsoft.com/zh-cn/library/system.xml.serialization.xmlserializer(v=VS.80).aspxhttp://www.cnblogs.com/yukaizhao/archive/2011/07/22/xml-serialization.html
XmlSerializer带来的性能问题及解决办法
http://www.cnblogs.com/juqiang/archive/2008/03/11/1100984.html

Answer 6

public class Item
{}public class Items:List<Item>
{}Items items=new Items();
//序列化items对象

Answer 7

少写了一个public class cats
{
   public Items items{get;set;}
}

Answer 8

还有一个问题
我想
让XML显示一个
 <clientitem type="c2" id="xxx" keytoken="xxx" keytype="xxx" />
这样格式的而我现在只能写出这样的
<Clien>
  <clientitem type="c2" id="xxx" keytoken="xxx" keytype="xxx" />
</Clien>代码是
[XmlNamespaceDeclarations]
public clientitem[] Clien { get; set; }
public class clientitem
{
    [XmlAttribute("type")]
    public string Type { get; set; }    [XmlAttribute("id")]
    public string Id { get; set; }    [XmlAttribute("keytoken")]
    public string Keytoken { get; set; }    [XmlAttribute("keytype")]
    public string Keytype { get; set; }
}

Answer 9

10楼的问题已搞定
新问题`````
要生成显示的XML有一节点是关键字,这个怎么出来?才能让XML显示关键字,"class"
<class id=""...

Answer 10

不知道遇到关键字的时候该怎么处理呢?
[XmlElement]
public classitem[] class { get; set; }这里的class是关键字```