序列化和反序列化

序列化是把一个内存中的对象的信息转化成一个可以持久化保存的形式，以便于保存或传输，序列化的主要作用是不同平台之间进行通信，常用的有序列化有json、xml、文件等

  一、序列化为json

C#中用于对象和json相互转换的原生类有两个：DataContractJsonSerializer和JavaScriptSerializer，其中JavaScriptSerializer主要用于web的浏览器和服务器之间的通信。这里主要讲DataContractJsonSerializer的使用，要使用DataContractJsonSerializer，先要在项目中引用System.Runtime.Serialization。

首先准备一个测试的类Book：

  1. [DataContract]
  2.     class Book
  3.     {
  4.         [DataMember]
  5.         public int ID { get; set; }
  6.  
  7.         [DataMember]
  8.         public string Name { get; set; }
  9.  
  10.         [DataMember]
  11.         public float Price { get; set; }
  12.     }
  1. [DataContract]指定该类型要定义或实现一个数据协定，并可由序列化程序（如 System.Runtime.Serialization.DataContractSerializer）进行序列化。
    [DataMember]当应用于类型的成员时，指定该成员是数据协定的一部分并可由 System.Runtime.Serialization.DataContractSerializer进行序列化。
  2.  
  3. 然后先创建一个Book对象，实例化一个DataContractJsonSerializer实例，最后用该实例的WriteObject()方法将对象写到流中
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Runtime.Serialization;
  7. using System.Runtime.Serialization.Json;
  8. using System.IO;
  9.  
  10. namespace 序列化Json
  11. {
  12.     class Program
  13.     {
  14.         static void Main(string[] args)
  15.         {
  16.  
  17.             Book book = new Book() { ID = , Name = "C#程序设计", Price = 79.5f };
  18.             //序列化json
  19.             DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(Book));
  20.              using (MemoryStream stream = new MemoryStream())
  21.              {
  22.                  formatter.WriteObject(stream, book);
  23.                  string result = System.Text.Encoding.UTF8.GetString(stream.ToArray());
  24.                  Console.WriteLine(result);
  25.              }
  26.  
  27.             Console.ReadKey();
  28.         }
  29.     }
  30.  
  31.     [DataContract]
  32.     class Book
  33.     {
  34.         [DataMember]
  35.         public int ID { get; set; }
  36.  
  37.         [DataMember]
  38.         public string Name { get; set; }
  39.  
  40.         [DataMember]
  41.         public float Price { get; set; }
  42.     }
  43. }
  1. 将一个json格式的字符串反序列化为对象是用DataContractJsonSerializer实例的ReadObject()方法
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Runtime.Serialization;
  7. using System.Runtime.Serialization.Json;
  8. using System.IO;
  9.  
  10. namespace 序列化Json
  11. {
  12.     class Program
  13.     {
  14.         static void Main(string[] args)
  15.         {
  16.  
  17.             //反序列化json
  18.             string oriStr = "{\"ID\":101,\"Name\":\"C#程序设计\",\"Price\":79.5}";
  19.             DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(Book));
  20.             using (MemoryStream stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(oriStr)))
  21.             {
  22.                 Book outBook = formatter.ReadObject(stream) as Book;
  23.                 Console.WriteLine(outBook.ID);
  24.                 Console.WriteLine(outBook.Name);
  25.                 Console.WriteLine(outBook.Price);
  26.             }
  27.             Console.ReadKey();
  28.         }
  29.     }
  30.  
  31.     [DataContract]
  32.     class Book
  33.     {
  34.         [DataMember]
  35.         public int ID { get; set; }
  36.  
  37.         [DataMember]
  38.         public string Name { get; set; }
  39.  
  40.         [DataMember]
  41.         public float Price { get; set; }
  42.     }
  43. }
  1. 把上面的json序列化与反序列为封装成泛型方法
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Runtime.Serialization;
  7. using System.Runtime.Serialization.Json;
  8. using System.IO;
  9.  
  10. namespace 序列化Json
  11. {
  12.     class Program
  13.     {
  14.         static void Main(string[] args)
  15.         {
  16.  
  17.             Book book = new Book() { ID = , Name = "C#程序设计", Price = 79.5f };
  18.  
  19.             //序列化json
  20.             string result = Serializer.ObjectToJson<Book>(book);
  21.             Console.WriteLine(result);
  22.  
  23.             //反序列化json
  24.             string oriStr = "{\"ID\":101,\"Name\":\"C#程序设计\",\"Price\":79.5}";
  25.             Book outBook = Serializer.JsonToObject<Book>(oriStr);
  26.             Console.WriteLine(outBook.ID);
  27.             Console.WriteLine(outBook.Name);
  28.             Console.WriteLine(outBook.Price);
  29.  
  30.             Console.ReadKey();
  31.         }
  32.     }
  33.  
  34.     public class Serializer
  35.     {
  36.         /// 将对象序列化为json文件
  37.         /// </summary>
  38.         /// <typeparam name="T">类型</typeparam>
  39.         /// <param name="t">实例</param>
  40.         /// <param name="path">存放路径</param>
  41.         public static void ObjectToJson<T>(T t, string path) where T : class
  42.         {
  43.             DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
  44.             using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
  45.             {
  46.                 formatter.WriteObject(stream, t);
  47.             }
  48.         }
  49.  
  50.         /// <summary>
  51.         /// 将对象序列化为json字符串
  52.         /// </summary>
  53.         /// <typeparam name="T">类型</typeparam>
  54.         /// <param name="t">实例</param>
  55.         /// <returns>json字符串</returns>
  56.         public static string ObjectToJson<T>(T t) where T : class
  57.         {
  58.             DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
  59.             using (MemoryStream stream = new MemoryStream())
  60.             {
  61.                 formatter.WriteObject(stream, t);
  62.                 string result = System.Text.Encoding.UTF8.GetString(stream.ToArray());
  63.                 return result;
  64.             }
  65.         }
  66.  
  67.         /// <summary>
  68.         /// json字符串转成对象
  69.         /// </summary>
  70.         /// <typeparam name="T">类型</typeparam>
  71.         /// <param name="json">json格式字符串</param>
  72.         /// <returns>对象</returns>
  73.         public static T JsonToObject<T>(string json) where T : class
  74.         {
  75.             DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(Book));
  76.             using (MemoryStream stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(json)))
  77.             {
  78.                 T result = formatter.ReadObject(stream) as T;
  79.                 return result;
  80.             }
  81.         }
  82.     } 
  83.  
  84.     [DataContract]
  85.     class Book
  86.     {
  87.         [DataMember]
  88.         public int ID { get; set; }
  89.  
  90.         [DataMember]
  91.         public string Name { get; set; }
  92.  
  93.         [DataMember]
  94.         public float Price { get; set; }
  95.     }
  96. }

