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;
} }
}
}