曾经发过一篇如何在Silveright中利用XmlSerializer序列化对象的文章“Silverlight中的序列化”，限于当时的认识有限，一度以为silverlight只有这一种办法，今天意外发现，其实还有更好的方式，特此做一个汇总与比较

1.json序列化方式

silverlight支持json字符串已是众人皆知的事情，没啥好说的，有点容易让人误导的是：我们在vs的silverlight项目中添加引用时，一眼就能看到System.Runtime.Serialization.Json这个命名空间，于是想当然的以为json序列化的功能肯定是在这个命名空间下面

结果等你捣鼓半天才发现，其实这下面跟序列化相关的东西，啥也没有?

可能有朋友注意到了，在最新的.net4.0中，这个命名空间下貌似有json序列化功能了，但在sl4.0正式发布前，sl3.0(及以下版本)还是没办法玩的，其实silverlight3.0中是可以json序列化对象的，正确的程序集在System.ServiceModel.Web这个下面，所以只要添加System.ServiceModel.Web引用即可(代码见本文最后)

2.XmlSerializer序列化方式

这个在上篇文章里已经讲过了，不再重复

3.DataContractSerializer序列化方式

这个在命名空间System.Runtime.Serialization下

下面演示了三种方式的对象序列化与反序列化，值得一提的是：silverlight中不管用哪一种方式序列化，对象的类定义中都无需添加[DataContract],[DataMember],[Serializeable]之类的标记--前提是对象成员都是string,int之类的基本类型！

XAML部分代码:

1. <UserControl x:Class="SlSerialize.MainPage"  
2.     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
3.     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
4.     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"  
5.     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"  
6.     mc:Ignorable="d"  
7.     d:DesignHeight="300" d:DesignWidth="400">  
8.  
9.     <Grid x:Name="LayoutRoot" Background="White">  
10.         <Grid.RowDefinitions>             
11.             <RowDefinition></RowDefinition>  
12.             <RowDefinition Height="30"></RowDefinition>  
13.         </Grid.RowDefinitions>  
14.         <TextBox x:Name="txtResult" Grid.Row="0" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" TextWrapping="Wrap"></TextBox>  
15.         <StackPanel Orientation="Horizontal" Grid.Row="1" HorizontalAlignment="Center" VerticalAlignment="Center" Height="23">  
16.             <Button Content="Json序列化"   Name="btnJson"   Click="btnJson_Click" />  
17.             <Button Content="Xml序列化"   Name="btnXml" Click="btnXml_Click" Margin="5,0,0,0" />  
18.             <Button Content="二进制序列化"   Name="btnBin" Click="btnBin_Click" Margin="5,0,0,0" />  
19.         </StackPanel>          
20.     </Grid>  
21. </UserControl> 

CS部分代码:

1. using System.IO;  
2. using System.Json;  
3. using System.Runtime.Serialization;  
4. using System.Runtime.Serialization.Json;  
5. using System.Text;  
6. using System.Windows;  
7. using System.Windows.Controls;  
8. using System.Xml.Serialization;  
9.  
10. namespace SlSerialize  
11. {  
12.     public partial class MainPage : UserControl  
13.     {  
14.         Person _person;  
15.  
16.         public MainPage()  
17.         {  
18.             InitializeComponent();  
19.             this.Loaded += new RoutedEventHandler(MainPage_Loaded);  
20.         }  
21.  
22.         void MainPage_Loaded(object sender, RoutedEventArgs e)  
23.         {  
24.             _person = new Person() { Name = "菩提树下的\"杨过\"", Age = 30 };  
25.         }  
26.  
27.         private void btnJson_Click(object sender, RoutedEventArgs e)  
28.         {  
29.             //json序列化开始  
30.             MemoryStream ms = new MemoryStream();  
31.             DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Person));  
32.             ser.WriteObject(ms, _person);  
33.             byte[] json = ms.ToArray();  
34.             ms.Close();  
35.             string jsonString = Encoding.UTF8.GetString(json, 0, json.Length);//序列化得到的字符串  
36.  
37.             //json字符串解析(相当于反序列化)  
38.             JsonValue jsonv = JsonObject.Parse(jsonString);  
39.             Person pTest = new Person() { Age = int.Parse(jsonv["Age"].ToString()), Name = jsonv["Name"].ToString() };  
40.  
41.             //显示结果  
42.             txtResult.Text = "json序列化后的字符串：(长度" + jsonString.Length + ")\n" + jsonString + "\n\n反序列化后的结果：\nAge=" + pTest.Age + "，Name=" + pTest.Name;  
43.         }  
44.  
45.         private void btnXml_Click(object sender, RoutedEventArgs e)  
46.         {  
47.             //xml序列化开始  
48.             MemoryStream ms = new MemoryStream();  
49.             XmlSerializer xml = new XmlSerializer(typeof(Person));  
50.             xml.Serialize(ms, _person);//xml序列化的关键代码              
51.             byte[] arr = ms.ToArray();  
52.             ms.Close();  
53.             string xmlString = Encoding.UTF8.GetString(arr,0,arr.Length);  
54.             ms.Close();               
55.                         
56.  
57.             //xml反序列化                       
58.             MemoryStream ms2 = new MemoryStream(Encoding.UTF8.GetBytes(xmlString));  
59.             XmlSerializer xml2 = new XmlSerializer(typeof(Person));              
60.             Person pTest = xml.Deserialize(ms2) as Person;//xml反序列化的关键代码  
61.             ms2.Close();  
62.  
63.             //显示反序列化后的结果  
64.             txtResult.Text = "xml序列化后的字符串：(长度" + xmlString.Length + ")\n" + xmlString + "\n\n反序列化后的结果：\nAge=" + pTest.Age + "，Name=" + pTest.Name;  
65.         }  
66.  
67.         private void btnBin_Click(object sender, RoutedEventArgs e)  
68.         {  
69.             //DataContract方式序列化  
70.             MemoryStream ms = new MemoryStream();              
71.             DataContractSerializer ser = new DataContractSerializer(typeof(Person));  
72.             ser.WriteObject(ms, _person);  
73.             byte[] array = ms.ToArray();  
74.             ms.Close();  
75.  
76.             string _serializeString = Encoding.UTF8.GetString(array, 0, array.Length);  
77.  
78.             //反序列化  
79.             DataContractSerializer ser2 = new DataContractSerializer(typeof(Person));  
80.             MemoryStream ms2 = new MemoryStream(Encoding.UTF8.GetBytes(_serializeString));  
81.             Person pTest = ser2.ReadObject(ms2) as Person;  
82.  
83.             //显示反序列化后的结果  
84.             txtResult.Text = "DataContract序列化后的字符串：(长度" + _serializeString.Length + ")\n" + _serializeString + "\n\n反序列化后的结果：\nAge=" + pTest.Age + "，Name=" + pTest.Name;  
85.  
86.         }  
87.  
88.     }  
89.  
90.     /// <summary>  
91.     /// 测试类  
92.     /// </summary>  
93.     public class Person  
94.     {  
95.         public string Name { set; get; }  
96.  
97.         public int Age { set; get; }  
98.     }  
99. } 

最后比较一下各自的异同:

可以看到，如果：

用json方式序列化以及反序列化，最终会引入50k的"System.Json.dll"，序列化后的字节数最少;
XmlSerializer方式，最终会引入314k的"System.Xml.Serialization.dll"，序列化后的字节数也最多;
DataContractSerializer方式，默认不需引用额外的程序集，序列化后的字节数高于json方式，但低于XmlSerializer方式


建议:

如果在网络通讯应用(比如socket编程中)，最好使用json方式序列化;
如果想让最终的xap体积最小(以达到最快加载速度)，最好使用DataContractSerializer方式;
一般不建议使用XmlSerializer方式处理对象序列化