二、序列化为xml

  1. C#中将对象序列化和反序列化为xml的类是XmlSerializer，要引用System.Xml.Serialization
    先创建一个XmlSerializer对象实例，然后用实例的Serialize的方法将对象写入到文件流中
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Xml.Serialization;
  7. using System.IO;
  8.  
  9. namespace 序列化XML
  10. {
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  15.             Book book = new Book() { ID = , Name = "C#程序设计", Price = 79.5f };
  16.  
  17.             XmlSerializer formatter = new XmlSerializer(typeof(Book));
  18.             using (FileStream stream = new FileStream(@"c:\book.xml", FileMode.OpenOrCreate))
  19.             {
  20.                 formatter.Serialize(stream, book);
  21.             }
  22.             Console.Read();
  23.  
  24.         }
  25.     }
  26.  
  27.     [Serializable]
  28.     public class Book
  29.     {
  30.  
  31.         public int ID { get; set; }
  32.         public string Name { get; set; }
  33.         public float Price { get; set; }
  34.     }
  35.  
  36. }

book.xml:

  1. 当然也可以将对象转换成对象流，然后转换成xml格式的字符串
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Xml.Serialization;
  7. using System.IO;
  8.  
  9. namespace 序列化XML
  10. {
  11.     class Program
  12.     {
  13.         static void Main(string[] args)
  14.         {
  15.  
  16.             Book book = new Book() { ID = , Name = "C#程序设计", Price = 79.5f };
  17.  
  18.             XmlSerializer formatter = new XmlSerializer(typeof(Book));
  19.             using (MemoryStream stream = new MemoryStream())
  20.             {
  21.                 formatter.Serialize(stream, book);
  22.                 string result = System.Text.Encoding.UTF8.GetString(stream.ToArray());//转换成xml字符串
  23.                 Console.WriteLine(result);
  24.             }
  25.  
  26.             Console.Read();
  27.  
  28.         }
  29.     }
  30.  
  31.     [Serializable]
  32.     public class Book
  33.     {
  34.  
  35.         public int ID { get; set; }
  36.         public string Name { get; set; }
  37.         public float Price { get; set; }
  38.     }
  39.  
  40. }
  1. 将xml文件反序列化的方法是用XmlSerializer实例的Deserialize()方法
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using System.Xml.Serialization;
  7. using System.IO;
  8. using System.Xml;
  9.  
  10. namespace 序列化XML
  11. {
  12.     class Program
  13.     {
  14.         static void Main(string[] args)
  15.         {
  16.  
  17.             XmlSerializer formatter = new XmlSerializer(typeof(Book));
  18.             using (FileStream stream = new FileStream(@"c:\book.xml", FileMode.OpenOrCreate))
  19.             {
  20.                 XmlReader xmlReader = new XmlTextReader(stream);
  21.                 Book outBook = formatter.Deserialize(xmlReader) as Book;//反序列化
  22.                 Console.WriteLine(outBook.ID);
  23.                 Console.WriteLine(outBook.Name);
  24.                 Console.WriteLine(outBook.Price);
  25.             }
  26.  
  27.             Console.Read();
  28.  
  29.         }
  30.     }
  31.  
  32.     [Serializable]
  33.     public class Book
  34.     {
  35.  
  36.         public int ID { get; set; }
  37.         public string Name { get; set; }
  38.         public float Price { get; set; }
  39.     }
  40.  
  41. }
  1. xml序列化与反序列为封装成泛型方法
  1. class Program
  2.      {
  3.          static void Main(string[] args)
  4.          {
  5.              Book book = new Book() { ID = , Name = "C#程序设计", Price = 79.5f };
  6.  
  7.              //序列化xml
  8.              Serializer.ObjectToXml(book, @"c:\book.xml");
  9.  
  10.              //反序列化xml
  11.              Book outBook = Serializer.XmlToObject(book, @"c:\book.xml");
  12.              Console.WriteLine(outBook.ID);
  13.              Console.WriteLine(outBook.Name);
  14.              Console.WriteLine(outBook.Price);
  15.              Console.Read();
  16.          }
  17.      }
  18.  
  19.      public class Serializer
  20.      {
  21.          /// <summary>
  22.          /// 将对象序列化为xml文件
  23.          /// </summary>
  24.          /// <typeparam name="T">类型</typeparam>
  25.          /// <param name="t">对象</param>
  26.          /// <param name="path">xml存放路径</param>
  27.          public static void ObjectToXml<T>(T t,string path) where T : class
  28.          {
  29.              XmlSerializer formatter = new XmlSerializer(typeof(T));
  30.              using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
  31.              {
  32.                  formatter.Serialize(stream, t);
  33.              }
  34.          }
  35.  
  36.          /// <summary>
  37.          /// 将对象序列化为xml字符串
  38.          /// </summary>
  39.          /// <typeparam name="T">类型</typeparam>
  40.          /// <param name="t">对象</param>
  41.          public static string ObjectToXml<T>(T t) where T : class
  42.          {
  43.              XmlSerializer formatter = new XmlSerializer(typeof(T));
  44.              using (MemoryStream stream = new MemoryStream())
  45.              {
  46.                  formatter.Serialize(stream, t);
  47.                  string result = System.Text.Encoding.UTF8.GetString(stream.ToArray());
  48.                  return result;
  49.              }
  50.          }
  51.  
  52.          /// <summary>
  53.          /// 将xml文件反序列化为对象
  54.          /// </summary>
  55.          /// <typeparam name="T">类型</typeparam>
  56.          /// <param name="t">对象</param>
  57.          /// <param name="path">xml路径</param>
  58.          /// <returns>对象</returns>
  59.          public static T XmlToObject<T>(T t, string path) where T : class
  60.          {
  61.              XmlSerializer formatter = new XmlSerializer(typeof(T));
  62.              using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
  63.              {
  64.                  XmlReader xmlReader = new XmlTextReader(stream);
  65.                  T result = formatter.Deserialize(xmlReader) as T;
  66.                  return result;
  67.              }
  68.          }
  69.      }

