c#.net实体类序列化方法

2011-06-01 15:45 佚名 互联网 我要评论(0) 字号：T | T

序列化是将对象状态转换为可保持或传输的格式的过程，在序列化过程中，对象的公共字段和私有字段以及类的名称（包括包含该类的程序集）都被转换为字节流，然后写入数据流。与序列化相对的是反序列化，它将流转换为对象。本文主要介绍实体类序列化，一起来看。

AD：

提到为了传递数据，需要把作为载体的实体类序列化，好好的找了一些序列化方面的介绍。感觉下面的这个介绍比较容易介绍!

1.什么是序列化

序列化是将对象状态转换为可保持或传输的格式的过程，在序列化过程中，对象的公共字段和私有字段以及类的名称（包括包含该类的程序集）都被转换为字节流，然后写入数据流。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。

2.为什么使用序列化

a. 一个原因是将对象的状态保持在存储媒体中，以便可以在以后重新创建精确的副本。

我们经常需要将对象的字段值保存到磁盘中，并在以后检索此数据。尽管不使用序列化也能完成这项工作，但这种方法通常很繁琐而且容易出错，并且在需要跟踪对象的层次结构时，会变得越来越复杂。可以想象一下编写包含大量对象的大型业务应用程序的情形，程序员不得不为每一个对象编写代码，以便将字段和属性保存至磁盘以及从磁盘还原这些字段和属性。序列化提供了轻松实现这个目标的快捷方法。

b.另一个原因是通过值将对象从一个应用程序域发送到另一个应用程序域中。

例如，序列化可用于在 ASP.NET 中保存会话状态并将对象复制到 Windows 窗体的剪贴板中。远程处理还可以使用序列化通过值将对象从一个应用程序域传递到另一个应用程序域中。

公共语言运行时 (CLR) 管理对象在内存中的分布，.NET 框架则通过使用反射提供自动的序列化机制。对象序列化后，类的名称、程序集以及类实例的所有数据成员均被写入存储媒体中。对象通常用成员变量来存储对其他实例的引用。类序列化后，序列化引擎将跟踪所有已序列化的引用对象，以确保同一对象不被序列化多次。.NET 框架所提供的序列化体系结构可以自动正确处理对象图表和循环引用。对对象图表的唯一要求是，由正在进行序列化的对象所引用的所有对象都必须标记为 Serializable（请参阅基本序列化）。否则，当序列化程序试图序列化未标记的对象时将会出现异常。

当反序列化已序列化的类时，将重新创建该类，并自动还原所有数据成员的值。

3.如何实现对象的序列化及反序列化

要实现对象的序列化，首先要保证该对象可以序列化。而且，序列化只是将对象的属性进行有效的保存，对于对象的一些方法则无法实现序列化的。

实现一个类可序列化的最简便的方法就是增加Serializable属性标记类。如：

1.[Serializable()]  

2.public class MEABlock  

3.{  

4.private int m_ID;  

5.public string Caption;  

6.public MEABlock()  

7.{  

8.///构造函数  

9.}  

10.} 

即可实现该类的可序列化。注意序列化的类必须为Public，否则不能够被序列化。

要将该类的实例序列化为到文件中？.NET FrameWork提供了两种方法：

a .XML序列化

使用 XmLSerializer 类，可将下列项序列化。

公共类的公共读／写属性和字段

实现 ICollection 或 IEnumerable 的类。（注意只有集合会被序列化，而公共属性却不会。）

XmlElement 对象。

XmlNode 对象。

DataSet 对象。

要实现上述类的实例的序列化，可参照如下例子：

1.MEABlock myBlock = new MEABlock();  

2.// Insert code to set properties and fields of the object.  

3.XmlSerializer mySerializer = new XmlSerializer(typeof(MEABlock));  

4.// To write to a file, create a StreamWriter object.  

5.StreamWriter myWriter = new StreamWriter("myFileName.xml");  

6.mySerializer.Serialize(myWriter, MEABlock); 

需要注意的是XML序列化只会将public的字段保存，对于私有字段不予于保存。

生成的XML文件格式如下：

1. 

2.Test 

3. 

对于对象的反序列化，则如下：

1.MEABlock myBlock;  

2.// Constructs an instance of the XmlSerializer with the type  

