C#什么是序列化以及分类

一句两句说不清楚。先给你一个定义：

序列化 (serialization)

将对象的状态信息转换为可以存储或传输的窗体的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

net的运行时环境用来支持用户定义类型的流化的机制。它是将对象实例的状态存储到存储媒体的过程。在此过程中，先将对象的公共字段和私有字段以及类的名称（包括类所在的程序集）转换为字节流，然后再把字节流写入数据流。在随后对对象进行反序列化时，将创建出与原对象完全相同的副本。 序列化的目的: 1、以某种存储形式使自定义对象持久化； 2、将对象从一个地方传递到另一个地方。 实质上序列化机制是将类的值转化为一个一般的（即连续的）字节流，然后就可以将该流写到磁盘文件或任何其他流化目标上。而要想实际的写出这个流，就要使用那些实现了IFormatter接口的类里的Serialize和Deserialize方法。

工具/原料

Visual Studio（本文使用VS2013，其他版本亦可）。

准备工作和类设计

1

启动VS，新建C# 类库项目，并命名为KTools。

2

添加C# Winform项目，命名为Test，重命名主窗口为MainForm，并设置为启动项。同时在KTools项目添加文件夹Serializer，并在该文件夹中添加3个类：XMLSerializer、SoapSerializer和BinarySerializer，如下图：

3

该类库的设计目标是快速方便，最好把序列化和反序列化的方法做成静态方法，这样就可以省去了实例化的步骤。序列化大体上分为序列化到文件和序列化到流，虽然序列化到流更为通用，但序列化到流的步骤中似乎没有什么可简化的，故我们只讨论序列化到文件。对于序列化到文件，我们需要考虑文件是否存在、写入是否覆盖等，为了方便使用只考虑“存在覆盖”的原则。为了尽可能的避免异常（因为这样使用起来更简单，不必考虑是否会引发异常），我们必须确保对象可序列化、文件存在、反序列化时文件不空等。另外，为了避免反序列化时的类型转化，以及更好的使用类，把序列化和范序列化的方法做成泛型。

END

XML序列化和反序列化

1

XML序列化需要引用名称空间SystemXmlSerialization，序列化代码如下：

public static void Serialize<T>(T o, string filePath)

{

try

{

XmlSerializer formatter = new XmlSerializer(typeof(T));

StreamWriter sw = new StreamWriter(filePath, false);

formatterSerialize(sw, o);

swFlush();

swClose();

}

catch (Exception) { }

}

2

XML反序列化，代码如下：

public static T DeSerialize<T>(string filePath)

{

try

{

XmlSerializer formatter = new XmlSerializer(typeof(T));

StreamReader sr = new StreamReader(filePath);

T o = (T)formatterDeserialize(sr);

srClose();

return o;

}

catch (Exception)

{

}

return default(T);

}

END

Soap序列化

1

Soap序列化需要名称引用空间SystemRuntimeSerializationFormattersSoap，并且该dll引用需要手工添加。Soap序列化代码，如下：

public static void Serialize<T>(T o, string filePath)

{

try

{

SoapFormatter formatter = new SoapFormatter();

// StreamWriter sw = new StreamWriter(filePath, false);

Stream stream = new FileStream(filePath , FileModeOpenOrCreate, FileAccessWrite, FileShareNone);

formatterSerialize(stream, o);

streamFlush();

streamClose();

}

catch (Exception) { }

}

2

Soap反序列化，代码如下：

public static T DeSerialize<T>(string filePath)

{

try

{

SoapFormatter formatter = new SoapFormatter();

// StreamReader sr = new StreamReader(filePath);

Stream destream = new FileStream(filePath, FileModeOpen, FileAccessRead, FileShareRead);

T o = (T)formatterDeserialize(destream);

destreamFlush();

destreamClose();

return o;

}

catch (Exception)

{

}

return default(T);

}

END

Binary序列化和反序列化

1

Binary序列化，代码：

