所谓的序列化其实就是把一个内存中的对象信息转化成一个可以持久化保存的形式，方便保存数据库和文件或着用于传输，

序列化的主要作用是不同平台之间进行通信与信息的传递保存等，常用的有序列化有Json Xml Binary Soap JavaScript序列化等，当然我们也可以使用第三方的序列化类库，第三方的序列化类库可以参照网上的，这里不再赘述，

本文主要介绍Json Xml Binary Soap JavaScript等6种序列化的方法，

添加引用以下类库

  1. using System.Runtime.Serialization.Json;//DataContractJsonSerializer序列化
  2. using System.Xml.Serialization;//XmlSerializer序列化
  3. using System.Runtime.Serialization.Formatters.Binary;//BinarySerializer序列化
  4. using System.Runtime.Serialization.Formatters.Soap;//SoapSerializer序列化
  5. using System.Web.Script.Serialization;//JavaScriptSerializer序列化

代码如下：

  1. using System;
  2. using System.Text;
  3. using System.IO;
  4. using System.Runtime.Serialization.Json;//DataContractJsonSerializer序列化
  5. using System.Xml.Serialization;//XmlSerializer序列化
  6. using System.Runtime.Serialization.Formatters.Binary;//BinarySerializer序列化
  7. using System.Runtime.Serialization.Formatters.Soap;//SoapSerializer序列化
  8. using System.Web.Script.Serialization;//JavaScriptSerializer序列化
  9.  
  10. namespace SupremeConsole
  11. {
  12.     /// <summary>
  13.     /// 序列化单例对象
  14.     /// </summary>
  15.     public class SerializeManager : SingleManager<SerializeManager>
  16.     {
  17.         public SerializeManager()
  18.         {
  19.             Initialize();
  20.         }
  21.  
  22.         public override void Initialize()
  23.         {
  24.             base.Initialize();
  25.         }
  26.  
  27.         /// <summary>
  28.         /// DataContractJson泛型序列化
  29.         /// </summary>
  30.         /// <typeparam name="T">泛型类型</typeparam>
  31.         /// <param name="t">泛型对象</param>
  32.         /// <returns>泛型对象序列化的字符串</returns>
  33.         public string DataContractJsonSerialize<T>(T t) where T : class
  34.         {
  35.             string s = null;
  36.             try
  37.             {
  38.                 using MemoryStream ms = new MemoryStream();
  39.                 DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
  40.                 dcjs.WriteObject(ms, t);
  41.                 s = Encoding.UTF8.GetString(ms.ToArray());
  42.             }
  43.             catch (Exception ex)
  44.             {
  45.                 Program.Log.Error($"DataContractJson泛型序列化错误信息：{ex.ToString()}");
  46.             }
  47.             return s;
  48.         }
  49.  
  50.         /// <summary>
  51.         /// DataContractJson泛型序列化
  52.         /// </summary>
  53.         /// <typeparam name="T">泛型类型</typeparam>
  54.         /// <param name="t">泛型对象</param>
  55.         /// <param name="path">保存的路径</param>
  56.         public void DataContractJsonSerialize<T>(T t, string path) where T : class
  57.         {
  58.             try
  59.             {
  60.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
  61.                 using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
  62.                 DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
  63.                 dcjs.WriteObject(fs, t);
  64.             }
  65.             catch (Exception ex)
  66.             {
  67.                 Program.Log.Error($"DataContractJson泛型序列化错误信息：{ex.ToString()}");
  68.             }
  69.         }
  70.  
  71.         /// <summary>
  72.         /// DataContractJson泛型的反序列化
  73.         /// </summary>
  74.         /// <typeparam name="T">泛型类型</typeparam>
  75.         /// <param name="json">反序列化的序列化文件路径</param>
  76.         /// <returns>泛型对象</returns>
  77.         public T DataContractJsonDeserializeJson<T>(string json) where T : class
  78.         {
  79.             T t = null;
  80.             try
  81.             {
  82.                 using MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json));
  83.                 DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
  84.                 if (dcjs.ReadObject(ms) is T a)
  85.                 {
  86.                     t = a;
  87.                 }
  88.             }
  89.             catch (Exception ex)
  90.             {
  91.                 Program.Log.Error($"DataContractJson泛型反序列化错误信息：{ex.ToString()}");
  92.             }
  93.             return t;
  94.         }
  95.  
  96.         /// <summary>
  97.         /// DataContractJson泛型的反序列化
  98.         /// </summary>
  99.         /// <typeparam name="T">泛型类型</typeparam>
  100.         /// <param name="json">反序列化的序列化文件路径</param>
  101.         /// <returns>泛型对象</returns>
  102.         public T DataContractJsonDeserialize<T>(string path) where T : class
  103.         {
  104.             T t = null;
  105.             try
  106.             {
  107.                 using MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(File.ReadAllText(path)));
  108.                 DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
  109.                 if (dcjs.ReadObject(ms) is T a)
  110.                 {
  111.                     t = a;
  112.                 }
  113.             }
  114.             catch (Exception ex)
  115.             {
  116.                 Program.Log.Error($"DataContractJson泛型反序列化错误信息：{ex.ToString()}");
  117.             }
  118.             return t;
  119.         }
  120.  
  121.         /// <summary>
  122.         /// Xml泛型序列化
  123.         /// </summary>
  124.         /// <typeparam name="T">泛型类型</typeparam>
  125.         /// <param name="t">泛型对象</param>
  126.         /// <returns>泛型对象序列化的字符串</returns>
  127.         public string XmlSerialize<T>(T t) where T : class
  128.         {
  129.             string s = null;
  130.             try
  131.             {
  132.                 using MemoryStream ms = new MemoryStream();
  133.                 XmlSerializer xs = new XmlSerializer(typeof(T));
  134.                 xs.Serialize(ms, t);
  135.                 s = Encoding.UTF8.GetString(ms.ToArray());
  136.             }
  137.             catch (Exception ex)
  138.             {
  139.                 Program.Log.Error($"Xml泛型序列化错误信息：{ex.ToString()}");
  140.             }
  141.             return s;
  142.         }
  143.  
  144.         /// <summary>
  145.         /// Xml泛型序列化
  146.         /// </summary>
  147.         /// <typeparam name="T">泛型类型</typeparam>
  148.         /// <param name="t">泛型对象</param>
  149.         /// <param name="path">保存的路径</param>
  150.         public void XmlSerialize<T>(T t, string path) where T : class
  151.         {
  152.             try
  153.             {
  154.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
  155.                 using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
  156.                 XmlSerializer xs = new XmlSerializer(typeof(T));
  157.                 xs.Serialize(fs, t);
  158.             }
  159.             catch (Exception ex)
  160.             {
  161.                 Program.Log.Error($"Xml泛型序列化错误信息：{ex.ToString()}");
  162.             }
  163.         }
  164.  
  165.         /// <summary>
  166.         /// Xml泛型的反序列化
  167.         /// </summary>
  168.         /// <typeparam name="T">泛型类型</typeparam>
  169.         /// <param name="path">反序列化的序列化文件路径</param>
  170.         /// <returns>泛型对象</returns>
  171.         public T XmlDeserialize<T>(string path) where T : class
  172.         {
  173.             T t = null;
  174.             try
  175.             {
  176.                 using MemoryStream ms = new MemoryStream(File.ReadAllBytes(path));
  177.                 XmlSerializer xs = new XmlSerializer(typeof(T));
  178.                 if (xs.Deserialize(ms) is T a)
  179.                 {
  180.                     t = a;
  181.                 }
  182.             }
  183.             catch (Exception ex)
  184.             {
  185.                 Program.Log.Error($"Xml泛型的反序列化错误信息：{ex.ToString()}");
  186.             }
  187.             return t;
  188.         }
  189.  
  190.         /// <summary>
  191.         /// Binary泛型序列化
  192.         /// </summary>
  193.         /// <typeparam name="T">泛型类型</typeparam>
  194.         /// <param name="t">泛型对象</param>
  195.         /// <returns>泛型对象序列化的字符串</returns>
  196.         public string BinarySerialize<T>(T t) where T : class
  197.         {
  198.             string s = null;
  199.             try
  200.             {
  201.                 using MemoryStream ms = new MemoryStream();
  202.                 BinaryFormatter bf = new BinaryFormatter();
  203.                 bf.Serialize(ms, t);
  204.                 s = Encoding.UTF8.GetString(ms.ToArray());
  205.             }
  206.             catch (Exception ex)
  207.             {
  208.                 Program.Log.Error($"Binary泛型序列化错误信息：{ex.ToString()}");
  209.             }
  210.             return s;
  211.         }
  212.  
  213.         /// <summary>
  214.         /// Binary泛型序列化
  215.         /// </summary>
  216.         /// <typeparam name="T">泛型类型</typeparam>
  217.         /// <param name="t">泛型对象</param>
  218.         /// <param name="path">保存的路径</param>
  219.         public void BinarySerialize<T>(T t, string path) where T : class
  220.         {
  221.             try
  222.             {
  223.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
  224.                 using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
  225.                 BinaryFormatter bf = new BinaryFormatter();
  226.                 bf.Serialize(fs, t);
  227.             }
  228.             catch (Exception ex)
  229.             {
  230.                 Program.Log.Error($"Binary泛型序列化错误信息：{ex.ToString()}");
  231.             }
  232.         }
  233.  
  234.         /// <summary>
  235.         /// Binary泛型的反序列化
  236.         /// </summary>
  237.         /// <typeparam name="T">泛型类型</typeparam>
  238.         /// <param name="path">反序列化的序列化文件路径</param>
  239.         /// <returns>泛型对象</returns>
  240.         public T BinaryDeserialize<T>(string path) where T : class
  241.         {
  242.             T t = null;
  243.             try
  244.             {
  245.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
  246.                 using MemoryStream fs = new MemoryStream(File.ReadAllBytes(path));
  247.                 BinaryFormatter bf = new BinaryFormatter();
  248.                 if (bf.Deserialize(fs) is T a)
  249.                 {
  250.                     t = a;
  251.                 }
  252.             }
  253.             catch (Exception ex)
  254.             {
  255.                 Program.Log.Error($"Binary泛型的反序列化错误信息：{ex.ToString()}");
  256.             }
  257.             return t;
  258.         }
  259.  
  260.         /// <summary>
  261.         /// Soap泛型序列化
  262.         /// </summary>
  263.         /// <typeparam name="T">泛型类型</typeparam>
  264.         /// <param name="t">泛型对象</param>
  265.         /// <returns>泛型对象序列化的字符串</returns>
  266.         public string SoapSerialize<T>(T t) where T : class
  267.         {
  268.             string s = null;
  269.             try
  270.             {
  271.                 using MemoryStream ms = new MemoryStream();
  272.                 SoapFormatter sf = new SoapFormatter();
  273.                 sf.Serialize(ms, t);
  274.                 s = Encoding.UTF8.GetString(ms.ToArray());
  275.             }
  276.             catch (Exception ex)
  277.             {
  278.                 Program.Log.Error($"Soap泛型序列化错误信息：{ex.ToString()}");
  279.             }
  280.             return s;
  281.         }
  282.  
  283.         /// <summary>
  284.         ///Soap泛型序列化
  285.         /// </summary>
  286.         /// <typeparam name="T">泛型类型</typeparam>
  287.         /// <param name="t">泛型对象</param>
  288.         /// <param name="path">保存的路径</param>
  289.         public void SoapSerialize<T>(T t, string path) where T : class
  290.         {
  291.             try
  292.             {
  293.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
  294.                 using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
  295.                 SoapFormatter sf = new SoapFormatter();
  296.                 sf.Serialize(fs, t);
  297.             }
  298.             catch (Exception ex)
  299.             {
  300.                 Program.Log.Error($"Soap泛型序列化错误信息：{ex.ToString()}");
  301.             }
  302.         }
  303.  
  304.         /// <summary>
  305.         /// Soap泛型的反序列化
  306.         /// </summary>
  307.         /// <typeparam name="T">泛型类型</typeparam>
  308.         /// <param name="path">反序列化的序列化文件路径</param>
  309.         /// <returns>泛型对象</returns>
  310.         public T SoapDeserialize<T>(string path) where T : class
  311.         {
  312.             T t = null;
  313.             try
  314.             {
  315.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
  316.                 using MemoryStream fs = new MemoryStream(File.ReadAllBytes(path));
  317.                 SoapFormatter sf = new SoapFormatter();
  318.                 if (sf.Deserialize(fs) is T a)
  319.                 {
  320.                     t = a;
  321.                 }
  322.             }
  323.             catch (Exception ex)
  324.             {
  325.                 Program.Log.Error($"Soap泛型的反序列化错误信息：{ex.ToString()}");
  326.             }
  327.             return t;
  328.         }
  329.  
  330.         /// <summary>
  331.         /// JavaScript泛型序列化
  332.         /// </summary>
  333.         /// <typeparam name="T">泛型类型</typeparam>
  334.         /// <param name="t">泛型对象</param>
  335.         /// <returns>泛型对象序列化的字符串</returns>
  336.         public string JavaScriptSerialize<T>(T t) where T : class
  337.         {
  338.             string s = null;
  339.             try
  340.             {
  341.                 JavaScriptSerializer jss = new JavaScriptSerializer();
  342.                 s = jss.Serialize(t);
  343.             }
  344.             catch (Exception ex)
  345.             {
  346.                 Program.Log.Error($"JavaScript泛型序列化错误信息：{ex.ToString()}");
  347.             }
  348.             return s;
  349.         }
  350.  
  351.         /// <summary>
  352.         ///JavaScript泛型序列化
  353.         /// </summary>
  354.         /// <typeparam name="T">泛型类型</typeparam>
  355.         /// <param name="t">泛型对象</param>
  356.         /// <param name="path">保存的路径</param>
  357.         public void JavaScriptSerialize<T>(T t, string path) where T : class
  358.         {
  359.             try
  360.             {
  361.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
  362.                 using FileStream fs = new FileStream(path, FileMode.OpenOrCreate);
  363.                 using StreamWriter sw = new StreamWriter(fs);
  364.                 StringBuilder sb = new StringBuilder();
  365.                 JavaScriptSerializer jss = new JavaScriptSerializer();
  366.                 jss.Serialize(t, sb);
  367.                 sw.WriteLine(sb.ToString());
  368.             }
  369.             catch (Exception ex)
  370.             {
  371.                 Program.Log.Error($"JavaScript泛型序列化错误信息：{ex.ToString()}");
  372.             }
  373.         }
  374.  
  375.         /// <summary>
  376.         /// JavaScript泛型的反序列化
  377.         /// </summary>
  378.         /// <typeparam name="T">泛型类型</typeparam>
  379.         /// <param name="path">反序列化的序列化文件路径</param>
  380.         /// <returns>泛型对象</returns>
  381.         public T JavaScriptDeserialize<T>(string path) where T : class
  382.         {
  383.             T t = null;
  384.             try
  385.             {
  386.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "test.txt");
  387.                 string input = Encoding.UTF8.GetString(File.ReadAllBytes(path));
  388.                 JavaScriptSerializer jss = new JavaScriptSerializer();
  389.                 if (jss.Deserialize<T>(input) is T a)
  390.                 {
  391.                     t = a;
  392.                 }
  393.             }
  394.             catch (Exception ex)
  395.             {
  396.                 Program.Log.Error($"JavaScript泛型的反序列化错误信息：{ex.ToString()}");
  397.             }
  398.             return t;
  399.         }
  400.     }
  401. }