三、序列化为文件

  1. C#中将对象序列化和反序列化为二进制文件的类是BinaryFormatter，要引用System.Runtime.Serialization.Formatters.Binary
    先创建一个BinaryFormatter对象实例，然后用实例的Serialize的方法将对象写入到文件流中
  1. class Program
  2.      {
  3.          static void Main(string[] args)
  4.          {
  5.              Book book = new Book() { ID = , Name = "C#程序设计", Price = 79.5f };
  6.  
  7.              //序列化文件
  8.              BinaryFormatter formatter = new BinaryFormatter();
  9.              using (FileStream stream = new FileStream(@"c:\book.txt", FileMode.OpenOrCreate))
  10.              {
  11.                  formatter.Serialize(stream, book);
  12.              }
  13.              Console.Read();
  14.          }
  15.      }
  1. 可以通过BinaryFormatter类型实例的Deserialize()方法把二进制文本反序列化为对象
  1. class Program
  2.      {
  3.          static void Main(string[] args)
  4.          {
  5.              Book book = new Book() { ID = , Name = "C#程序设计", Price = 79.5f };
  6.  
  7.              //序列化文件
  8.              BinaryFormatter formatter = new BinaryFormatter();
  9.              using (FileStream stream = new FileStream(@"c:\book.txt", FileMode.OpenOrCreate))
  10.              {
  11.                  Book outBook = formatter.Deserialize(stream) as Book;
  12.                  Console.WriteLine(outBook.ID);
  13.                  Console.WriteLine(outBook.Name);
  14.                  Console.WriteLine(outBook.Price);
  15.              }
  16.              Console.Read();
  17.          }
  18.      }

