ORM映射框架总结终极JSON

1. 简单介绍一下JSON

　　JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript的一个子集。 JSON采用完全独立于语言的文本格式。也正是因为这样，它能够在各种计算机语言中蓬勃发展。

　　JSON 的结构：

　　1. “名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。

　　2. 值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。

　　

2.C# 实体对象转化为JSON

  1 /**
  2  * 
  3  * 2009-5-26
  4  * 
  5  * 
  6  * 将某个对象转化为Json数据格式
  7  * */
  8 using System;
  9 using System.Collections.Generic;
 10 using System.Linq;
 11 using System.Text;
 12 using System.IO;
 13 using System.Data;
 14 using System.ServiceModel.Web;
 15 using System.Runtime.Serialization;
 16 using System.Runtime.Serialization.Json;
 17 
 18 namespace CommonData.Json
 19 {
 20     public class ObjectSerialization
 21     {
 22         private object _entity;
 23 
 24         /// <summary>
 25         /// 被序列化得实体对象
 26         /// </summary>
 27         public object Entity
 28         {
 29             get { return _entity; }
 30             set { _entity = value; }
 31         }
 32 
 33         private string _jsonData;
 34 
 35         /// <summary>
 36         /// 被转化为json格式数据的对象
 37         /// </summary>
 38         public string JsonData
 39         {
 40             get { return _jsonData; }
 41             set { _jsonData = value; }
 42         }
 43 
 44         /// <summary>
 45         /// 无参数构造方法
 46         /// </summary>
 47         public ObjectSerialization()
 48         { 
 49         }
 50 
 51         /// <summary>
 52         /// 有参数构造方法
 53         /// </summary>
 54         /// <param name="entity">要被序列化得实体对象</param>
 55         public ObjectSerialization(object entity)
 56         {
 57             this._entity = entity;
 58         }
 59 
 60 
 61         /// <summary>
 62         /// 序列化实体对象
 63         /// </summary>
 64         /// <returns></returns>
 65         public string EntityToJson()
 66         {
 67             var serializer = new DataContractJsonSerializer(Entity.GetType());
 68             MemoryStream ms = new MemoryStream();
 69             serializer.WriteObject(ms, Entity);
 70             byte[] myByte = new byte[ms.Length];
 71             ms.Position = 0;
 72             ms.Read(myByte, 0, (int)ms.Length);
 73             string dataString = Encoding.UTF8.GetString(myByte);
 74             return dataString;
 75         }
 76 
 77 
 78         /// <summary>
 79         /// 序列化实体对象
 80         /// </summary>
 81         /// <param name="entity">要被序列化得实体对象</param>
 82         /// <returns></returns>
 83         public string EntityToJson(object entity)
 84         {
 85             this._entity = entity;
 86             return EntityToJson();
 87         }
 88 
 89         /// <summary>
 90         /// 将Json格式数据转换为对象
 91         /// </summary>
 92         /// <returns></returns>
 93         public T GetObjectJson<T>()
 94         {
 95             MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(JsonData));
 96             var serializer = new DataContractJsonSerializer(typeof(T));
 97             T t = (T)serializer.ReadObject(ms);
 98             return t;
 99         }
100 
101         /// <summary>
102         /// 将Json格式数据转换为对象
103         /// </summary>
104         /// <param name="jsonData">json数据格式</param>
105         /// <returns></returns>
106         public T GetObjectJson<T>(string jsonData)
107         {
108             this._jsonData = jsonData;
109             return GetObjectJson<T>();
110         }
111     }
112 }
113 

　　这个类提供了一个实体对象序列化和反序列化得操作。

　　序列化操作

　　public string EntityToJson()
        {
            var serializer = new DataContractJsonSerializer(Entity.GetType());
            MemoryStream ms = new MemoryStream();
            serializer.WriteObject(ms, Entity);
            byte[] myByte = new byte[ms.Length];
            ms.Position = 0;
            ms.Read(myByte, 0, (int)ms.Length);
            string dataString = Encoding.UTF8.GetString(myByte);
            return dataString;
        }