3.// of object that is being deserialized.  

4.XmlSerializer mySerializer = new XmlSerializer(typeof(MEABlock));  

5.// To read the file, creates a FileStream.  

6.FileStream myFileStream = new FileStream("myFileName.xml", FileMode.Open);  

7.// Calls the Deserialize method and casts to the object type.  

8.myBlock = (MEABlock)mySerializer.Deserialize(myFileStream) 

b. 二进制序列化

与XML序列化不同的是，二进制序列化可以将类的实例中所有字段（包括私有和公有）都进行序列化操作。这就更方便、更准确的还原了对象的副本。

要实现上述类的实例的序列化，可参照如下例子：

1.MEABlock myBlock = new MEABlock();  

2.// Insert code to set properties and fields of the object.  

3.IFormatter formatter = new BinaryFormatter();  

4.Stream stream = new FileStream("MyFile.bin",FileMode.Create,FileAccess.Write, FileShare.None);  

5.formatter.Serialize(stream, myBlock);  

6.stream.Close(); 

对于对象的反序列化，则如下：

1.IFormatter formatter = new BinaryFormatter();  

2.Stream stream = new FileStream("MyFile.bin", FileMode.Open,FileAccess.Read, FileShare.Read);  

3.MEABlock myBlock = (MEABlock) formatter.Deserialize(stream);  

4.stream.Close(); 

4、如何变相实现自定义可视化控件的序列化、反序列化

对于WinForm中自定义控件，由于继承于System.Windows.Form类，而Form类又是从MarshalByRefObject继承的，窗体本身无法做到序列化，窗体的实现基于Win32下GUI资源，不能脱离当前上下文存在。

当然可以采用变通的方法实现控件的序列化。这里采用的是记忆类模型。

定义记忆类（其实就是一个可序列化的实体类）用于记录控件的有效属性，需要序列化控件的时候，只需要将该控件的实例Copy到记忆类，演变成序列化保存该记忆类的操作。

反序列化是一个逆过程。将数据流反序列化成为该记忆类，再根据该记忆类的属性生成控件实例。而对于控件的一些事件、方法则可以继续使用。

wwf之所以强调要把类实例化，就是因为工作流和应用程序是在不同的线程中。二者之间需要用类作为传递数据的载体的话，就需要把该类定义为public序列化为二进制。

对象的序列化和反序列化

2011-06-01 15:05 阿蜜果 博客园 我要评论(0) 字号：T | T

把Java对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为Java对象的过程称为对象的反序列化。本文主要介绍对象的序列化和反序列化，希望对你有帮助，一起来看。

AD：

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

把Java对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为Java对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：

1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

2） 在网络上传送对象的字节序列。

一． JDK类库中的序列化API

java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式 。

对象序列化包括如下步骤：

1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；

2） 通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：

1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；

2） 通过对象输入流的readObject()方法读取对象。

下面让我们来看一个对应的例子，类的内容如下：

1.import java.io.*;  

2.import java.util.Date;  

3./**  

4.* 对象的序列化和反序列化测试类.   

5.* @author AmigoXie  

6.* @version 1.0   

7.* Creation date: 2007-9-15 - 下午21:45:48  

8.*/ 

9.public class ObjectSaver {  

10./**  

11.* @param args  

12.* @author AmigoXie  

13.* Creation date: 2007-9-15 - 下午21:45:37  

14.*/ 

15.public static void main(String[] args) throws Exception {  

16.ObjectOutputStream out = new ObjectOutputStream  

17.(new FileOutputStream("D:""objectFile.obj"));  

18.//序列化对象  

19.Customer customer = new Customer("阿蜜果", 24);  

20.out.writeObject("你好!");  

21.out.writeObject(new Date());  

22.out.writeObject(customer);  

23.out.writeInt(123); //写入基本类型数据  

24.out.close();  

25.//反序列化对象  

26.ObjectInputStream in = new ObjectInputStream  

27.(new FileInputStream("D:""objectFile.obj"));  

28.System.out.println("obj1=" + (String) in.readObject());  

29.System.out.println("obj2=" + (Date) in.readObject());  

30.Customer obj3 = (Customer) in.readObject();  

31.System.out.println("obj3=" + obj3);  

32.int obj4 = in.readInt();  

33.System.out.println("obj4=" + obj4);  

34.in.close();  

35.}  

36.}  

