C#序列化和反序列化综合案例

最新推荐文章于 2021-03-16 13:58:37 发布
最新推荐文章于 2021-03-16 13:58:37 发布
阅读量7.5k 收藏 5
点赞数 2
分类专栏： 【编程语言】 文章标签： C#序列化 C#反序列化 winform序列化 WinForm反序列 c#读取json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u_9_5/article/details/51289761
版权 
大家好，我是网呦，今天分享的内容是：C#序列号和反序列化的实用案例。

大纲

1.贴出主文件的所有代码
2.逐个分析之如何把JSON string 转为DataTable
3.如何把DataTable转为JSON string
4.如何序列化？
5.如何从txt文件中读取JSON格式的数据并反序列化
6.总结以及如何移植到web和其他序列化途径

1.贴出主文件的所有代码

该案例我是用WinForm做的，相信大部分人都是在Web开发中用，这个没关系。首先，给大家贴出源码喽，
https://yunpan.cn/cPMADjQr2M5v2 访问密码 f15d

首先你需要给你的Project引入所需的dll。System.Web和System.Web.Extensions如图
这里写图片描述

好的，下面是我用程序创建的一个JSON 格式的名为”json.txt”的文本。

[{"name":"Jason","id":"20130001","phone":"13579246810"},{"name":"Alias","id":"20130002","phone":"18437965529"},{"name":"Tom","id":"20130003","phone":"15090246296"}]

下面是我的WinForm的UI和识别代码逻辑效果
这里写图片描述
如何你解析的JSON不是多个对象，而是一个，如：

{"name":"Jason","id":"20130001","phone":"13579246810"}

那么执行效果如图：
这里写图片描述

好的，作为辅助，我创建了一个class Person，代码如下：

 public class Person
    {
        private string _name;
        private int _id;
        private string _phone;

        public string Phone
        {
            get { return _phone; }
            set { _phone = value; }
        }

        public int Id
        {
            get { return _id; }
            set { _id = value; }
        }

        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }

        public Person() { }
        public Person(int id, string name, string phone)
        {
            this._id = id;
            this._name = name;
            this._phone = phone;
        }

    }

然后就是主逻辑代码：如下，

/*
 * Author     : 刘壮
 * Edit Date  : 2016/5/1
 * Email      :  
 * Description: 1.Create a txt file with json string.
 *              2.Deserialize JSON string by two ways.
 *              3.You can type a json with object or a json array.
 */
using System;
using System.Windows.Forms;
using System.IO;
using System.Web;
using System.Web.Script.Serialization;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Data;
using System.Collections;