public static void Serialize<T>(T o, string filePath)

{

try

{

BinaryFormatter formatter = new BinaryFormatter();

Stream stream = new FileStream(filePath, FileModeOpenOrCreate, FileAccessWrite, FileShareNone);

formatterSerialize(stream, o);

streamFlush();

streamClose();

}

catch (Exception) { }

}

2

Binary反序列化，代码:

public static T DeSerialize<T>(string filePath)

{

try

{

BinaryFormatter formatter = new BinaryFormatter();

Stream destream = new FileStream(filePath, FileModeOpen, FileAccessRead, FileShareRead);

T o = (T)formatterDeserialize(destream);

destreamFlush();

destreamClose();

return o;

}

catch (Exception)

{

}

return default(T);

}

END

测试

在Test项目中的MainForm窗体中添加两个Button控件，分别命名为“序列化”和“反序列化”，并添加代码：

public partial class MainForm : Form

{

public MainForm()

{

InitializeComponent();

}

private void button1_Click(object sender, EventArgs e)

{

string str = "Hello world!!!";

KToolsSerializerXMLSerializerSerialize<string>(str, "1txt");

MessageBoxShow("序列化完毕");

}

private void button2_Click(object sender, EventArgs e)

{

string str = KToolsSerializerXMLSerializerDeSerialize<string>("1txt");

MessageBoxShow(str);

}

}

调试运行，查看结果：

1、什么是序列化？为什么要序列化？

Java 序列化就是指将对象转换为字节序列的过程，而反序列化则是只将字节序列转换成目标对象的过程。

我们都知道，在进行浏览器访问的时候，我们看到的文本、、音频、视频等都是通过二进制序列进行传输的，那么如果我们需要将Java对象进行传输的时候，是不是也应该先将对象进行序列化？答案是肯定的，我们需要先将Java对象进行序列化，然后通过网络，IO进行传输，当到达目的地之后，再进行反序列化获取到我们想要的对象，最后完成通信。

2、如何实现序列化

21、使用到JDK中关键类 ObjectOutputStream 和ObjectInputStream

ObjectOutputStream 类中：通过使用writeObject(Object object) 方法，将对象以二进制格式进行写入。

ObjectInputStream 类中：通过使用readObject（）方法，从输入流中读取二进制流，转换成对象。

22、目标对象需要先实现 Seriable接口

我们创建一个Student类：

public class Student implements Serializable {

private static final long serialVersionUID = 3404072173323892464L;

private String name;

private transient String id;

private String age;

@Override

public String toString() {

return "Student{" +

"name='" + name + '\'' +

", id='" + id + '\'' +

", age='" + age + '\'' +

'}';

}

public String getAge() {

return age;

}

public void setAge(String age) {

thisage = age;

}

public Student(String name, String id) {

Systemoutprintln("args Constructor");

thisname = name;

thisid = id;

}

public Student() {

Systemoutprintln("none-arg Constructor");

}

public String getName() {

return name;

}

public void setName(String name) {

thisname = name;

}

public String getId() {

return id;

}

public void setId(String id) {

thisid = id;

}

}

代码中Student类实现了Serializable 接口，并且生成了一个版本号：

private static final long serialVersionUID = 3404072173323892464L;

首先：

1、Serializable 接口的作用只是用来标识我们这个类是需要进行序列化，并且Serializable 接口中并没有提供任何方法。

2、serialVersionUid 序列化版本号的作用是用来区分我们所编写的类的版本，用于判断反序列化时类的版本是否一直，如果不一致会出现版本不一致异常。

3、transient 关键字，主要用来忽略我们不希望进行序列化的变量

23、将对象进行序列或和反序列化

如果你想学习Java可以来这个群，首先是一二六，中间是五三四，最后是五一九，里面有大量的学习资料可以下载。

231 第一种写入方式：

