详解 C# 中XML对象的序列化和反序列化

这一篇主要是用来介绍关于c#中的xml序列化的问题，这个相信大家一定会经常使用它，特别是在wpf中，有时候我们需要将我们后台的数据保存在数据库中，从而在软件下一次启动的时候能够自动去加载这些数据，由于我们的这些model中字段众多，如果单独进行保存那是不太现实的，这个时候将这些字段序列化成xml字符串并保存在数据库中就是一个不错的选择，当我们需要这些数据的时候我们也可以反过来将其序列化为一些字段，最终达到我们的效果，首先我们来看看是如何实现的？

public class xmlutil
{
    /// <summary>
    /// xml & datacontract serialize & deserialize helper
    /// </summary>
    /// <typeparam name="t"></typeparam>
    /// <param name="serialobject"></param>
    /// <returns></returns>
    public static string serializer<t>(t serialobject) where t : class
    {
        try
        {
            xmlserializer ser = new xmlserializer(typeof(t));
            system.io.memorystream mem = new memorystream();
            xmltextwriter writer = new xmltextwriter(mem, encoding.utf8);
            ser.serialize(writer, serialobject);
            writer.close();
 
            return encoding.utf8.getstring(mem.toarray());
        }
        catch (exception ex)
        {
            return null;
        }
    }
 
    public static t deserialize<t>(string str) where t : class
    {
        try
        {
            xmlserializer myserializer = new xmlserializer(typeof(t));
            streamreader mem2 = new streamreader(
                    new memorystream(system.text.encoding.utf8.getbytes(str)),
                    system.text.encoding.utf8);
 
            return (t)myserializer.deserialize(mem2);
        }
        catch (exception)
        {
            return null;
        }
    }
    
}

　　微软为我们提供的xmlserializer这个类就为我们提供了这个可能，在序列化的过程中我们需要注意下面的情况，所有的属性必须是可序列化的对象，像bitmapimage、solidcolorbrush等这些对象都是不能够进行序列化的对象，如果用上面的方法进行序列化时将返回null，正确的方式是在这些字段上面加上[xmlignore]说明，从而在进行序列化时候跳过这些对象，就像下面的方式。

/// <summary>
///背景颜色
/// </summary>
private solidcolorbrush _backgroundcolor;
[xmlignore]
public solidcolorbrush backgroundcolor
{
    get
    {
        return _backgroundcolor;
    }
    set
    {
        if (value != _backgroundcolor)
        {
            _backgroundcolor = value;
            onpropertychanged("backgroundcolor");
        }
    }
}

　　那么像上面的这个solidcolorbrush对象该怎样去进行序列化呢，这里我们选择将当前颜色的argb值保存在一个byte数组中，从而在反序列化的时候通过color.fromargb的方式进行还原，就像下面的方式。

byte[] colorbyte=savedmodel.configurationbasemodel.backgroundcolorargb;
    color backcolor=color.fromargb(colorbyte[0],colorbyte[1],colorbyte[2],colorbyte[3]);
    sourcebasemodel.backgroundcolor = new solidcolorbrush(backcolor);

　　那么这个对象在进行序列化的时候该怎么进行保存呢？同样的原理我们可以通过下面的方式。

/// <summary>
///背景颜色
/// </summary>
private solidcolorbrush _backgroundcolor;
[xmlignore]
public solidcolorbrush backgroundcolor
{
    get
    {
        return _backgroundcolor;
    }
    set
    {
        if (value != _backgroundcolor)
        {
            _backgroundcolor = value;
            onpropertychanged("backgroundcolor");
        }
    }
}
 
/// <summary>
///背景颜色argb
/// </summary>
private byte[] _backgroundcolorargb=new byte[4];
[xmlarray("argb"),xmlarrayitem("value")]
public byte[] backgroundcolorargb
{
    get
    {
        if (null != _backgroundcolor)
        {
            color color = _backgroundcolor.color;
            _backgroundcolorargb[0] = color.a;
            _backgroundcolorargb[1] = color.r;
            _backgroundcolorargb[2] = color.g;
            _backgroundcolorargb[3] = color.b;
        }
        return _backgroundcolorargb;
    }
    set
    {
        if (value != _backgroundcolorargb)
        {
            _backgroundcolorargb = value;
            onpropertychanged("backgroundcolorargb");
        }
     
    }
}

　　这里在实际的使用中发现，就像byte数组必须通过[xmlarray("argb"),xmlarrayitem("value")] 这类型的标识来将其分类，在将其序列化完毕以后，我们可以看看这个backgroundcolorargb字段最终是通过怎样的方式来保存的？   

    在进行反序列化的时候会将这个argb和value反序列化为一个byte数组。

    除了这些特例意外，有时候经常需要将一些对象的数组进行序列化，那么原理是什么呢？这里我借用别人的一个例子来进行相关的说明。

　对象数组的xml序列化：

　数组的xml序列化需要使用xmlarrayattribute和xmlarrayitemattribute；xmlarrayattribute指定数组元素的xml节点名，xmlarrayitemattribute指定数组元素的xml节点名。

　如下代码示例： 

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 { 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 { 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; }
    }
}

  最终获得的结果是：  

<?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 good cat</saying>
    </item>
    <item color="black">
      <saying>white or black,  so long as the cat can catch mice,  it is a good cat</saying>
    </item>
  </items>
</cats>　

以上就是详解 c# 中xml对象的序列化和反序列化的详细内容，更多关于c# xml序列化和反序列化的资料请关注其它相关文章！