37.class Customer implements Serializable {  

38.private String name;  

39.private int age;  

40.public Customer(String name, int age) {  

41.this.name = name;  

42.this.age = age;  

43.}  

44.public String toString() {  

45.return "name=" + name + ", age=" + age;  

46.}  

47.} 

输出结果如下：

1.obj1=你好!  

2.obj2=Sat Sep 15 22:02:21 CST 2007  

3.obj3=name=阿蜜果, age=24 

4.obj4=123 

因此例比较简单，在此不再详述。

二．实现Serializable接口

ObjectOutputStream只能对Serializable接口的类的对象进行序列化。默认情况下，ObjectOutputStream按照默认方式序列化，这种序列化方式仅仅对对象的非transient的实例变量进行序列化，而不会序列化对象的transient的实例变量，也不会序列化静态变量。

当ObjectOutputStream按照默认方式反序列化时，具有如下特点：

1） 如果在内存中对象所属的类还没有被加载，那么会先加载并初始化这个类。如果在classpath中不存在相应的类文件，那么会抛出ClassNotFoundException；

2） 在反序列化时不会调用类的任何构造方法。

如果用户希望控制类的序列化方式，可以在可序列化类中提供以下形式的writeObject()和readObject()方法。

1.private void writeObject(java.io.ObjectOutputStream out) throws IOException  

2.private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException; 

当ObjectOutputStream对一个Customer对象进行序列化时，如果该对象具有writeObject()方法，那么就会执行这一方法，否则就按默认方式序列化。在该对象的writeObjectt()方法中，可以先调用ObjectOutputStream的defaultWriteObject()方法，使得对象输出流先执行默认的序列化操作。同理可得出反序列化的情况，不过这次是defaultReadObject()方法。

有些对象中包含一些敏感信息，这些信息不宜对外公开。如果按照默认方式对它们序列化，那么它们的序列化数据在网络上传输时，可能会被不法份子窃取。对于这类信息，可以对它们进行加密后再序列化，在反序列化时则需要解密，再恢复为原来的信息。

默认的序列化方式会序列化整个对象图，这需要递归遍历对象图。如果对象图很复杂，递归遍历操作需要消耗很多的空间和时间，它的内部数据结构为双向列表。

在应用时，如果对某些成员变量都改为transient类型，将节省空间和时间，提高序列化的性能。

三． 实现Externalizable接口

Externalizable接口继承自Serializable接口，如果一个类实现了Externalizable接口，那么将完全由这个类控制自身的序列化行为。Externalizable接口声明了两个方法：

1.public void writeExternal(ObjectOutput out) throws IOException  

2.public void readExternal(ObjectInput in) throws IOException , ClassNotFoundException 

前者负责序列化操作，后者负责反序列化操作。

在对实现了Externalizable接口的类的对象进行反序列化时，会先调用类的不带参数的构造方法，这是有别于默认反序列方式的。如果把类的不带参数的构造方法删除，或者把该构造方法的访问权限设置为private、默认或protected级别，会抛出java.io.InvalidException: no valid constructor异常。

四．可序列化类的不同版本的序列化兼容性

凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

1.private static final long serialVersionUID; 

以上serialVersionUID的取值是Java运行时环境根据类的内部细节自动生成的。如果对类的源代码作了修改，再重新编译，新生成的类文件的serialVersionUID的取值有可能也会发生变化。

类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，有可能会导致不同的serialVersionUID，也有可能相同。为了提高哦啊serialVersionUID的性和确定性，强烈建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。显式地定义serialVersionUID有两种用途：

1） 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；

2） 在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

谈谈序列化，关于.net中的二进制序列化和xml序列化

2011-06-01 14:26 佚名 17fx.Net 我要评论(0) 字号：T | T

序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化，它将流转换为对象。这两个过程结合起来，可以轻松地存储和传输数据。本文主要介绍.NET中的二进制序列化和XML序列化。

AD：

序列化技术，就是将对象持久存储。 可以这样理解：序列化就是将对象占用的内存的数据copy到持久存储设备，比如硬盘。序列化有什么用呢？

两点作用：

1、持久的存储对象状态；

2、分布式运算中传递数据的底层实现。