控制台程序主方法Main测试调用方式如下：

  1.         static void Main(string[] args)
  2.         {
  3.             #region MyRegion
  4.             try
  5.             {
  6.                 TestClass testClass = new TestClass { Id = , Name = "张三", Age = , Address = "上海浦东新区2弄5汤", Sex = "男" };
  7.                 #region DataContractJsonSerialize 要序列化的对象可以不添加SerializableAttribute属性，[Serializable]
  8.                 //string s = SerializeManager.Instance.DataContractJsonSerialize<TestClass>(testClass);//序列化
  9.                 //Console.ForegroundColor = ConsoleColor.Green;
  10.                 //Console.WriteLine("测试序列化成功。。。");
  11.                 //Console.WriteLine($"测试序列化结果：{s}");
  12.  
  13.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化123.txt");//序列化
  14.                 //SerializeManager.Instance.DataContractJsonSerialize<TestClass>(testClass, path);
  15.  
  16.                 //string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
  17.                 //TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
  18.                 //if (test != null)
  19.                 //{
  20.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  21.                 //}
  22.  
  23.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化123.txt");
  24.                 //TestClass test = SerializeManager.Instance.DataContractJsonDeserialize<TestClass>(path);//反序列化
  25.                 //if (test != null)
  26.                 //{
  27.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  28.                 //}
  29.                 #endregion
  30.  
  31.                 #region XmlSerialize 要序列化的对象可以不添加SerializableAttribute属性，[Serializable]
  32.                 //string s = SerializeManager.Instance.XmlSerialize<TestClass>(testClass);//序列化
  33.                 //Console.ForegroundColor = ConsoleColor.Green;
  34.                 //Console.WriteLine("测试序列化成功。。。");
  35.                 //Console.WriteLine($"测试序列化结果：\r\n{s}");
  36.  
  37.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化.txt");//序列化
  38.                 //SerializeManager.Instance.XmlSerialize<TestClass>(testClass, path);
  39.  
  40.                 //备用
  41.                 //string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
  42.                 //TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
  43.                 //if (test != null)
  44.                 //{
  45.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  46.                 //}
  47.  
  48.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化.txt");
  49.                 //TestClass test = SerializeManager.Instance.XmlDeserialize<TestClass>(path);//反序列化
  50.                 //if (test != null)
  51.                 //{
  52.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  53.                 //}
  54.                 #endregion
  55.  
  56.                 TestClass1 testClass1 = new TestClass1 { Id = , Name = "张三11111", Age = , Address = "12123上海浦东新区2弄5汤1111", Sex = "男" };
  57.                 #region BinarySerialize 必须添可序列化属性，即要序列化的对象必须添加SerializableAttribute属性，[Serializable]
  58.                 //string s = SerializeManager.Instance.BinarySerialize<TestClass1>(testClass1);//序列化
  59.                 //Console.ForegroundColor = ConsoleColor.Green;
  60.                 //Console.WriteLine("测试序列化成功。。。");
  61.                 //Console.WriteLine($"测试序列化结果：\r\n{s}");
  62.  
  63.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化11111.txt");//序列化
  64.                 //SerializeManager.Instance.BinarySerialize<TestClass1>(testClass1, path);
  65.  
  66.                 //备用
  67.                 //string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
  68.                 //TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
  69.                 //if (test != null)
  70.                 //{
  71.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  72.                 //}
  73.  
  74.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化11111.txt");
  75.                 //TestClass1 test = SerializeManager.Instance.BinaryDeserialize<TestClass1>(path);//反序列化
  76.                 //if (test != null)
  77.                 //{
  78.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  79.                 //}
  80.                 #endregion
  81.  
  82.                 #region SoapSerialize 必须添可序列化属性，即要序列化的对象必须添加SerializableAttribute属性，[Serializable]
  83.                 //string s = SerializeManager.Instance.SoapSerialize<TestClass1>(testClass1);//序列化
  84.                 //Console.ForegroundColor = ConsoleColor.Green;
  85.                 //Console.WriteLine("测试序列化成功。。。");
  86.                 //Console.WriteLine($"测试序列化结果：\r\n{s}");
  87.  
  88.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化2222.txt");//序列化
  89.                 //SerializeManager.Instance.SoapSerialize<TestClass1>(testClass1, path);
  90.  
  91.                 //备用
  92.                 //string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
  93.                 //TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
  94.                 //if (test != null)
  95.                 //{
  96.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  97.                 //}
  98.  
  99.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化2222.txt");
  100.                 //TestClass1 test = SerializeManager.Instance.SoapDeserialize<TestClass1>(path);//反序列化
  101.                 //if (test != null)
  102.                 //{
  103.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  104.                 //}
  105.                 #endregion
  106.  
  107.                 #region JavaScriptSerialize 要序列化的对象可以不添加SerializableAttribute属性，[Serializable]
  108.                 //string s = SerializeManager.Instance.JavaScriptSerialize<TestClass1>(testClass1);//序列化
  109.                 //Console.ForegroundColor = ConsoleColor.Green;
  110.                 //Console.WriteLine("测试序列化成功。。。");
  111.                 //Console.WriteLine($"测试序列化结果：\r\n{s}");
  112.  
  113.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化66666.txt");//序列化
  114.                 //SerializeManager.Instance.JavaScriptSerialize<TestClass1>(testClass1, path);
  115.  
  116.                 //备用
  117.                 //string json = "{\"Address\":\"中国南京\",\"Age\":10,\"Id\":1,\"Name\":\"张三\",\"Sex\":\"男\"}";
  118.                 //TestClass test = SerializeManager.Instance.DataContractJsonDeserializeJson<TestClass>(json);//反序列化
  119.                 //if (test != null)
  120.                 //{
  121.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  122.                 //}
  123.  
  124.                 //string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "序列化66666.txt");
  125.                 //TestClass1 test = SerializeManager.Instance.JavaScriptDeserialize<TestClass1>(path);//反序列化
  126.                 //if (test != null)
  127.                 //{
  128.                 //    Console.WriteLine($"测试序列化结果：{test.ToString()}");
  129.                 //}
  130.                 #endregion
  131.  
  132.                 Console.WriteLine("测试序列化成功。。。");
  133.             }
  134.             catch (Exception ex)
  135.             {
  136.                 Log.Error($"测试序列化出错，原因：{ex.ToString()}");
  137.                 throw;
  138.             }
  139.  
  140.             #endregion
  141.  
  142.             Console.ReadLine();
  143.         }

