.net 实体对象生成json对象

转载地址：http://www.cnblogs.com/qingyuan/archive/2010/01/22/JSON.html

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 数据格式字符串。