.Net框架封装的序列化技术包含两种，即 二进制序列化 和 xml序列化

（以下代码都要求被序列化的对象的类型使用Serializable特征类）

二进制序列化的实现 （using System.Runtime.Serialization.Formatters.Binary;）

序列化代码：

1.//打开文件流  

2.FileStream fs = new FileStream(保存序列化数据的文件路径, FileMode.OpenOrCreate);  

3.//创建二进制序列化对象  

4.BinaryFormatter bf = new BinaryFormatter();  

5.//调用二进制序列化对象的序列化方法执行序列化操作  

6.bf.Serialize(fs, 被序列化的对象);  

7.//关闭文件流  

8.fs.Close(); 

反序列化代码：

1.//打开文件流  

2.FileStream fs = new FileStream(保存序列化数据的文件路径, FileMode.OpenOrCreate);  

3.//创建二进制序列化对象  

4.BinaryFormatter bf = new BinaryFormatter();  

5.//调用二进制序列化对象的反序列化方法执行反序列化操作  

6.从文件中反序列化得到的对象 = bf.Deserialize(fs) as 被序列化对象的类型;  

7.//关闭文件流  

8.fs.Close(); 

XML序列化的实现（using System.Xml.Serialization;）

序列化代码：

1.//打开文件流  

2.FileStream fs = new FileStream(保存序列化数据的文件路径, FileMode.OpenOrCreate);  

3.//创建XML序列化对象  

4.XmlSerializer xs = new XmlSerializer(typeof(被序列化对象的类型));  

5.//调用XML序列化对象的序列化方法执行序列化操作  

6.xs.Serialize(fs, 被序列化的对象);  

7.//关闭文件流  

8.fs.Close(); 

反序列化代码：

1.//打开文件流  

2.FileStream fs = new FileStream(保存序列化数据的文件路径, FileMode.OpenOrCreate);  

3.//创建XML序列化对象  

4.XmlSerializer xs = new XmlSerializer(typeof(被序列化对象的类型));  

5.//调用XML序列化对象的反序列化方法执行反序列化操作  

6.从文件中反序列化得到的对象 = xs.Deserialize(fs) as 被序列化对象的类型;  

7.//关闭文件流  

8.fs.Close(); 

当然这里所提供的是序列化和反序列化的默认实现，能应付大多数运用。 特殊情况可以还需要重写序列化的默认实现。MSDN里面也有较详细的示例代码。

深入C# 序列化(Serialize)、反序列化(Deserialize)(1)

2011-06-01 14:50 望穿秋水 博客园 我要评论(0) 字号：T | T

本文主要介绍了C#中的序列化和反序列化，序列化是.NET运行时环境用来支持用户定义类型的流化的机制，希望对你有帮助，一起来看吧。

AD：

序列化又称串行化，是.NET运行时环境用来支持用户定义类型的流化的机制。其目的是以某种存储形成使自定义对象持久化，或者将这种对象从一个地方传输到另一个地方。

.NET框架提供了两种串行化的方式：

1、是使用BinaryFormatter进行串行化；

2、使用SoapFormatter进行串行化；

3、使用XmlSerializer进行串行化。

第一种方式提供了一个简单的二进制数据流以及某些附加的类型信息，而第二种将数据流格式化为XML存储；第三种其实和第二种差不多也是XML的格式存储，只不过比第二种的XML格式要简化很多(去掉了SOAP特有的额外信息)。

可以使用[Serializable]属性将类标志为可序列化的。如果某个类的元素不想被序列化，1、2可以使用[NonSerialized]属性来标志，2、可以使用[XmlIgnore]来标志。

1、使用BinaryFormatter进行串行化

下面是一个可串行化的类：

1.using System;  

2.using System.Data;  

3.using System.Configuration;  

4.using System.Web;  

5.using System.Web.Security;  

6.using System.Web.UI;  

7.using System.Web.UI.WebControls;  

8.using System.Web.UI.WebControls.WebParts;  

9.using System.Web.UI.HtmlControls;  

10.using System.IO;  

11.using System.Runtime.Serialization.Formatters.Binary;  

12./**//// 

15.[Serializable]  

16.public class ClassToSerialize  