public static void main(String[] args){

File file = new File("D:/testtxt");

Student student = new Student("孙悟空","12");

try {

ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(file));

outputStreamwriteObject(student);

outputStreamclose();

} catch (IOException e) {

eprintStackTrace();

}

try {

ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));

Student s = (Student) objectInputStreamreadObject();

Systemoutprintln(stoString());

Systemoutprintln(sequals(student));

} catch (IOException e) {

eprintStackTrace();

} catch (ClassNotFoundException e) {

eprintStackTrace();

}

}

创建对象Student ，然后通过ObjectOutputStream类中的writeObject()方法，将对象输出到文件中。

然后通过ObjectinputStream 类中的readObject（）方法反序列化，获取对象。

232 第二种写入方式：

在Student 类中实现writeObject（）和readObject（）方法：

private void writeObject(ObjectOutputStream objectOutputStream) throws IOException {

objectOutputStreamdefaultWriteObject();

objectOutputStreamwriteUTF(id);

}

private void readObject(ObjectInputStream objectInputStream) throws IOException, ClassNotFoundException {

objectInputStreamdefaultReadObject();

id = objectInputStreamreadUTF();

}

通过这中方式进行序列话，我们可以自定义想要进行序列化的变量，将输入流和输出流传入对线实例中，然后进行序列化以及反序列化。

当然可以。常见的序列化有二进制序列化、xml序列化、Json序列化等，二进制序列化需要在类上面添加SerializableAttribute标签，因为是dll中的类，你没办法修改，所以没办法。Xml序列化和Json序列化都不需要标签，以xml序列化为例：

using System;

using SystemIO;

using SystemXmlSerialization;

// This is the class that will be serialized

public class OrderedItem

{

   public string ItemName;

   public string Description;

   public decimal UnitPrice;

   public int Quantity;

   public decimal LineTotal;

   // A custom method used to calculate price per item

   public void Calculate()

   {

      LineTotal = UnitPrice  Quantity;

   }

}

 

public class Test{

   public static void Main(string[] args)

   {

      Test t = new Test();

      // Write a purchase order

      tSerializeObject("simplexml");

   }

 

   private void SerializeObject(string filename)

   {

      ConsoleWriteLine("Writing With Stream");

 

      XmlSerializer serializer = 

      new XmlSerializer(typeof(OrderedItem));

      OrderedItem i = new OrderedItem();

      iItemName = "Widget";

      iDescription = "Regular Widget";

      iQuantity = 10;

      iUnitPrice = (decimal) 230;

      iCalculate();

 

      // Create a FileStream to write with

      Stream writer = new FileStream(filename, FileModeCreate);

      // Serialize the object, and close the TextWriter

      serializerSerialize(writer, i);

      writerClose();

   }

}

基类用QJsonObject比较合适，用宏定义参数，例如

DECLARE_VALUE(name, QString);

DECLARE_VALUE(age, int);

宏展开成set，get方法，#拼接参数1，这样就给每个参数生成了一套接口

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

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

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

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

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

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

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

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

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

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

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

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

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

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

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

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

输出如下

输出如下

在序列化时显示指定serialVersionUID作为版本号，凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量，如果不显示指定，jvm会隐式给我们随机生成一个serialVersionUID，这个serialVersionUID是根据对象的信息生成的，如果我们对序列化对象有所改动的话，serialVersionUID也会随之改动，再反序列化就会因serialVersionUID不一致而报错、

示例：

序列化和反序列化跟上面一样

反序列化

此时是正常且成功的，但是，我们如果现在在User对象新增一个属性

上面我说，serialVersionUID是根据对象信息生成的，现在对象多了一个属性，信息已经改变，再次生成的serialVersionUID 已经和刚才的不一样了，这时我们再进行反序列化会报如下错误

我们指定serialVersionUID后就可以随意修改了

以上就是关于C#什么是序列化以及分类全部的内容，包括:C#什么是序列化以及分类、C#关于序列化和反序列化、什么是java的序列化和反序列化等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！