namespace _02_反序列化和反序列化
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private string filename = "json.txt";
        JavaScriptSerializer jss = new JavaScriptSerializer();

        /// <summary>
        /// 创建一个带有json格式的txt
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCreateJson_Click(object sender, EventArgs e)
        {
            //Create a new  document with json string.

            //Judge whether the specified file exists.
            if (!File.Exists(filename))
            {
                //MessageBox.Show("no existence");
                //File.Create(filename);
                //Write a json string into the specified file
                using (StreamWriter sw = new StreamWriter(filename, false, System.Text.Encoding.UTF8))
                {
                    //下面通过一个例子演示了如何从json转为DataTable，再由DataTable转为JSON string.
                    string json = string.Empty;
                    json = "[{\"name\":\"Jason\",\"id\":20130001,\"phone\":\"13579246810\"}," +
                                   "{\"name\":\"Alias\",\"id\":20130002,\"phone\":\"18437965529\"}," +
                                   "{\"name\":\"Tom\",\"id\":20130003,\"phone\":\"15090246296\"}]";

                    DataTable dt = new DataTable();
                    //json = ToJson(new Person(20130001,"Json","12345678901"));
                    dt = JsonToDataTable(json);
                    json = DataTableToJson(dt);
                    sw.Write(json);
                }
                MessageBox.Show("the specified have been created!");
            }
            else
            {
                MessageBox.Show("the file was existing.you can delete it then re click it.");
            }
        }

        /// <summary>
        /// Reading the specified file that contains a json string
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAnalyzeJson_Click(object sender, EventArgs e)
        {
            //Judge whether the specified file exists.
            if (File.Exists(filename))
            {
                //Getting the string that is a specified file
                using (StreamReader sr = new StreamReader(filename, System.Text.Encoding.UTF8))
                {
                    string json = sr.ReadToEnd();
                    //analyze the json string.
                    txtOrgJson.Text = json;


                    //The first method.(For one object)
                    //Person p = jss.Deserialize(json,typeof(Person)) as Person;
                    //txtAnalysedJson.Text = "name="+p.Name+"\r\nid="+p.Id+"\r\nphone="+p.Phone;

                    //The second method.(For a lots objects)
                    List<Person> people = jss.Deserialize<List<Person>>(json);
                    StringBuilder sb = new StringBuilder();
                    PropertyInfo[] piArr = typeof(Person).GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                    if (people.Count == 0)
                    {
                        DeserializeToObject(json);
                        return;
                    }

                    //Get the name and value of the specified class Person automatically.
                    foreach (var person in people)
                    {
                        sb.Clear();
                        foreach (PropertyInfo pi in piArr)
                        {
                            sb.Append(pi.Name + "=" + pi.GetValue(person));
                            sb.Append("\t ");
                        }
                        listAll.Items.Add(sb.ToString());
                        //listAll.Items.Add("name=" + person.Name + "\tid=" + person.Id + "\tphone=" + person.Phone);
                    }
                }
            }
            else
            {
                MessageBox.Show("Cannot find the specified file.Please click the up button of this.");
            }
        }

        /// <summary>
        /// Converts the specified JSON string to a object of type T.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        private T Deserialize<T>(string jsonString)
        {
            JavaScriptSerializer json = new JavaScriptSerializer();
            return json.Deserialize<T>(jsonString);
        }

        private void btnDelFile_Click(object sender, EventArgs e)
        {
            if (File.Exists(filename))
            {
                File.Delete(filename);
                MessageBox.Show("Deleted");
            }
        }

        /// <summary>
        /// Convert JSON string to Object
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnConvert_Click(object sender, EventArgs e)
        {
            string json = txtOrgJson.Text.Trim();
            if (!String.IsNullOrEmpty(json))
            {
                List<Person> lPerson = Deserialize<List<Person>>(json);

                StringBuilder sb = new StringBuilder();
                PropertyInfo[] piArr = typeof(Person).GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                if (lPerson.Count == 0)
                {
                    DeserializeToObject(json);
                    return;
                }

                //Get the name and value of the specified class Person automatically.
                foreach (var person in lPerson)
                {
                    sb.Clear();
                    foreach (PropertyInfo pi in piArr)
                    {
                        sb.Append(pi.Name + "=" + pi.GetValue(person));
                        sb.Append("\t ");
                    }
                    listAll.Items.Add(sb.ToString());
                }

            }
        }

        /// <summary>
        /// Clear the listbox
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnClear_Click(object sender, EventArgs e)
        {
            listAll.Items.Clear();
        }

        private void DeserializeToObject(string data)
        {
            Person p = jss.Deserialize(data, typeof(Person)) as Person;
            txtAnalysedJson.Text = "name=" + p.Name + "\r\nid=" + p.Id + "\r\nphone=" + p.Phone;
        }

        /// <summary>
        /// ConvertS an object to a JSON string 
        /// </summary>
        /// <param name="o">Object</param>
        /// <returns></returns>
        private string ToJson(Object o)
        {
            JavaScriptSerializer j = new JavaScriptSerializer();
            return j.Serialize(o);
        }

        /// <summary>
        ///  ConvertS an object to a JSON string When the string length is long
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        private string ToJson2(Object o)
        {
            JavaScriptSerializer j = new JavaScriptSerializer();
            j.MaxJsonLength = Int32.MaxValue;
            return j.Serialize(o);
        }

        /// <summary>
        /// Converts datatable to JSON string.
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        private string DataTableToJson(DataTable dt)
        {
            JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
            javaScriptSerializer.MaxJsonLength = Int32.MaxValue; //取得最大数值
            ArrayList arrayList = new ArrayList();
            foreach (DataRow dataRow in dt.Rows)
            {
                Dictionary<string, object> dictionary = new Dictionary<string, object>(); //实例化一个参数集合
                foreach (DataColumn dataColumn in dt.Columns)
                {
                    dictionary.Add(dataColumn.ColumnName, dataRow[dataColumn.ColumnName].ToString());
                }
                arrayList.Add(dictionary); //ArrayList集合中添加键值
            }

            return javaScriptSerializer.Serialize(arrayList); //返回一个json字符串
        }



        /// <summary>
        /// Json 字符串 转换为 DataTable数据集合
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public  DataTable JsonToDataTable(string json)
        {
            DataTable dataTable = new DataTable(); //实例化
            DataTable result;
            try
            {
                JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
                javaScriptSerializer.MaxJsonLength = Int32.MaxValue; //取得最大数值
                ArrayList arrayList = javaScriptSerializer.Deserialize<ArrayList>(json);
                if (arrayList.Count > 0)
                {
                    foreach (Dictionary<string, object> dictionary in arrayList)
                    {
                        if (dictionary.Keys.Count == 0)
                        {
                            result = dataTable;
                            return result;
                        }
                        if (dataTable.Columns.Count == 0)
                        {
                            foreach (string current in dictionary.Keys)
                            {
                                dataTable.Columns.Add(current, dictionary[current].GetType());
                            }
                        }
                        DataRow dataRow = dataTable.NewRow();
                        foreach (string current in dictionary.Keys)
                        {
                            dataRow[current] = dictionary[current];
                        }

                        dataTable.Rows.Add(dataRow); //循环添加行到DataTable中
                    }
                }
            }
            catch
            {
            }
            result = dataTable;
            return result;
        }
    }
}

