C# 序列化与反序列化

时间：2025-03-27 15:42:22

一、序列化的概念
序列化就是把一个对象保存到一个文件或数据库字段中去，反序列化就是在适当的时候
把这个文件再转化成原来的对象使用。
需要分清楚的概念：对象的序列化而不是类的序列化。对象的序列化表明C#提供了将
运行中的对象（实时数据）写入到硬盘文件或者数据库中，此功能可以运用在需要保留
程序运行时状态信息的环境下。
使用序列化有两个最重要的原因：
一个原因是将对象的状态永久保存在存储媒体中，以便可以在以后重新创建精确的
副本；
另一个原因是通过值将对象从一个应用程序域发送到另一个应用程序域中。
前提：要将对象的类声明为可以序列化。
最主要的作用有：
1、在进程下次启动时读取上次保存的对象的信息
2、在不同的AppDomain或进程之间传递数据
3、在分布式应用系统中传递数据
序列化是把一个内存中的对象的信息转化成一个可以持久化保存的形式，以便于保存或
传输，序列化的主要作用是不同平台之间进行通信，常用的序列化有json、xml、文件
等，下面就逐个讲下这三种序列化的方法。
1、序列化为json
C#中用于对象和json相互转换的原生类有两个：DataContractJsonSerializer和
JavaScriptSerializer，其中JavaScriptSerializer主要用于web的浏览器和服务器之间的通
信。这里主要讲DataContractJsonSerializer的使用，要使用
DataContractJsonSerializer，先要在项目中引用。首先准
备一个测试的类Book：
然后先创建一个Book对象，实例化一个DataContractJsonSerializer实例，最后用该实例
的WriteObject()方法将对象写到流中，代码如下：
/*
[DataContract]指定该类型要定义或实现一个数据协定，并可由序列化程序（如
）进行序列化。
[DataMember]当应用于类型的成员时，指定该成员是数据协定的一部分并可由
进行序列化。
*/
[DataContract]
public class Book
{
[DataMember]
public int ID { get; set; }
[DataMember]
public string Name { get; set; }
[DataMember]
public float Price { get; set; }
}
class Program
{
static void Main(string[] args)
{
//创建一个Book对象
Book book = new Book() { ID = 101, Name = “C#程序设计”, Price =
79.5f };
//序列化json
DataContractJsonSerializer formatter= new
DataContractJsonSerializer(typeof(Book));
using (MemoryStream stream = new MemoryStream())
{
(stream, book);
string result =
.(());
Console.WriteLine(result);
}
}
}
程序的输出结果如图：
将一个json格式的字符串反序列化为对象是用DataContractJsonSerializer实例的
ReadObject()方法，代码如下：
class Program
{
static void Main(string[] args)
{
Book book = new Book() { ID = 101, Name = “C#程序设计”, Price =
79.5f };
//反序列化json
string oriStr = "{“ID”:101,“Name”:"C#程序设计
“,“Price”:79.5}”;
DataContractJsonSerializer formatter = new
DataContractJsonSerializer(typeof(Book));
using (MemoryStream stream = new
MemoryStream(.(oriStr)))
{
Book outBook = (stream) as Book;
();
();
();
}
();

程序输出结果如图：
我们也可以把上面的json序列化与反序列为封装成泛型方法，这样可以公用，全部代码如
下：
}
}
class Program
{
static void Main(string[] args)
{
Book book = new Book() { ID = 101, Name = “C#程序设计”,
Price = 79.5f };
//序列化json
string result = (book);
(result);
//反序列化json
string oriStr = "{“ID”:101,“Name”:"C#程序设计
“,“Price”:79.5}”;
Book outBook = (oriStr);
();
();
();

();
}
}
public class Serializer
{
/// 将对象序列化为json文件
///
/// 类型
/// 实例
/// 存放路径
public static void ObjectToJson(T t, string path) where T :
class
{
DataContractJsonSerializer formatter = new
DataContractJsonSerializer(typeof(T));
using (FileStream stream = new FileStream(path,
))
{
(stream, t);
}
}
///
/// 将对象序列化为json字符串
///
/// 类型
/// 实例
/// json字符串
public static string ObjectToJson(T t) where T : class
{
DataContractJsonSerializer formatter = new
DataContractJsonSerializer(typeof(T));
using (MemoryStream stream = new MemoryStream())
{
(stream, t);
string result =
.(());
return result;
}
}
///

2、序列化为xml
C#中将对象序列化和反序列化为xml的类是XmlSerializer，要引用

先创建一个XmlSerializer对象实例，然后用实例的Serialize的方法将对象写入到文件流
中，代码如下：
/// json字符串转成对象
///
/// 类型
/// json格式字符串
/// 对象
public static T JsonToObject(string json) where T : class
{
DataContractJsonSerializer formatter = new
DataContractJsonSerializer(typeof(Book));
using (MemoryStream stream = new
MemoryStream(.(json)))
{
T result = (stream) as T;
return result;
}
}
}
class Program
{
static void Main(string[] args)
{
Book book = new Book() { ID = 101, Name = “C#程序设计”, Price =
79.5f };
XmlSerializer formatter = new XmlSerializer(typeof(Book));
using (FileStream stream = new FileStream(@“d:\”,
))
{
(stream, book);
}
();
}
}

