.NET3.5中JSON用法以及封装JsonUtils工具类（二）

    在上一篇随笔.NET3.5中JSON用法以及封装JsonUtils工具类（一）中我们讲到JSON的简单使用，现在我们来研究如何进行封装微软提供的JSON基类，达到更加方便、简单、强大且重用性高的效果。

    首先创建一个类JsonUtils.cs，代码如下：

JsonUtils代码，点击展开

using  System;
using  System.Net;
using  System.Reflection;
using  System.Collections;
using  System.Collections.Generic;
using  System.Windows;
using  System.Windows.Controls;
using  System.Windows.Documents;
using  System.Windows.Ink;
using  System.Windows.Input;
using  System.Windows.Media;
using  System.Windows.Media.Animation;
using  System.Windows.Shapes;
using  System.Json;

namespace  SLCommon
{
     public   class  JsonUtils
    {
         ///   <summary>
         ///  将JSON文本反序列化成List <T> 对象
          ///   </summary>
         ///   <typeparam name="T"> 泛型类，实体类型 </typeparam>
         ///   <param name="jsonString"> JSON文本 </param>
         ///   <returns> 返回List <T> 对象 </returns>
         public   static  List < T >  toList < T > (String jsonString)  where  T :  new ()
        {               
            JsonArray jsonArray  =  JsonArray.Parse(jsonString)  as  JsonArray;
            
             return  toList < T > (jsonArray);
        }

         ///   <summary>
         ///  将JsonArray对象转化成List <T> 对象
          ///   </summary>
         ///   <typeparam name="T"> 泛型类，实体类型 </typeparam>
         ///   <param name="jsonArray"> 传入的参数JsonArray对象 </param>
         ///   <returns> 返回List <T> 对象 </returns>
         public   static  List < T >  toList < T > (JsonArray jsonArray)  where  T :  new ()
        {      
             // 申明泛型List
            List < T >  entityList  =   new  List < T > ();
            
             // 获取泛型类的类型
            Type classType  =   new  T().GetType();
             // 获取泛型类中的属性信息
            PropertyInfo[] propertys  =  

                   classType.GetProperties(BindingFlags.Public  |  BindingFlags.Instance);

            
             foreach  (JsonObject jsonObject  in  jsonArray)
            {
                // 创建泛型对象
                T entity  =   new  T();
                 // 遍历属性数组
                 foreach  (PropertyInfo property  in  propertys)
                {
                    // 得到类中属性的数据类型
                    var type  =  property.PropertyType.FullName;
                     // 通过属性名称prperty.Name在jsonObject中检索到相应的值
                    var val  =  JsonTypeUtils.TypeConvert(jsonObject[property.Name]);
                     // 数据类型转换
                    var value  =  TypeUtils.ConvertType(type, val);
                     // 将属性值赋值给相应的属性
                    property.SetValue(entity, value,  null );
                }
                 // 泛型类对象放入List中
                entityList.Add(entity);
            }
            
             return  entityList;
        }
        
         ///   <summary>
         ///  将JSON文本反序列化成实体类对象
          ///   </summary>
         ///   <typeparam name="T"> 泛型类，实体类型 </typeparam>
         ///   <param name="jsonString"> JSON文本 </param>
         ///   <returns> 返回泛型T类型实体对象 </returns>
         public   static  T toEntity < T > (String jsonString)  where  T :  new ()
        {
            JsonObject jsonObject  =  JsonObject.Parse(jsonString)  as  JsonObject;

             return  toEntity < T > (jsonObject);             
        }

         ///   <summary>
         ///  将JSON对象转化成实体类对象
          ///   </summary>
         ///   <typeparam name="T"> 泛型类，实体类型 </typeparam>
         ///   <param name="jsonObject"> JSON对象 </param>
         ///   <returns> 返回泛型T类型实体对象 </returns>
         public   static  T toEntity < T > (JsonObject jsonObject)  where  T :  new ()
        {
             // 创建泛型对象
            T entity  =   new  T();
             // 获取泛型类的类型
            Type classType  =  entity.GetType();
             // 获取泛型类中的属性信息
            PropertyInfo[] propertys  =  

                classType.GetProperties(BindingFlags.Public  |  BindingFlags.Instance);           

             // 遍历属性数组
             foreach  (PropertyInfo property  in  propertys)
            {
                 // 得到类中属性的数据类型
                var type  =  property.PropertyType.FullName;
                 // 通过属性名称prperty.Name在jsonObject中检索到相应的值
                var val  =  JsonTypeUtils.TypeConvert(jsonObject[property.Name]);
                 // 数据类型转换
                var value  =  TypeUtils.ConvertType(type, val);
                 // 将属性值赋值给相应的属性
                property.SetValue(entity, value,  null );
            }

             return  entity;    
        } 
    }
}

 在上面用到了2个辅助类，因为从JsonObject中取到值后，值的数据类型是JsonValue，并非普通的数据类型，在利用反射为类的属性赋值的时候不能识别JsonValue中的数据类型，不能实现数据类型的隐式转换。但它有自己的数据类型如下：

JsonType枚举：

JsonType.Array

JsonType.Boolean