使用的类TestClass和TestClass1，类TestClass和TestClass1主要是区分是否添加可序列化属性标记，TestClass主要是测试XmlSerializer（xml序列化）和DatacontractJsonSerializer（json序列化），可以不添加可序列化标记 [Serializable]，TestClass1主要是测试Binary和Soap JavaScript序列化，但Binary和Soap JavaScript序列化TestClass1时，必须添加TestClass1的可序列化标记 [Serializable]，否则，BinarySerialize，SoapSerialize序列化TestClass1的时候会报，提示未标记可序列化

TestClass类

  1. namespace SupremeConsole
  2. {
  3.     /// <summary>
  4.     ///  测试类，该类必未标记为可序列化，DataContractJsonSerialize，XmlSerialize可以正常序列化
  5.     /// </summary>
  6.     public class TestClass
  7.     {
  8.         /// <summary>
  9.         /// 编号
  10.         /// </summary>
  11.         public int Id { get; set; }
  12.  
  13.         /// <summary>
  14.         /// 姓名
  15.         /// </summary>
  16.         public string Name { get; set; }
  17.  
  18.         /// <summary>
  19.         /// 年龄
  20.         /// </summary>
  21.         public int Age { get; set; }
  22.  
  23.         /// <summary>
  24.         /// 地址
  25.         /// </summary>
  26.         public string Address { get; set; }
  27.  
  28.         /// <summary>
  29.         /// 性别
  30.         /// </summary>
  31.         public string Sex { get; set; }
  32.  
  33.         public override string ToString()
  34.         {
  35.             //return string.Format("编号:{0},姓名:{1},年龄:{2},地址:{3},性别:{4}", Id, Name, Age, Address, Sex);
  36.             return $"编号:{Id},姓名:{Name},年龄:{Age},地址:{Address},性别:{Sex}";
  37.         }
  38.     }
  39. }