程序运行后会在c盘产生一个文件，内容如下：
当然也可以将对象转换成对象流，然后转换成xml格式的字符串，代码和效果图如下：
class Program
{
static void Main(string[] args)
{
Book book = new Book() { ID = 101, Name = “C#程序设计”, Price =
79.5f };
XmlSerializer formatter = new XmlSerializer(typeof(Book));
using (MemoryStream stream = new MemoryStream())
{
(stream, book);
string result =
.(());//转换成xml字符串
(result);
}
();
}
}

将xml文件反序列化的方法是用XmlSerializer实例的Deserialize()方法，代码如下：
程序执行完成效果如图：
class Program
{
static void Main(string[] args)
{
Book book = new Book() { ID = 101, Name = “C#程序设计”, Price =
79.5f };
XmlSerializer formatter = new XmlSerializer(typeof(Book));
using (FileStream stream = new FileStream(@“d:”,
))
{
XmlReader xmlReader = new XmlTextReader(stream);
Book outBook = (xmlReader) as Book;//反
序列化
();
();
();
}
();
}
}
我们同样也可以把上面的xml序列化与反序列为封装成泛型方法，这样可以公用，全部代
码如下：
class Program
{
static void Main(string[] args)
{
Book book = new Book() { ID = 101, Name = “C#程序设计”,
Price = 79.5f };

//序列化xml
(book, @“d:\”);
//反序列化xml
Book outBook = (book,
@“d:\”);
();
();
();
();
}
}
public class Serializer
{
///

/// 将对象序列化为xml文件
///
/// 类型
/// 对象
/// xml存放路径
public static void ObjectToXml(T t,string path) where T :
class
{
XmlSerializer formatter = new XmlSerializer(typeof(T));
using (FileStream stream = new FileStream(path,
))
{
(stream, t);
}
}
///
/// 将对象序列化为xml字符串
///
/// 类型
/// 对象
public static string ObjectToXml(T t) where T : class
{
XmlSerializer formatter = new XmlSerializer(typeof(T));
using (MemoryStream stream = new MemoryStream())
{
(stream, t);
string result =
.(());
return result;
}
}
///
/// 将xml文件反序列化为对象
///
/// 类型
/// 对象
/// xml路径
/// 对象
public static T XmlToObject(T t, string path) where T :
class
{

3、序列化为文件
C#中将对象序列化和反序列化为二进制文件的类是BinaryFormatter，要引用

先创建一个BinaryFormatter对象实例，然后用实例的Serialize的方法将对象写入到文件
流中，代码如下：
程序执行完成后产生文件，如图：
XmlSerializer formatter = new XmlSerializer(typeof(T));
using (FileStream stream = new FileStream(path,
))
{
XmlReader xmlReader = new XmlTextReader(stream);
T result = (xmlReader) as T;
return result;
}
}
}
class Program
{
static void Main(string[] args)
{
Book2 book = new Book2() { ID = 101, Name = “C#程序设计”, Price
= 79.5f };
//产生一个序列化类的对象
BinaryFormatter formatter = new BinaryFormatter();
//产生一个文本存放序列化之后的数据流
using (FileStream stream = new FileStream(@“d:\”,
))
{
//开始序列化并写入文本
(stream, book);
}
();
}
}

可以通过BinaryFormatter类型实例的Deserialize()方法把二进制文本反序列化为对象，代
码如下：
程序执行后显示如图：
class Program
{
static void Main(string[] args)
{
//声明被序列化类的对象
Book2 book = new Book2() { ID = 101, Name = “C#程序设计”, Price
= 79.5f };
//序列化文件
BinaryFormatter formatter = new BinaryFormatter();
using (FileStream stream = new FileStream(@“d:\”,
))
{
(“开始还原序列化对象…”);
//将文件中的数据流反序列化后赋值给类的对象
Book2 outBook = (stream) as Book2;
(“\n Binary对象完成还原…如下：”);
();
();
();
}
();
}
}

我们同样也可以把序列化和反序列化为二进制文件的方法封装成泛型方法，全部代码如
下：
class Program
{
static void Main(string[] args)
{
Book book = new Book() { ID = 101, Name = “C#程序设计”,
Price = 79.5f };
//序列化文件
(book, @“d:\”);
//反序列化文件
Book outBook =
(@“d:\”) as Book;
();
();
();
();
}
}
public class Serializer
{
#region 文件序列化
///

/// 将对象序列化为字符串
///
/// 类型
/// 实例
/// 字符串
public static string ObjectToString(T t)
{
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream stream = new MemoryStream())
{
(stream, t);
string result =
.(());
return result;
}
}
///
/// 将对象序列化为文件
///
/// 类型
/// 实例
/// 存放路径
public static void ObjectToFile(T t, string path)
{
BinaryFormatter formatter = new BinaryFormatter();
using (FileStream stream = new FileStream(path,
))
{
(stream, t);
();
}
}
///
/// 将字符串反序列为类型
///
/// 类型
/// 字符串
/// 对象
public static T StringToObject(string s) where T : class
{
byte[] buffer = .(s);

相关文章