上面用到了很多方法，都是很重要很重要很重要的，重要是事情要说三遍！！！由于使用的WinForm开发的，所以上面的代码中会含有部分控件的Name。
下面我将会分开部分讲一下该案例的核心方法

2.逐个分析之如何把JSON string 转为DataTable

1.首先创建一个JsonToDataTable的通用方法

 /// <summary>
        /// Json 字符串 转换为 DataTable数据集合
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public  DataTable JsonToDataTable(string json)
        {
            DataTable dataTable = new DataTable(); //实例化
            DataTable result;
            try
            {
                JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
                javaScriptSerializer.MaxJsonLength = Int32.MaxValue; //取得最大数值
                ArrayList arrayList = javaScriptSerializer.Deserialize<ArrayList>(json);
                if (arrayList.Count > 0)
                {
                    foreach (Dictionary<string, object> dictionary in arrayList)
                    {
                        if (dictionary.Keys.Count == 0)
                        {
                            result = dataTable;
                            return result;
                        }
                        if (dataTable.Columns.Count == 0)
                        {
                            foreach (string current in dictionary.Keys)
                            {
                                dataTable.Columns.Add(current, dictionary[current].GetType());
                            }
                        }
                        DataRow dataRow = dataTable.NewRow();
                        foreach (string current in dictionary.Keys)
                        {
                            dataRow[current] = dictionary[current];
                        }

                        dataTable.Rows.Add(dataRow); //循环添加行到DataTable中
                    }
                }
            }
            catch
            {
            }
            result = dataTable;
            return result;
        }

2.新建一个json字符串并赋值。然后调用上面的方法就可以转为DataTable了。

string json = string.Empty;
                    json = "[{\"name\":\"Jason\",\"id\":20130001,\"phone\":\"13579246810\"}," +
                                   "{\"name\":\"Alias\",\"id\":20130002,\"phone\":\"18437965529\"}," +
                                   "{\"name\":\"Tom\",\"id\":20130003,\"phone\":\"15090246296\"}]";
   DataTable dt = JsonToDataTable(json);

3.如何把DataTable转为JSON string

1.新建一个DataTableToJson的方法

/// <summary>
        /// Converts datatable to JSON string.
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        private string DataTableToJson(DataTable dt)
        {
            JavaScriptSerializer javaScriptSerializer = new JavaScriptSerializer();
            javaScriptSerializer.MaxJsonLength = Int32.MaxValue; //取得最大数值
            ArrayList arrayList = new ArrayList();
            foreach (DataRow dataRow in dt.Rows)
            {
                Dictionary<string, object> dictionary = new Dictionary<string, object>(); //实例化一个参数集合
                foreach (DataColumn dataColumn in dt.Columns)
                {
                    dictionary.Add(dataColumn.ColumnName, dataRow[dataColumn.ColumnName].ToString());
                }
                arrayList.Add(dictionary); //ArrayList集合中添加键值
            }

            return javaScriptSerializer.Serialize(arrayList); //返回一个json字符串
        }

2.调用方法，传入一个DataTable就可以。哪个DataTable都可以的。

string json = DataTableToJson(dt);

4.如何序列化？

1.创建一个方法

        /// <summary>
        ///  ConvertS an object to a JSON string When the string length is long
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        private string ToJson2(Object o)
        {
            JavaScriptSerializer j = new JavaScriptSerializer();
            j.MaxJsonLength = Int32.MaxValue;
            return j.Serialize(o);
        }

2.就这样传入一个对象就行了。
比如：Person p = new Person();string json = ToJson2(p);
上面在DataTable中也用到过序列化的Demo，可以参考用到大量数据时进行转JSON

5.如何从txt文件中读取JSON格式的数据并反序列化

简述下流程：
1.判断txt的存在
2.读取txt的内容
3.通过下面的代码把JSON对象存入一个泛型中