TestClass1类

  1. using System;
  2. using System.Runtime.Serialization;
  3.  
  4. namespace SupremeConsole
  5. {
  6.     /// <summary>
  7.     /// 测试类1，该类必须标记可序列化，否则，BinarySerialize，SoapSerialize序列化的时候会报，未标记可序列化
  8.     /// </summary>
  9.     [Serializable]
  10.     [DataContract]
  11.     public class TestClass1
  12.     {
  13.         /// <summary>
  14.         /// 编号
  15.         /// </summary>
  16.  
  17.         public int Id { get; set; }
  18.  
  19.         /// <summary>
  20.         /// 姓名
  21.         /// </summary>
  22.         public string Name { get; set; }
  23.  
  24.         /// <summary>
  25.         /// 年龄
  26.         /// </summary>
  27.         public int Age { get; set; }
  28.  
  29.         /// <summary>
  30.         /// 地址
  31.         /// </summary>
  32.         public string Address { get; set; }
  33.  
  34.         /// <summary>
  35.         /// 性别
  36.         /// </summary>
  37.         public string Sex { get; set; }
  38.  
  39.         public override string ToString()
  40.         {
  41.             //return string.Format("编号:{0},姓名:{1},年龄:{2},地址:{3},性别:{4}", Id, Name, Age, Address, Sex);
  42.             return $"编号:{Id},姓名:{Name},年龄:{Age},地址:{Address},性别:{Sex}";
  43.         }
  44.     }
  45. }

