基于Reflect将List泛型数据源转换为Json字符串

在Web开发中，较为常用的数据传递格式为json键值对字符串格式，而在普遍的ORM全映射或半映射技术中，从后端所获得的数据往往是Enumerable或是List<T>类型的数据，因此做了一个通用类，实现将List<T>类型的数据向json格式数据的转换。代码如下：

首先建立一个基于Reflect的基础类Reflect，实现对名称为给定字符串的属性的赋值或取值操作：

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

namespace ReflectionLearning
{
    class Reflect
    {
        private Type _type;
        private object _obj;
        private PropertyInfo _propertyInfo;

        public Reflect(object obj)
        {
            this._obj = obj;
            _type = obj.GetType();            
        }

        /// <summary>
        /// 通过反射，传入属性名，获取属性值
        /// </summary>
        /// <param name="Name"></param>
        /// <returns></returns>
        public object GetValue(string Name)
        {
            _propertyInfo = _type.GetProperty(Name);
            object result = _propertyInfo.GetValue(_obj, null);
            return result;
        }

        /// <summary>
        /// 传入属性名、属性值，完成属性赋值操作
        /// </summary>
        /// <param name="Name"></param>
        /// <param name="value"></param>
        public void SetValue(string Name, object value)
        {
            _propertyInfo = _type.GetProperty(Name);
            _propertyInfo.SetValue(_obj,value, null);
        }
    }
}

 

在通用类中，对Reflect类进行引用，然后通过遍历List<T>中的每个T类的每个属性，进行键值对的转换：

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

namespace ReflectionLearning
{
    class ValueTurning
    {
        private Reflect reflect;
        private string[] parms;
        private DataTable dt;
        private List<Type> ResultList;

        //以数据源Dt，属性列表Parms，原始列表（其中元素已定义但未实例化）outList
        //对此类进行初始化操作
        public ValueTurning(DataTable Dt, string[] Parms, List<Type> outList)
        {
            dt = Dt;
            parms = Parms;
            ResultList = outList;
            beginTurning();
            GetJsonFromList(ResultList);
        }

        /// <summary>
        /// 遍历List中的元素，以Dt中的查询结果对其属性赋值
        /// </summary>
        public void beginTurning()
        {
            object obj;
            //遍历List中的每一个元素
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                //访问当前元素，用以初始化reflect反射类
                obj = ResultList[i];
                reflect = new Reflect(obj);

                //遍历此元素中的每个属性，对其赋值
                for (int j = 0; j < parms.Length; j++)
                {
                    //设置属性
                    reflect.SetValue(parms[j], dt.Rows[i][parms[j]]);
                }

                TmpReset(obj);
            }
        }

        /// <summary>
        /// 以ResultList中的元素为数据源，转化为JSON字符串
        /// </summary>
        /// <returns>Json字符串</returns>
        public string GetJsonFromList(List<Type> ResultList)
        {
            StringBuilder strBuilder = new StringBuilder();
            if (ResultList.Count <= 0)
            {
                return "";
            }
            else
            {
                int num=ResultList.Count;
                int index = 0;
                object obj;
                for (; index < num; index++)
                {
                    obj = ResultList[index];
                    reflect = new Reflect(obj);
                    string parm = parms[index];
                    strBuilder.Append("{");
                    strBuilder.Append(couple(parm, reflect.GetValue(parm).ToString()));
                    strBuilder.Append("}");
                    if (index != num - 1)
                        strBuilder.Append(",");
                    TmpReset(obj);
                }
                return strBuilder.ToString();
            }
        }

        //临时对象初始化
        private void TmpReset(object obj)
        {
            obj = null;
            reflect = null;
        }

        //将键值对转化成 "str1":"str2" 形式
        public string couple(string str1, string str2)
        {
            return ("\"" + str1 + "\":\"" + str2 + "\"");
        }
    }
}