17.{  

18.public int id = 100;  

19.public string name = "Name";  

20.[NonSerialized]  

21.public string Sex = "男";  

22.} 

下面是串行化和反串行化的方法：

1.public void SerializeNow()  

2.{  

3.ClassToSerialize c = new ClassToSerialize();  

4.FileStream fileStream = new FileStream("c:\\\emp.dat", FileMode.Create);  

5.BinaryFormatter b = new BinaryFormatter();  

6.b.Serialize(fileStream, c);  

7.fileStream.Close();  

8.}  

9.public void DeSerializeNow()  

10.{  

11.ClassToSerialize c = new ClassToSerialize();  

12.c.Sex = "kkkk";  

13.FileStream fileStream = new FileStream("c:\\\emp.dat", FileMode.Open, FileAccess.Read, FileShare.Read);  

14.BinaryFormatter b = new BinaryFormatter();  

15.c = b.Deserialize(fileStream) as ClassToSerialize;  

16.Response.Write(c.name);  

17.Response.Write(c.Sex);  

18.fileStream.Close();  

19.} 

调用上述两个方法就可以看到串行化的结果：Sex属性因为被标志为[NonSerialized],故其值总是为null。

2、使用SoapFormatter进行串行化

和BinaryFormatter类似，我们只需要做一下简单修改即可：

a.将using语句中的.Formatter.Binary改为.Formatter.Soap;

b.将所有的BinaryFormatter替换为SoapFormatter.

c.确保报存文件的扩展名为.xml

经过上面简单改动，即可实现SoapFormatter的串行化，这时候产生的文件就是一个xml格式的文件。

3、使用XmlSerializer进行串行化

关于格式化器还有一个问题，假设我们需要XML，但是不想要SOAP特有的额外信息，那么我们应该怎么办呢？有两中方案：要么编写一个实现IFormatter接口的类，采用的方式类似于SoapFormatter类,但是没有你不需要的信息；要么使用库类XmlSerializer，这个类不使用Serializable属性，但是它提供了类似的功能。

如果我们不想使用主流的串行化机制，而想使用XmlSeralizer进行串行化我们需要做一下修改：

a.添加System.Xml.Serialization命名空间。

b.Serializable和NoSerialized属性将被忽略,而是使用XmlIgnore属性，它的行为与NoSerialized类似。

c.XmlSeralizer要求类有个默认的构造器，这个条件可能已经满足了。

下面看示例：

要序列化的类：

1.using System;  

2.using System.Data;  

3.using System.Configuration;  

4.using System.Web;  

5.using System.Web.Security;  

6.using System.Web.UI;  

7.using System.Web.UI.WebControls;  

8.using System.Web.UI.WebControls.WebParts;  

9.using System.Web.UI.HtmlControls;  

10.using System.Xml.Serialization;  

11.[Serializable]  

12.public class Person{  

13.private string name;  

14.public string Name{  

15.get{  

16.return name;  

17.}  

18.set{  

19.name = value;  

20.}}  

21.public string Sex;  

22.public int Age = 31;  

23.public Course[] Courses;  

24.public Person()  

25.{}  

26.public Person(string Name){  

27.name = Name;  

28.Sex = "男";  

29.}  

30.}  

31.[Serializable]  

32.public class Course{  

33.public string Name;  

34.[XmlIgnore]  

35.public string Description;  

36.public Course(){}  

37.public Course(string name, string description){  

38.Name = name;  

39.Description = description;  

40.}  

41.}  

序列化和反序列化方法：

1.public void XMLSerialize()  

2.{  

3.Person c = new Person("cyj");  

4.c.Courses = new Course[2];  

5.c.Courses[0] = new Course("英语", "交流工具");  

6.c.Courses[1] = new Course("数学","自然科学");  

7.XmlSerializer xs = new XmlSerializer(typeof(Person));  

8.Stream stream = new FileStream("c:\\\\cyj.XML",FileMode.Create,FileAccess.Write,FileShare.Read);  

9.xs.Serialize(stream,c);  

10.stream.Close();  

11.}  

12.public void XMLDeserialize()  