List<Person> people = jss.Deserialize<List<Person>>(json);

4.通过映射，自动获取到JSON对应类(Class)的属性名，实现自动化并通过遍历输出

PropertyInfo[] piArr = typeof(Person).GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                    if (people.Count == 0)
                    {
                        DeserializeToObject(json);
                        return;
                    }

                    //Get the name and value of the specified class Person automatically.
                    foreach (var person in people)
                    {
                        sb.Clear();
                        foreach (PropertyInfo pi in piArr)
                        {
                            sb.Append(pi.Name + "=" + pi.GetValue(person));
                            sb.Append("\t ");
                        }
                        listAll.Items.Add(sb.ToString());
                        //listAll.Items.Add("name=" + person.Name + "\tid=" + person.Id + "\tphone=" + person.Phone);
                    }

下面是用到的方法

        /// <summary>
        /// Reading the specified file that contains a json string
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAnalyzeJson_Click(object sender, EventArgs e)
        {
            //Judge whether the specified file exists.
            if (File.Exists(filename))
            {
                //Getting the string that is a specified file
                using (StreamReader sr = new StreamReader(filename, System.Text.Encoding.UTF8))
                {
                    string json = sr.ReadToEnd();
                    //analyze the json string.
                    txtOrgJson.Text = json;


                    //The first method.(For one object)
                    //Person p = jss.Deserialize(json,typeof(Person)) as Person;
                    //txtAnalysedJson.Text = "name="+p.Name+"\r\nid="+p.Id+"\r\nphone="+p.Phone;

                    //The second method.(For a lots objects)
                    List<Person> people = jss.Deserialize<List<Person>>(json);
                    StringBuilder sb = new StringBuilder();
                    PropertyInfo[] piArr = typeof(Person).GetProperties(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                    if (people.Count == 0)
                    {
                        DeserializeToObject(json);
                        return;
                    }

                    //Get the name and value of the specified class Person automatically.
                    foreach (var person in people)
                    {
                        sb.Clear();
                        foreach (PropertyInfo pi in piArr)
                        {
                            sb.Append(pi.Name + "=" + pi.GetValue(person));
                            sb.Append("\t ");
                        }
                        listAll.Items.Add(sb.ToString());
                        //listAll.Items.Add("name=" + person.Name + "\tid=" + person.Id + "\tphone=" + person.Phone);
                    }
                }
            }
            else
            {
                MessageBox.Show("Cannot find the specified file.Please click the up button of this.");
            }
        }

6.总结以及如何移植到web和其他序列化途径

先写这么多，你有什么疑问也可以留言交流一下，该案例仅供参考，不代表标准案例。另外，由于这里用的是WinForm开发，你在Web里通过POST方法传入json数据时，可能需要通过下面的方法获取到json string

StreamReader reader = new StreamReader(context.Request.InputStream);
        //比如得到json字符串：strJson={"key3":"xdp-gacl","key4":"白皇"}
        String strJson = HttpUtility.UrlDecode(reader.ReadToEnd());

然后下面就是按上面的案例中的方法进行优化，调整。
另外呢，如果是传入的JSON string是一个，那么可以通过键值对的方式来读取：

    /// <summary>
    /// 获取参数
    /// </summary>
    /// <param name="context"></param>
    /// <returns></returns>
    private System.Collections.Generic.Dictionary<String, Object> GetParameter(HttpContext context)
    {
        StreamReader reader = new StreamReader(context.Request.InputStream);
        //得到json字符串：strJson={"key3":"xdp-gacl","key4":"白虎神皇"}
        String strJson = HttpUtility.UrlDecode(reader.ReadToEnd());
        System.Web.Script.Serialization.JavaScriptSerializer jss = new System.Web.Script.Serialization.JavaScriptSerializer();
        //将json字符串反序列化成一个Dictionary对象
        System.Collections.Generic.Dictionary<String, Object> dicParameter = jss.Deserialize<System.Collections.Generic.Dictionary<String, Object>>(strJson);
        return dicParameter;
    }

调用方式

Dictionary<String, Object> dicParameter = GetParameter(context);
string key3 = dicParameter["keyword"].ToString();

另外呢，除了上面的序列化之外，还可以用下面的方法：

public static string ToJsJson(object item)
    {
        DataContractJsonSerializer serializer = new DataContractJsonSerializer(item.GetType());
        using (MemoryStream ms = new MemoryStream())
        {
            serializer.WriteObject(ms, item);
            StringBuilder sb = new StringBuilder("");
            sb.Append(Encoding.UTF8.GetString(ms.ToArray()));
            return sb.ToString();
        }
    }

需要你引用：using System.Runtime.Serialization.Json;

好，暂时就分享到这里。谢谢！

文刀木由
关注
专栏目录
C# Winform序列化和反序列化
qq_27474555的博客
08-07 311
在NET Framework 4.7.2中不能用Newtonsoft.Json进行序列化和反序列化，为解决此问题，采用System.Text.Json进行序列化，注意要添加System.Memory的引用。反序列化后不相等的原因在于对象类型比较的不完善。
C# 序列化与反序列化
04-15
C# XmlSerializer 分别为对ArrayList的以及对类的实例化对象的序列化与反序列化
C# 序列化（Serialize）与反序列化（Deserialize）
weixin_33874713的博客
06-12 71
序列化又称串行化，是.NET运行时环境用来支持用户定义类型的流化的机制。其目的是以某种存储形成使自定义对象持久化，或者将这种对象从一个地方传输到另一个地方。 .NET框架提供了两种种串行化的方式：1、是使用BinaryFormatter进行串行化；2、使用XmlSerializer进行串行化。第一种方式提供了一个简单的二进制数据流以及某些附加的类型信息，而第二种将数据流格式化为XML存储...
C#序列化和反序列化
qq_42832272的博客
03-16 969
序列化就是是将对象转换为容易传输的格式的过程，一般情况下转化打流文件，放入内存或者IO文件 中。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象，或者和其它应用程序共享使用。反之，反序列化根据流重新构造对象。 一、序列化的方式 1）二进制序列化：是一种将数据写到输出流，以使它能够用来自动重构成相应对象的机制。二进制，其名字就暗示它的必要信息是保存在存储介质上，而这些必要信息要求创建一个对象的精确的二进制副本。在二进制（流）序列化中，整个对象的状态都被保存起
C#序列化与反序列化
pan_junbiao的博客
01-03 911
1、序列化与反序列化 序列化：序列化是将对象的状态存储到特定存储介质的过程，也可以说是将对象状态转换为可保持或传输的格式的过程。 反序列化：反序列化则是从特定存储介质中将数据重新构建对象的过程。通过反序列化，可以将存储在文件上的对象信息读取，然后重新构建为对象。 2、案例说明 对于一个Windows应用程序来说，配置文件是非常重要的。本案例将使用序列化与反序列化、实现保存与加载用户
C#序列化和反序列化案例.rar
11-19
在这个“C#序列化和反序列化案例”中，我们可以通过提供的代码示例深入理解这两个概念。 首先，序列化是将对象的状态转换为可以存储或传输的数据格式的过程。在C#中，我们可以使用内置的System.Runtime....
C#序列化（二）二进制序列化的案例 c#经典案例.pdf
05-07
总结起来，这个案例展示了C#中如何使用二进制序列化来持久化对象状态，以及如何在程序启动时加载和显示这些数据。二进制序列化的优势在于其效率高、占用空间小，但缺点是序列化的数据对人类不友好，不易阅读，且不同...
C#对象三种形式的序列化和反序列化
08-20
在C#编程中，序列化和反序列化是将对象的状态转换为可存储或传输的形式，然后恢复为原始对象的过程。这在数据持久化、网络通信以及跨应用程序域共享数据时非常有用。本主题将详细探讨C#中的三种序列化方式：二进制...
C# 序列化和反序列化
喵毛的博客
08-06 192
序列化： 将对象转化为二进制 反序列化： 将二进制转化为对象 作用： 传输数据，计算机是以二进制的形式传输数据。 模拟两台电脑的数据【传送】和【接收】 传送： 将类标记为可被序列化 [Serializable] //将类标记为可被序列化 class Person { private string _name; private int _age;...
C#--序列化和反序列化
qq826364410的专栏
05-15 473
序列化是指将对象转换成字节流，从而存储对象或将对象传输到内存、数据库或文件的过程。 它的主要用途是保存对象的状态，以便能够在需要时重新创建对象。 反向过程称为“反序列化”。序列化的工作原理下图展示了序列化的整个过程。对象序列化若要序列化对象，需要具有要序列化的对象、包含已序列化对象的一个流，以及一个 Formatter。将 SerializableAttribute 特性应用于某个类型，以指示此类...
理解JSON序列化与反序列化：案例解析
"这篇文档详细介绍了JSON序列化与反序列化的过程，提供了具体的案例和代码示例，适合各个技术水平的Web开发人员学习。" 在Web开发中，JSON（JavaScript Object Notation）是一种广泛用于数据交换的轻量级格式。它以...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值