　　　这个方法用到了DataContractJsonSerializer 这个类，这个类是WCF中的一个序列化类，也就是说在.net 3.0 之前是没有的，这个类提供了比Serializable 更好更方便的序列化。我们呢正好赶上了这个大趋势，方便了，很快能够将实体对象序列化为json格式数据。.net 2.0 中操作都是利用反射然后拼接字符串。

　　 至于反序列也就是上面的相反操作了，但我们的字符串格式和实体对象能够匹配的时候，我们可以将一个字符串重新转化为一个实体对象。

 

(3). DataTable 序列化json

  1 /**
  2  * 
  3  * 2009-5-26
  4  * 
  5  * 
  6  * 将DataTable 转化为Json数据格式
  7  * */
  8 using System;
  9 using System.Collections.Generic;
 10 using System.Linq;
 11 using System.Text;
 12 using System.IO;
 13 using System.Data;
 14 using System.ServiceModel.Web;
 15 using System.Runtime.Serialization;
 16 using System.Runtime.Serialization.Json;
 17 
 18 namespace CommonData.Json
 19 {
 20     public class DataTableJson
 21     {
 22         private DataTable _jsonTable;
 23 
 24         /// <summary>
 25         /// DataTable属性
 26         /// </summary>
 27         public DataTable JsonTable
 28         {
 29             get
 30             {
 31                 return _jsonTable;
 32             }
 33             set
 34             {
 35                 _jsonTable = value;
 36             }
 37         }
 38 
 39         /// <summary>
 40         /// 无参构造方法
 41         /// </summary>
 42         public DataTableJson()
 43         {
 44         }
 45 
 46         /// <summary>
 47         /// 有参构造方法
 48         /// </summary>
 49         /// <param name="table">table对象</param>
 50         public DataTableJson(DataTable table)
 51         {
 52             this._jsonTable = table;
 53         }
 54 
 55         /// <summary>
 56         /// 将DataTable 转化为Json数据格式
 57         /// </summary>
 58         /// <returns></returns>
 59         public string ToJson()
 60         {
 61             StringBuilder JsonString = new StringBuilder();
 62             if (_jsonTable != null && _jsonTable.Rows.Count > 0)
 63             {
 64                 JsonString.Append("{ ");
 65                 JsonString.Append("\"Head\":[ ");
 66                 for (int i = 0; i < _jsonTable.Rows.Count; i++)
 67                 {
 68                     JsonString.Append("{ ");
 69                     for (int j = 0; j < _jsonTable.Columns.Count; j++)
 70                     {
 71                         if (j < _jsonTable.Columns.Count - 1)
 72                         {
 73                             JsonString.Append("\"" + _jsonTable.Columns[j].ColumnName.ToString() + "\":" + "\"" + _jsonTable.Rows[i][j].ToString() + "\",");
 74                         }
 75                         else if (j == _jsonTable.Columns.Count - 1)
 76                         {
 77                             JsonString.Append("\"" + _jsonTable.Columns[j].ColumnName.ToString() + "\":" + "\"" + _jsonTable.Rows[i][j].ToString() + "\"");
 78                         }
 79                     }
 80 
 81                     if (i == _jsonTable.Rows.Count - 1)
 82                     {
 83                         JsonString.Append("} ");
 84                     }
 85                     else
 86                     {
 87                         JsonString.Append("}, ");
 88                     }
 89                 }
 90                 JsonString.Append("]}");
 91                 return JsonString.ToString();
 92             }
 93             else
 94             {
 95                 return null;
 96             }
 97         }
 98 
 99         /// <summary>
100         /// 将DataTable 转化为Json数据格式
101         /// </summary>
102         /// <param name="table">table 对象</param>
103         /// <returns></returns>
104         public string ToJson(DataTable table)
105         {
106             this._jsonTable = table;
107             return ToJson();
108         }
109     }
110 }
111 

　　上面是C# 中的DataTable 序列化为JSON ，虽然名为序列化，其实不是序列化，因为DataTable是不能个序列化的，

所以这里是采用的拼字符串。将表格中的每个属性和每个值都读取出来，拼成JSON 数据格式字符串。