Newtonsoft.Json动态过滤属性

Newtonsoft.Json动态过滤属性

接口写的多了，会发现很多的问题。同一个dto，不同的action返回的字段个数不一样。往往开发人员因为懒或者各种原因一股脑的全返回，会浪费很多流量且用户体验很差。

当然也会有负责一些的，根据不同的action定义不同的output类。毫无疑问这很麻烦，浪费开发时间。博主本人也是深受其扰，之前看到一篇博文 Newtonsoft.Json高级用法 里面有说到动态决定是属性是否序列化。深得我心于是上手试了一下。博文里的代码很不完善

本人的项目返回类型均为 OutputModel(Status、Message、Data（数据）)。把output丢给json序列化的时候，拿到的只有属性只有Status、Message、Data。而我们要针对的是Data类型的属性。本人进行改造后。由于过滤的属性清单与OutPutModel的又不一致（因为我们要序列化的是output，我们传入的是data里的属性)，无法进行序列化，后面又实验了一下效率如何。如下图，5w次循环竟然与之前差了71倍之多。于是博主准备自己动手去写一个

自己动手

动手之前应该思考一下，我们需要的是什么效果。

• 根据传入数组动态决定哪些属性需要初始化
• 针对OutPutModel的处理
• 效率的高效，至少要直接序列化的差距不会太大

我想要用法是在序列化的时候传入一个字符串数组（也就是需要序列化属性），这里对思路进行梳理一下

return Json(output,new []{"Name","Age"})

• 使用反射，拿到output.Data的Type
• 使用type创建一个实例，循环type的GetProperties。判断property是否在传入的字符串数组中
• 使用property.GetValue获取到属性值，然后再SetValue到创建的实例中
• 把实例赋值给output.Data

很简单，就是对output的data进行一次替换，下面代码很完美的可以解决问题。

private static void Filtered(OutputModel output, string[] param)
 {
        Type type = null;
        if (param == null || param.Length <= 0)
        {
              return;
        }
        type = null;

        if (output.Data == null) return;
        type = output.Data.GetType();
        object result = Activator.CreateInstance(type);
        foreach (var property in type.GetProperties())
       {
           if (!((IList)param).Contains(property.Name)) continue;
           object value = property.GetValue(output.Data, null);
          property.SetValue(result, value);
       }
        output.Data = result;
   }

细心的同学可能会发现上面的少了针对List的处理

      Type type = null;
      if (output.Data is IList)
            {
                var dataList = output.Data as IList;
                if (dataList.Count > 0)
                {
                    type = dataList[0].GetType();
                    var result = Activator.CreateInstance(output.Data.GetType()) as IList;

                    foreach (var temp in dataList)
                    {
                        var instance = Activator.CreateInstance(type);
                        foreach (var property in type.GetProperties())
                        {
                            if (!((IList) param).Contains(property.Name)) continue;
                            object value = property.GetValue(temp, null);
                            property.SetValue(instance, value);
                        }
                        result.Add(instance);
                    }
                    output.Data = result;
                }
            }

上面的一些代码运行起来效率比原生5000次只低不50-100ms，完全可以接受。但是会发现序列化后我们不想要被序列化的属性值变成了null。研究了一下问题出在

var instance = Activator.CreateInstance(type);  这里，因为我们创建的还是那个类嘛。。属性也无法被砍掉。想了想这里可以用动态类型去实现。

                type = obj.GetType();
                var result = new ExpandoObject() as IDictionary<string, Object>;
                foreach (var property in type.GetProperties())
                {
                    if (retain)
                    {
                        if (!((IList)props).Contains(property.Name.ToLower())) continue;
                    }
                    else
                    {
                        if (((IList)props).Contains(property.Name.ToLower())) continue;
                    }
                    object value = property.GetValue(obj, null);
                    result.Add(property.Name, value);

                }
                obj = result;

实验了一下对效果非常满意，另外一个有意思的事情是效率竟然比原生要快上一倍

这张图直接进行序列化

这张图是用过滤了属性