C# 序列化与反序列化Serialization之Json Xml Binary Soap JavaScript序列化的更多相关文章

  1. C# 序列化与反序列化之DataContract与xml对子类进行序列化的解决方案

    C# 序列化与反序列化之DataContract与xml对子类进行序列化的解决方案 1.DataContract继承对子类进行序列化的解决方案 第一种是在 [DataContract, KnownTy ...

  2. Json序列化与反序列化(对象与Json字符串的转换)--C#

    public class JsonHelper { #region Json序列化与反序列化 /// <summary> /// 将json转化为对象 /// (需要提前构造好结构一致的M ...

  3. C# dynamic类型序列化和反序列化之Newtonsoft.Json

    原文:C# dynamic类型序列化和反序列化之Newtonsoft.Json 版权声明:本文为博主原创文章,未经博主允许不得转载. https://blog.csdn.net/u011127019/ ...

  4. 序列化与反序列化 - BinaryFormatter二进制(.dat)、SoapFormatter(.soap)、XmlSerializer(.xml)

    序列化的作用是什么?为什么要序列化? 1.在进程下次启动时读取上次保存的对象的信息. 2.在不同的应用程序域或进程之间传递数据. 3.在分布式应用程序中的各应用程序之间传输对象. 所为序列化,就是将对 ...

  5. c# xml序列化和反序列化。也就是xml的解析和反解析。

    用习惯了newTownSoft.json 的json反序列化.碰到xml是真的不习惯. 每次json反序列化都是直接把json丢到bejson网站生成一个实体类,稍微修改修改一点点变量名.然后直接ne ...

  6. ASP.NET JSON的序列化和反序列化 之 Newtonsoft.Json

    我们用到的类库为:Newtonsoft.Json,通过VS工具中NuGet程序包可以下载. 一:对象转json-序列化 public class Student { public int ID { g ...

  7. C# dynamic类型序列化和反序列化之Newtonsoft.Json，动态解析远端返回的jSON数据

    一.说明 1.Newtonsoft.Json 中的Linq To Json中提供了方便的json数据查询.修改等操作. 例如:JObject,JArray 2.在JObject.FromObject( ...

  8. java中的序列化与反序列化，还包括将多个对象序列化到一个文件中

    package Serialize; /** * Created by hu on 2015/11/7. */ //实现序列化必须实现的接口,这就是一个空接口,起到标识的作用 import java. ...

  9. 解决如下json格式的字符串不能使用DataContractJsonSerializer序列化和反序列化 分类： JSON 2015-01-28 14:26 72人阅读 评论(0) 收藏

    可以解决如下json格式的字符串不能使用DataContractJsonSerializer反序列化 {     "ss": "sss",     " ...

随机推荐

  1. Sass和Less的区别？

    这篇文章主要解答以下几个问题,供前端开发者的新手参考. 1.什么是Sass和Less? 2.为什么要使用CSS预处理器? 3.Sass和Less的比较 4.为什么选择使用Sass而不是Less? 什么 ...

  2. Go语言入门——interface

    1.Go如何定义interface Go通过type声明一个接口,形如 type geometry interface { area() float64 perim() float64 } 和声明一个 ...

  3. DMA初识

    功能 DMA可以在CPU不干涉的情况下,进行数据的搬移.例如:通过DMA来获取摄像头输出的像素数据,而占用少量CPU资源. DMAMUX DMAMUX负责数据的路由:将触发源绑定到特定的DMA通道,当 ...

  4. linux如何执行定时任务

    前言:最近在做一个前端监控系统,用到分表分库的功能,由于代码上无法做到实时新建表,所以只能够曲线救国,使用linux系统的定时任务来完成. ============================== ...

  5. 树莓派无显示屏连接wifi

    在烧好Raspbian系统的TF卡boot分区新建 wpa_supplicant.conf 文件,内容如下(修改自己的WIFI名和密码,key_mgmt根据路由器配置),保存后启动树莓派即可自动连接W ...

  6. Codeforces C Match Points（二分贪心）

    题目描述: Match Points time limit per test 2 seconds memory limit per test 256 mega bytes input standard ...

  7. 洛谷P1084 疫情控制（贪心+倍增）

    这个题以前写过一遍,现在再来写,感觉以前感觉特别不好写的细节现在好些多了,还是有进步吧. 这个题的核心思想就是贪心+二分.因为要求最小时间,直接来求问题将会变得十分麻烦,但是如果转换为二分答案来判断可 ...

  8. linux定时任务（转）

    转自:https://www.cnblogs.com/intval/p/5763929.html linux 系统则是由 cron (crond) 这个系统服务来控制的.Linux 系统上面原本就有非 ...

  9. hdu2068-RPG的错排-（dp递推式）

    去年看错排公式,死都看不懂,基础扎实之后再来看就略懂了. 公式: dp[ n ] = ( n-1 ) * ( dp[n-1] + dp[n-2] ) 解析公式:比如有n个元素,各对应n个正确位置,dp ...

  10. 「GXOI / GZOI2019」宝牌一大堆 （DP）

    题意 LOJ传送门 题解 可以发现「七对子」 和 「国士无双」直接暴力就行了. 唯一的就是剩下的"3*4+2". 考试的时候写了个爆搜剪枝,开了O2有50pts.写的时候发现可以D ...