.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代码，点击展开

);
                    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用法代码

\"}";

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