JsonType.Number

JsonType.Object

JsonType.String

我们先通过JsonTypeUtils类来实现JsonType中的数据类型与基本数据类型之间的转换，代码如下：

JsonTypeUtils代码，点击展开

using  System;
using  System.Net;
using  System.Numeric;
using  System.Linq;
using  System.Windows;
using  System.Windows.Controls;
using  System.Windows.Documents;
using  System.Windows.Ink;
using  System.Windows.Input;
using  System.Windows.Media;
using  System.Windows.Media.Animation;
using  System.Windows.Shapes;
using  System.Json;

namespace  SLCommon
{
     public   class  JsonTypeUtils
    {
         public   static  Object TypeConvert(JsonValue jv)
        {
             if (jv.JsonType  ==  JsonType.Array)
            {
                 return   new  JsonArray(jv);
            }
             if  (jv.JsonType  ==  JsonType.Boolean)
            {
                 return  Boolean.Parse(jv.ToString());
            }
             if  (jv.JsonType  ==  JsonType.Number)
            {
                 return  Double.Parse(jv.ToString());
            }
             if  (jv.JsonType  ==  JsonType.Object)
            {
                 return  (Object)jv;
            }
             if  (jv.JsonType  ==  JsonType.String)
            {
                 return  jv.ToString();
            }
                        
             return  jv;
        }
    }
}

 这时获取到的数据类型只是根据上面5种枚举类型转换的，得到的值并非属性真正的类型，所以需要通过先获取类中属性的数据类型：

var type = property.PropertyType.FullName;

然后通过TypeUtils类的静态方法ConvertType类实现把值转换到属性的类型，代码如下：

TypeUtils代码，点击展开

using  System;
using  System.Net;
using  System.Windows;
using  System.Windows.Controls;
using  System.Windows.Documents;
using  System.Windows.Ink;
using  System.Windows.Input;
using  System.Windows.Media;
using  System.Windows.Media.Animation;
using  System.Windows.Shapes;

namespace  SLCommon
{
     public   class  TypeUtils
    {
         public   static  Object ConvertType(String type,Object value)
        {            
            var val  =   new  Object();
             switch (type)
            {
                 case   " System.String " :                    
                    String s  =  value.ToString();
                     if  (s.StartsWith( " \ "" ) && s.EndsWith( " \ "" ))
                        s  =  s.Substring( 1 , s.Length  -   2 );
                    val  =  s;
                     break ;
                 case   " System.Int16 " :
                 case   " System.Int32 " :                
                 case   " System.Int64 " :                   
                    val  =   int .Parse(value.ToString());
                     break ;
                 case   " System.Double " :                    
                    val  =  Double.Parse(value.ToString());
                     break ;
                 case   " System.Decimal " :                   
                    val  =  Decimal.Parse(value.ToString());
                     break ;                
                 case   " System.Object " :                    
                    val  =  (Object)value;
                     break ;
            }
          
             return  val;
        }
    }
}

 在TypeUtils中还只实现了少数数据类型的转换，还有待完善。

下面介绍JsonUtils的用法，先创建实体类FruitEntity.cs,代码如下：

FruitEntity代码，点击展开

using  System;
using  System.Collections.Generic;
using  System.Linq;
using  System.Text;

namespace  SLEntity
{
     public   class  FruitEntity
    {        
         private  String id;
         private  String name;
         private  Double price;
         private  Double stock;
         private  String date;

         public  String Id
        {
             get  {  return  id; }
             set  { id  =  value; }
        }
        
         public  String Name
        {
             get  {  return  name; }
             set  { name  =  value; }
        }

         public  Double Price
        {
             get  {  return  price; }
             set  { price  =  value; }
        }
        

         public  Double Stock
        {
             get  {  return  stock; }
             set  { stock  =  value; }
        }

         public  String Date
        {
             get  {  return  date; }
             set  { date  =  value; }
        }
    }
}

JsonUtils用法示例代码：

JsonUtils用法代码

// ===================================================================== 
String jsonString  =   " [{\ " id\ " :\ " 0001 \ " ,\ " name\ " :\ " 香蕉\ " ,\ " price\ " :3.30,\ " stock\ " :200,\ " date\ " :\ " 2010 - 05 - 01 \ " },
{\ " id\ " :\ " 0002\ " ,\ " name\ " :\ " 苹果\ " ,\ " price\ " : 3.87 ,\ " stock\ " : 125.8 ,\ " date\ " :\ " 2010-05-02\ " }] " ;

// 将JSON文本转换为List，当jsonStr为数组时转换为List
List < FruitEntity >  list  =  JsonUtils.toList < FruitEntity > (jsonString);                
// =====================================================================
String jsonStr  =   " {\ " id\ " :\ " 0001 \ " ,\ " name\ " :\ " 香蕉\ " ,\ " price\ " :3.30,\ " stock\ " :200,\ " date\ " :\ " 2010 - 05 - 01 \ " } " ;

// 上面JSON文本为一个对象，不是多个对象组成的数组。所以转换为实体类：
FruitEntity entity  =  JsonUtils.toEntity < FruitEntity > (jsonStr);