原文地址：http://www.cnblogs.com/gaozhongfa/archive/2009/12/08/1619041.html
收录一：
我的理解：
比如用一个类描述一张合同，而这个类实例化后其中的字段保存着合同的信息，如果现在要把这个类的实例发送到另一台机器、另一个窗体或是想保存这个类以便以后再取出来用（持久化对象），可以对这个类进行序列化（序列化实际上是一个信息流），传送或保存，用的时候再反序列化重新生成这个对象
为什么您想要使用序列化？有两个最重要的原因促使对序列化的使用：一个原因是将对象的状态保持在存储媒体中，以便可以在以后重新创建精确的副本；另一个原因是通过值将对象从一个应用程序域发送到另一个应用程序域中。例如，序列化可用于在 ASP.NET 中保存会话状态并将对象复制到 Windows 窗体的剪贴板中。远程处理还可以使用序列化通过值将对象从一个应用程序域传递到另一个应用程序域中。
序列化的是对象的状态
也就是对象数据成员的值和方法是没有关系的
跨应用程序域通信时，要用到序列化
以及用WEB服务时
一：BinaryFormatter序列化
序列化简单点来理解就是把内存的东西写到硬盘中,当然也可以写到内存中(这个内容我会在后面写一个例子).而反序列化就是从硬盘中把信息读到内存中.就这么简单,呵呵,现在来看下面的例子吧!
在这篇文章中我将使用BinaryFormatter序列化类Book作为例子,希望大家能从例子中深刻体会什么是序列化.
定义类Book:
[Serializable]
public Class Book
{
string name;
float price;
string author;
public Book(string bookname, float bookprice, string bookauthor)
{
name = bookname;
price = bookprice;
author = bookauthor;
}
}
在类的上面增加了属性:Serializable.(如果不加这个属性,将抛出SerializationException异常).
通过这个属性将Book标志为可以序列化的.当然也有另一种方式使类Book可以序列化,那就是实行ISerializable接口了.在这里大家要注意了:Serializable属性是不能被继承的咯!!!
如果你不想序列化某个变量,该怎么处理呢?很简单,在其前面加上属性[NonSerialized] .比如我不想序列化
string author;
那我只需要
[NonSerialized]
string author;
好了,现在就告诉大家怎么实现序列化:
我们使用namespace:
using System;
using System.IO;
using System.RunTime.Serialization.Formatters.Binary;
首先创建Book实例,like this:
Book book = new Book("Day and Night", Numbertype="1" tcsc="0">30.0f, "Bruce");
接着当然要创建一个文件了,这个文件就是用来存放我们要序列化的信息了.
FileStream fs = new FileStream(@"C:\book.dat", FileMode.Create);
序列化的实现也很简单,like this:
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, book);
很简单吧!现在我列出整个原代码,包括反序列化.
static void Main(string[] args)
{
Book book = new Book("Day and Night", 30.0f, "Bruce");
using(FileStream fs = new FileStream(@"C:\book.dat", FileMode.Create))
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, book);
}
book = null;
using(FileStream fs = new FileStream(@"C:\book.dat", FileMode.Open))
{
BinaryFormatter formatter = new BinaryFormatter();
book = (Book)formatter.Deserialize(fs);//在这里大家要注意咯,他的返回值是object
}
}
有不对的地方,请大家多多纠正.....
注意一定不要忘了： using System.Runtime.Serialization.Formatters.Binary;
命名空间。
收录二：
原先一直用BinaryFormatter来序列化挺好，可是最近发现在WinCE下是没有办法进行BinaryFormatter操作，很不爽，只能改成了BinaryWriter和BinaryReader来读写，突然想到能不能用XML来序列化？于是在网上查了些资料便写了些实践性代码，做些记录，避免以后忘记。
序列化对象
public class People
{
[XmlAttribute("NAME")]
public string Name
{ set; get; }
[XmlAttribute("AGE")]
public int Age
{ set; get; }
}
[XmlRoot("Root")]
public class Student : People
{
[XmlElement("CLASS")]
public string Class
{ set; get; }
[XmlElement("NUMBER")]
public int Number
{ set; get; }
}
void Main(string[] args)
{
Student stu = new Student()
{
Age = 10,
Class = "Class One",
Name = "Tom",
Number = 1
};
XmlSerializer ser = new XmlSerializer(typeof(Student));
ser.Serialize(File.Create("C:\\x.xml"), stu);
}
反序列化对象
XmlSerializer ser = new XmlSerializer(typeof(Student));
Student stu = ser.Deserialize(File.OpenRead("C:\\x.xml")) as Student;
对象数组序列化
public class People
{
[XmlAttribute("NAME")]
public string Name
{ set; get; }
[XmlAttribute("AGE")]
public int Age
{ set; get; }
}
[XmlRoot("Root")]
public class Student : People
{
[XmlElement("CLASS")]
public string Class
{ set; get; }
[XmlElement("NUMBER")]
public int Number
{ set; get; }
}
void Main(string[] args)
{
List<Student> stuList = new List<Student>();
stuList.Add(new Student() { Age = 10, Number = 1, Name = "Tom", Class = "Class One" });
stuList.Add(new Student() { Age = 11, Number = 2, Name = "Jay", Class = "Class Two" });
stuList.Add(new Student() { Age = 12, Number = 3, Name = "Pet", Class = "Class One" });
stuList.Add(new Student() { Age = 13, Number = 4, Name = "May", Class = "Class Three" });
stuList.Add(new Student() { Age = 14, Number = 5, Name = "Soy", Class = "Class Two" });
XmlSerializer ser = new XmlSerializer(typeof(List<Student>));
ser.Serialize(File.Create("C:\\x.xml"), stuList);
}
对象数组反序列
XmlSerializer ser = new XmlSerializer(typeof(List<Student>));
List<Student> stuList = ser.Deserialize(File.OpenRead("C:\\x.xml")) as List<Student>;
foreach (Student s in stuList)
{
MessageBox.Show(string.Format("{0} : {1} : {2} : {3}",
s.Name, s.Age, s.Class, s.Number));
}
序列化Dirctionary
public struct DirectionList
{
[XmlAttribute("Name")]
public string Name;
[XmlElement("Value")]
public int Value;
}
void Main(string[] args)
{
Dictionary<string, int> list = new Dictionary<string, int>();
list.Add("1", 100);
list.Add("2", 200);
list.Add("3", 300);
list.Add("4", 400);
list.Add("5", 500);
list.Add("6", 600);
list.Add("7", 700);
list.Add("8", 800);
list.Add("9", 900);
List<DirectionList> dirList = new List<DirectionList>();
foreach (var s in list)
{
dirList.Add(new DirectionList() { Name = s.Key, Value = s.Value });
}
XmlSerializer ser = new XmlSerializer(typeof(List<DirectionList>));
ser.Serialize(File.Create("C:\\x.xml"), dirList);
}
这里还要讲一点，在XmlSerializer中，不支持Dirctionary<>类型的对象，所以在序列化这种最常见类型的时候，只能按照它的格式先创建一个可以别序列化的类型，这里我定义了一个结构体，当然你也可以定义成其他的类。将Dictionary<>中的数据依次放进结构体以后就可以放入流中了。
[XmlAttribute("Name")]意思是将这个字段作为xml的属性，属性名跟在“”中
[XmlElement("Value")]意思是将这个字段做为xml的元素。
反序列化Dirctionary
XmlSerializer ser = new XmlSerializer(typeof(List<DirectionList>));
List<DirectionList> dirList = ser.Deserialize(
File.OpenRead("C:\\x.xml")) as List<DirectionList>;
foreach (var v in dirList)
{
Console.WriteLine("{0} : {1}", v.Name, v.Value);
}
其实我并不喜欢这个名称，感觉有点生化危机的feel，但是也就是这样了，没有太炫的地方，Deserialize反序列化。真希望.Net能集成Dirctionary<>对象，那我们这些懒人就方便了。
在需要序列化的队伍中，数组是很常见的类型，其次就是图片了
序列化图片
public struct ImageStruct
{
[XmlAttribute("Number")]
public int number;
[XmlElement("Image")]
public byte[] picture;
}
void Main(string[] args)
{
ImageStruct s = new ImageStruct() { number = 1, picture = File.ReadAllBytes(@"11.jpg") };
XmlSerializer ser = new XmlSerializer(typeof(ImageStruct));
FileStream fs = File.Create("c:\\x.xml");
ser.Serialize(fs, s);
fs.Close();
}
一样的，采用结构体来保存图片，这里我还加了个图片的名字，到时候查找起来也方便一些
图片反序列化
XmlSerializer ser = new XmlSerializer(typeof(ImageStruct));
ImageStruct s = (ImageStruct)ser.Deserialize(File.OpenRead("c:\\x.xml"));
pictureBox1.Image = Image.FromStream(new MemoryStream(s.picture));
没有花头的方式，利用memorystream来做缓存，这样会比较快一点，实际上我并没有怎么感觉。
图片数组序列化
public struct ImageStruct
{
[XmlAttribute("Number")]
public int number;
[XmlElement("Image")]
public byte[] picture;
}
void Main(string[] args)
{
List<ImageStruct> imageList = new List<ImageStruct>();
imageList.Add(new ImageStruct()
{
number = 1,
picture = File.ReadAllBytes(@"11.jpg")
});
imageList.Add(new ImageStruct()
{
number = 2,
picture = File.ReadAllBytes(@"22.jpg")
});
XmlSerializer ser = new XmlSerializer(typeof(List<ImageStruct>));
FileStream fs = File.Create("c:\\x.xml");
ser.Serialize(fs, imageList);
fs.Close();
}
图片数组反序列化
XmlSerializer ser = new XmlSerializer(typeof(List<ImageStruct>));
List<ImageStruct> s = (List<ImageStruct>)ser.Deserialize(File.OpenRead("c:\\x.xml"));
var im = from i in s
where i.number == 1
select i.picture;
//var im = s.Where(p => p.number == 1).Select(p => p.picture);
foreach (var image in im)
{
pictureBox1.Image = Image.FromStream(
new MemoryStream(image));
}
这里还对数组结构进行了Linq查询，这样就可以很方便的查询图片了。
收录三：
序列化方便对象的传输及储存；
它能将对象转成如XML/Bit流；
它是Session(进程外/SqlServer模式）,ViewState,WebService,Remoting等的基础。
收录四：
例如学生类
public class Student
{
public int id;
public string name;
public bool sex;
public DateTime birthday;
...
}
// 序列化为byte[]
MemoryStream fs = new MemoryStream();
byte[] tmp = null;
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(fs, student);
tmp = fs.ToArray();
将tmp作为bianry数据存到数据库
// 反序列化直接生成Student类
MemoryStream fs = new MemoryStream();
Student student = null;
fs = new MemoryStream(tmp);
fs.Position = 0;
BinaryFormatter formatter = new BinaryFormatter();
student = formatter.Deserialize(fs);
操作方便不用一一赋值。
不过也有一些问题，如存到数据库以后，类Student又添加了属性，于是就反序列化不出来了！