把序列化和把序列化为二进制文件的方法封装成泛型方法

  1. class Program
  2.      {
  3.          static void Main(string[] args)
  4.          {
  5.              Book book = new Book() { ID = , Name = "C#程序设计", Price = 79.5f };
  6.              //序列化文件
  7.              Serializer.ObjectToFile(book, @"c:\book.txt");
  8.  
  9.              //反序列化文件
  10.              Book outBook = Serializer.FileToObject<Book>(@"c:\book.txt") as Book;
  11.              Console.WriteLine(outBook.ID);
  12.              Console.WriteLine(outBook.Name);
  13.              Console.WriteLine(outBook.Price);
  14.              Console.Read();
  15.          }
  16.      }
  17.  
  18.      public class Serializer
  19.      {
  20.          #region 文件序列化
  21.          /// <summary>
  22.          /// 将对象序列化为字符串
  23.          /// </summary>
  24.          /// <typeparam name="T">类型</typeparam>
  25.          /// <param name="t">实例</param>
  26.          /// <returns>字符串</returns>
  27.          public static string ObjectToString<T>(T t)
  28.          {
  29.              BinaryFormatter formatter = new BinaryFormatter();
  30.              using (MemoryStream stream = new MemoryStream())
  31.              {
  32.                  formatter.Serialize(stream, t);
  33.                  string result = System.Text.Encoding.UTF8.GetString(stream.ToArray());
  34.                  return result;
  35.              }
  36.          }
  37.  
  38.          /// <summary>
  39.          /// 将对象序列化为文件
  40.          /// </summary>
  41.          /// <typeparam name="T">类型</typeparam>
  42.          /// <param name="t">实例</param>
  43.          /// <param name="path">存放路径</param>
  44.          public static void ObjectToFile<T>(T t, string path)
  45.          {
  46.              BinaryFormatter formatter = new BinaryFormatter();
  47.              using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
  48.              {
  49.                  formatter.Serialize(stream, t);
  50.                  stream.Flush();
  51.              }
  52.          }
  53.  
  54.          /// <summary>
  55.          /// 将字符串反序列为类型
  56.          /// </summary>
  57.          /// <typeparam name="T">类型</typeparam>
  58.          /// <param name="s">字符串</param>
  59.          /// <returns>对象</returns>
  60.          public static T StringToObject<T>(string s) where T : class
  61.          {
  62.              byte[] buffer = System.Text.Encoding.UTF8.GetBytes(s);
  63.              BinaryFormatter formatter = new BinaryFormatter();
  64.              using (MemoryStream stream = new MemoryStream(buffer))
  65.              {
  66.                  T result = formatter.Deserialize(stream) as T;
  67.                  return result;
  68.              }
  69.          }
  70.  
  71.          /// <summary>
  72.          /// 将文件反序列化为对象
  73.          /// </summary>
  74.          /// <typeparam name="T">类型</typeparam>
  75.          /// <param name="path">路径</param>
  76.          /// <returns>对象</returns>
  77.          public static T FileToObject<T>(string path) where T : class
  78.          {
  79.              using (FileStream stream = new FileStream(path, FileMode.Open))
  80.              {
  81.                  BinaryFormatter formatter = new BinaryFormatter();
  82.                  T result = formatter.Deserialize(stream) as T;
  83.                  return result;
  84.              }
  85.          }
  86.          #endregion
  87.      }
  88.  
  89.      [Serializable]
  90.      public class Book
  91.      {
  92.          public int ID { get; set; }
  93.          public string Name { get; set; }
  94.          public float Price { get; set; }
  95.      }