13.{  

14.XmlSerializer xs = new XmlSerializer(typeof(Person));  

15.Stream stream = new FileStream("C:\\\\cyj.XML",FileMode.Open,FileAccess.Read,FileShare.Read);  

16.Person p = xs.Deserialize(stream) as Person;  

17.Response.Write(p.Name);  

18.Response.Write(p.Age.ToString());  

19.Response.Write(p.Courses[0].Name);  

20.Response.Write(p.Courses[0].Description);  

21.Response.Write(p.Courses[1].Name);  

22.Response.Write(p.Courses[1].Description);  

23.stream.Close();  

24.} 

这里Course类的Description属性值将始终为null，生成的xml文档中也没有该节点，如下：

1. 

2. 

3.男 

4.31 

5. 

6. 

7.英语 

8.交流工具 

9. 

10. 

11.数学 

12.自然科学 

13. 

14. 

15.cyj 

16. 

4、自定义序列化

如果你希望让用户对类进行串行化，但是对数据流的组织方式不完全满意，那么可以通过在自定义类中实现接口来自定义串行化行为。这个接口只有一个方法，GetObjectData. 这个方法用于将对类对象进行串行化所需要的数据填进SerializationInfo对象。你使用的格式化器将构造SerializationInfo对象，然后在串行化时调用GetObjectData. 如果类的父类也实现了ISerializable，那么应该调用GetObjectData的父类实现。

如果你实现了ISerializable，那么还必须提供一个具有特定原型的构造器，这个构造器的参数列表必须与GetObjectData相同。这个构造器应该被声明为私有的或受保护的，以防止粗心的开发人员直接使用它。

示例如下：

实现ISerializable的类：

1.using System;  

2.using System.Data;  

3.using System.Configuration;  

4.using System.Web;  

5.using System.Web.Security;  

6.using System.Web.UI;  

7.using System.Web.UI.WebControls;  

8.using System.Web.UI.WebControls.WebParts;  

9.using System.Web.UI.HtmlControls;  

10.using System.Runtime.Serialization;  

11.using System.Runtime.Serialization.Formatters.Binary;  

12./**//// 

15.[Serializable]  

16.public class Employee:ISerializable  

17.{  

18.public int EmpId=100;  

19.public string EmpName="刘德华";  

20.[NonSerialized]  

21.public string NoSerialString = "NoSerialString-Test";  

22.public Employee()  

23.{  

24.//  

25.// TODO: 在此处添加构造函数逻辑  

26.//  

27.}  

28.private Employee(SerializationInfo info, StreamingContext ctxt)  

29.{  

30.EmpId = (int)info.GetValue("EmployeeId", typeof(int));  

31.EmpName = (String)info.GetValue("EmployeeName",typeof(string));  

32.//NoSerialString = (String)info.GetValue("EmployeeString",typeof(string));  

33.}  

34.public void GetObjectData(SerializationInfo info, StreamingContext ctxt)  

35.{  

36.info.AddValue("EmployeeId", EmpId);  

37.info.AddValue("EmployeeName", EmpName);  

38.//info.AddValue("EmployeeString", NoSerialString);  

39.}  

40.} 

序列化和反序列化方法：

1.public void OtherEmployeeClassTest()  

2.{  

3.Employee mp = new Employee();  

4.mp.EmpId = 10;  

5.mp.EmpName = "邱枫";  

6.mp.NoSerialString = "你好呀";  

7.Stream steam = File.Open("c:\\\emp3.dat", FileMode.Create);  

8.BinaryFormatter bf = new BinaryFormatter();  

9.Response.Write("Writing Employee Info:");  

10.bf.Serialize(steam,mp);  

11.steam.Close();  

12.mp = null;  

13.//反序列化  

14.Stream steam2 = File.Open("c:\\\emp3.dat", FileMode.Open);  

15.BinaryFormatter bf2 = new BinaryFormatter();  

16.Response.Write("Reading Employee Info:");  

17.Employee mp2 = (Employee)bf2.Deserialize(steam2);  

18.steam2.Close();  

19.Response.Write(mp2.EmpId);  

20.Response.Write(mp2.EmpName);  

21.Response.Write(mp2.NoSerialString);  

22.} 

PS：本文章属个人学习总结，部分内容参考互联网上的相关文章。 其中如果发现个人总结有不正确的认知或遗漏的地方请评论告知，欢迎交流。

原文地址：http://www.cnblogs.com/qqflying/archive/2008/01/13/1037262.html