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

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

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

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中的数据类型与基本数据类型之间的转换，代码如下：

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类实现把值转换到属性的类型，代码如下：

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,代码如下：

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用法示例代码：

//===================================================================== 
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);