转自：http://www.cnblogs.com/maitian-lf/p/3670570.html

C#面向对象20 序列化和反序列化的更多相关文章

  1. [.net 面向对象程序设计进阶] (12) 序列化(Serialization)(四) 快速掌握JSON的序列化和反序列化

    [.net 面向对象程序设计进阶] (12) 序列化(Serialization)(四) 快速掌握JSON的序列化和反序列化 本节导读: 介绍JSON的结构,在JS中的使用.重点说明JSON如何在.N ...

  2. 在net中json序列化与反序列化 面向对象六大原则 (第一篇) 一步一步带你了解linq to Object 10分钟浅谈泛型协变与逆变

    在net中json序列化与反序列化   准备好饮料,我们一起来玩玩JSON,什么是Json:一种数据表示形式,JSON:JavaScript Object Notation对象表示法 Json语法规则 ...

  3. （转+整理）C# BinaryFormatter进行序列化与反序列化

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

  4. day5-python中的序列化与反序列化-json&pickle

    一.概述 玩过稍微大型一点的游戏的朋友都知道,很多游戏的存档功能使得我们可以方便地迅速进入上一次退出的状态(包括装备.等级.经验值等在内的一切运行时数据),那么在程序开发中也存在这样的需求:比较简单的 ...

  5. Java 中序列化与反序列化

    一. 序列化和反序列化概念 Serialization(序列化)是一种将对象以一连串的字节描述的过程:反序列化deserialization是一种将这些字节重建成一个对象的过程.将程序中的对象,放入文 ...

  6. 使用Newtonsoft.Json.dll(JSON.NET)动态解析JSON、.net 的json的序列化与反序列化（一）

    在开发中,我非常喜欢动态语言和匿名对象带来的方便,JSON.NET具有动态序列化和反序列化任意JSON内容的能力,不必将它映射到具体的强类型对象,它可以处理不确定的类型(集合.字典.动态对象和匿名对象 ...

  7. Java序列化与反序列化

    Java序列化与反序列化是什么?为什么需要序列化与反序列化?如何实现Java序列化与反序列化?本文围绕这些问题进行了探讨. 1.Java序列化与反序列化 Java序列化是指把Java对象转换为字节序列 ...

  8. java 对象序列化与反序列化

    Java序列化与反序列化是什么? 为什么需要序列化与反序列化? 如何实现Java序列化与反序列化? 本文围绕这些问题进行了探讨. 1.Java序列化与反序列化  Java序列化是指把Java对象转换为 ...

  9. Java基础学习总结——Java对象的序列化和反序列化

    一.序列化和反序列化的概念 把对象转换为字节序列的过程称为对象的序列化. 把字节序列恢复为对象的过程称为对象的反序列化. 对象的序列化主要有两种用途: 1) 把对象的字节序列永久地保存到硬盘上,通常存 ...