下面除上完整的代码，有需要的同学可以进行使用

using System;
using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using Tool.Response;

namespace MvcCustommade
{
    public class LimitPropsContractResolver
    {

        private static object Filtered(object obj, string[] props, bool retain)
        {

            if (obj == null)
                return null;
            Type type = null;
            if (obj is IList)
            {
                var dataList = obj as IList;
                if (dataList.Count > 0)
                {
                    type = dataList[0].GetType();
                    List<IDictionary<string, object>> result = new List<IDictionary<string, object>>();

                    foreach (var temp in dataList)
                    {
                        var instance = new ExpandoObject() as IDictionary<string, Object>;
                        foreach (var property in type.GetProperties())
                        {
                            if (retain)
                            {
                                if (!((IList)props).Contains(property.Name.ToLower())) continue;
                            }
                            else
                            {
                                if (((IList)props).Contains(property.Name)) continue;
                            }

                            object value = property.GetValue(temp, null);
                            instance.Add(property.Name, value);
                        }
                        result.Add(instance);
                    }
                    obj = result;
                }
            }
            else
            {

                type = obj.GetType();
                var result = new ExpandoObject() as IDictionary<string, Object>;
                foreach (var property in type.GetProperties())
                {
                    if (retain)
                    {
                        if (!((IList)props).Contains(property.Name.ToLower())) continue;
                    }
                    else
                    {
                        if (((IList)props).Contains(property.Name.ToLower())) continue;
                    }
                    object value = property.GetValue(obj, null);
                    result.Add(property.Name, value);

                }
                obj = result;
            }

            return obj;
        }

        /// <summary>
        /// 过滤无用的属性
        /// </summary>
        /// <param name="output">返回的数据</param>
        /// <param name="props">过滤的属性数组</param>
        /// <param name="retain">过滤的数组是包含还是不包含</param>
        public static object CreateProperties(object output, string[] props, bool retain)
        {
            if (props == null || props.Length <= 0)
            {
                return output;
            }
            if (output == null)
            {
                return null;
            }
            for (int i = 0; i < props.Length; i++)
            {
                props[i] = props[i].ToLower();
            }
            if (output is OutputModel)
            {
                var outputModel = output as OutputModel;
                if (outputModel.Data == null)
                {
                    return outputModel;
                }
                outputModel.Data = Filtered(outputModel.Data, props, retain);
                return outputModel;

                #region 初始版

                //Type type = null;

                //if (outputModle.Data is IList)
                //{
                //    var ss = outputModle.Data as IList;
                //    if (ss.Count > 0)
                //    {
                //        type = ss[0].GetType();
                //        List<IDictionary<string, object>> result = new List<IDictionary<string, object>>();

                //        foreach (var temp in ss)
                //        {
                //            var instance = new ExpandoObject() as IDictionary<string, Object>;
                //            foreach (var property in type.GetProperties())
                //            {
                //                if (retain)
                //                {
                //                    if (!((IList)props).Contains(property.Name)) continue;
                //                }
                //                else
                //                {
                //                    if (((IList)props).Contains(property.Name)) continue;
                //                }

                //                object value = property.GetValue(temp, null);
                //                instance.Add(property.Name, value);
                //            }
                //            result.Add(instance);
                //        }
                //        outputModle.Data = result;
                //    }
                //}
                //else
                //{
                //    if (outputModle.Data == null) return;
                //    type = outputModle.Data.GetType();
                //    var result = new ExpandoObject() as IDictionary<string, Object>;
                //    foreach (var property in type.GetProperties())
                //    {
                //        if (retain)
                //        {
                //            if (!((IList)props).Contains(property.Name)) continue;
                //        }
                //        else
                //        {
                //            if (((IList)props).Contains(property.Name)) continue;
                //        }
                //        object value = property.GetValue(outputModle.Data, null);
                //        result.Add(property.Name, value);

                //    }
                //    outputModle.Data = result;
                //} 

                #endregion
            }
            else
            {
                output = Filtered(output, props, retain);
                return output;
            }

        }
    }
}