随机推荐

  1. js判断滚动条是否已到页面最底部或顶部实例

    原文 本文实例讲述了js判断滚动条是否已到页面最底部或顶部的方法.分享给大家供大家参考.具体分析如下: 我们经常会看到很多的网站一个返回顶部效果就是当我们滚动条到指定位置时返回顶部出来了,否则就自动隐 ...

  2. Linux设备驱动程序 之 poll和select

    使用非阻塞IO的应用程序经常使用select,poll,epoll系统调用:它们的功能本质上是一样的:都允许进程决定是否可以对一个或者多个打开的文件做非阻塞的读取或者写入:这些电泳也会阻塞进程,直到给 ...

  3. Ubuntu18.04 server安装步骤

    Ubuntu18.04 server安装步骤 1. select a language default 2.  select your location default 3. configure th ...

  4. Flutter移动电商实战 --（11）首页_屏幕适配方案和制作

    1.flutter_ScreenUtil插件简介 flutter_ScreenUtil屏幕适配方案,让你的UI在不同尺寸的屏幕上都能显示合理的布局. 插件会让你先设置一个UI稿的尺寸,他会根据这个尺寸 ...

  5. 数据分析 - matpltlib 模块

    matplotlib 模块 引入模块 import matplotlib.pyplot as plt 设置图片大小 - figure 展示图片 - show 画图 - 实例化后指定类型画图 plot  ...

  6. 【译】优雅的停止docker容器

    1. 介绍 Docker的大部分重点是在隔离的容器中打包和运行应用程序的过程.有无数的教程说明了如何在Docker容器中运行应用程序,但是很少有教程讨论如何正确停止容器化的应用程序.这似乎是一个愚蠢的 ...

  7. 小D课堂 - 新版本微服务springcloud+Docker教程_3-07 Eureka服务注册中心配置控制台问题处理

    笔记 7.Eureka服务注册中心配置控制台问题处理     简介:讲解服务注册中心管理后台,(后续还会细讲) 问题:eureka管理后台出现一串红色字体:是警告,说明有服务上线率低 EMERGENC ...

  8. JavaScript（7）——DOM

    什么是 DOM? DOM是 Document Object Model(文档对象模型)的缩写 DOM是 W3C(万维网联盟)的标准. DOM 定义了访问 HTML 和 XML 文档的标准: “W3C ...

  9. springboot-springmvc

    0依赖 <!-- jsp --> <dependency> <groupId>org.apache.tomcat.embed</groupId> < ...

  10. python-Web-django-商城-session存入数据库

    utils: '''用户session''' import datetime from app01.models import Sessions ''' iii = request.session.s ...