我只想要一个对象的第一个深度级别（我不想要任何孩子）。我愿意使用任何可用的库。大多数库只会在达到递归深度时抛出异常，而不是忽略。如果这是不可能的，有没有办法忽略给定数据类型的某些成员的序列化？
编辑：假设我有一个像这样的对象：
class MyObject
{
String name = "Dan";
int age = 88;
List<Children> myChildren = ...(lots of children with lots of grandchildren);
}
我想删除任何孩子（甚至复杂类型）以返回这样的对象：
class MyObject
{
String name = "Dan";
int age = 88;
List<Children> myChildren = null;
}
这在Json.NETJsonWriter中使用和序列化程序之间的一些协调是可能的ContractResolver。
自定义JsonWriter在对象启动时递增计数器，然后在结束时再次递减。
public class CustomJsonTextWriter : JsonTextWriter
{
public CustomJsonTextWriter(TextWriter textWriter) : base(textWriter) {}
public int CurrentDepth { get; private set; }
public override void WriteStartObject()
{
CurrentDepth++;
base.WriteStartObject();
}
public override void WriteEndObject()
{
CurrentDepth--;
base.WriteEndObject();
}
}
自定义对将用于验证当前深度的所有属性ContractResolver应用特殊谓词。ShouldSerialize
public class CustomContractResolver : DefaultContractResolver
{
private readonly Func<bool> _includeProperty;
public CustomContractResolver(Func<bool> includeProperty)
{
_includeProperty = includeProperty;
}
protected override JsonProperty CreateProperty(
MemberInfo member, MemberSerialization memberSerialization)
{
var property = base.CreateProperty(member, memberSerialization);
var shouldSerialize = property.ShouldSerialize;
property.ShouldSerialize = obj => _includeProperty() &&
(shouldSerialize == null ||
shouldSerialize(obj));
return property;
}
}
以下方法显示了这两个自定义类如何协同工作。
public static string SerializeObject(object obj, int maxDepth)
{
using (var strWriter = new StringWriter())
{
using (var jsonWriter = new CustomJsonTextWriter(strWriter))
{
Func<bool> include = () => jsonWriter.CurrentDepth <= maxDepth;
var resolver = new CustomContractResolver(include);
var serializer = new JsonSerializer {ContractResolver = resolver};
serializer.Serialize(jsonWriter, obj);
}
return strWriter.ToString();
}
}
下面的测试代码演示了将最大深度分别限制为 1 级和 2 级。
var obj = new Node {
Name = "one",
Child = new Node {
Name = "two",
Child = new Node {
Name = "three"
}
}
};
var txt1 = SerializeObject(obj, 1);
var txt2 = SerializeObject(obj, 2);
public class Node
{
public string Name { get; set; }
public Node Child { get; set; }
}
首先，我想说所有功劳都应该归功于 Nathan Baulch。这是他的答案与在设置中使用 MaxDepth 相结合的改编。感谢您的帮助内森！
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Web;
using System.Web.Mvc;
namespace Helpers
{
public class JsonNetResult : JsonResult
{
public JsonNetResult()
{
Settings = new JsonSerializerSettings
{
ReferenceLoopHandling = ReferenceLoopHandling.Error
};
}
public JsonSerializerSettings Settings { get; private set; }
public override void ExecuteResult(ControllerContext context)
{
if (context == null)
throw new ArgumentNullException("context");
if (this.JsonRequestBehavior == JsonRequestBehavior.DenyGet && string.Equals(context.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
throw new InvalidOperationException("JSON GET is not allowed");
HttpResponseBase response = context.HttpContext.Response;
response.ContentType = string.IsNullOrEmpty(this.ContentType) ? "application/json" : this.ContentType;
if (this.ContentEncoding != null)
response.ContentEncoding = this.ContentEncoding;
if (this.Data == null)
return;
var scriptSerializer = JsonSerializer.Create(this.Settings);
using (var sw = new StringWriter())
{
if (Settings.MaxDepth != null)
{
using (var jsonWriter = new JsonNetTextWriter(sw))
{
Func<bool> include = () => jsonWriter.CurrentDepth <= Settings.MaxDepth;
var resolver = new JsonNetContractResolver(include);
this.Settings.ContractResolver = resolver;
var serializer = JsonSerializer.Create(this.Settings);
serializer.Serialize(jsonWriter, Data);
}
response.Write(sw.ToString());
}
else
{
scriptSerializer.Serialize(sw, this.Data);
response.Write(sw.ToString());
}
}
}
}
public class JsonNetTextWriter : JsonTextWriter
{
public JsonNetTextWriter(TextWriter textWriter) : base(textWriter) { }
public int CurrentDepth { get; private set; }
public override void WriteStartObject()
{
CurrentDepth++;
base.WriteStartObject();
}
public override void WriteEndObject()
{
CurrentDepth--;
base.WriteEndObject();
}
}
public class JsonNetContractResolver : DefaultContractResolver
{
private readonly Func<bool> _includeProperty;
public JsonNetContractResolver(Func<bool> includeProperty)
{
_includeProperty = includeProperty;
}
protected override JsonProperty CreateProperty(
MemberInfo member, MemberSerialization memberSerialization)
{
var property = base.CreateProperty(member, memberSerialization);
var shouldSerialize = property.ShouldSerialize;
property.ShouldSerialize = obj => _includeProperty() &&
(shouldSerialize == null ||
shouldSerialize(obj));
return property;
}
}
}
采用：
// instantiating JsonNetResult to handle circular reference issue.
var result = new JsonNetResult
{
Data = <<The results to be returned>>,
JsonRequestBehavior = JsonRequestBehavior.AllowGet,
Settings =
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore,
MaxDepth = 1
}
};
return result;
您可以使用反射来检查对象并根据需要制作一个更改每个属性值的副本。巧合的是，我刚刚公开了一个新库，它使这种事情变得非常容易。你可以在这里得到它：https ://github.com/jamietre/IQObjectMapper
这是您将使用的代码示例
var newInstance = ObjectMapper.Map(obj,(value,del) => {
return value !=null && value.GetType().IsClass ?
null :
value;
});
“Map”方法遍历对象的每个属性，并Func<object,IDelegateInfo>为每个属性调用一个（IDelegateInfo 具有反射信息，例如属性名称、类型等）。该函数返回每个属性的新值。所以在这个例子中，我只是测试每个属性的值，看它是否是一个类，如果是，则返回null；如果不是，则返回原始值。
另一种更具表现力的方式：
var obj = new MyObject();
// map the object to a new dictionary
var dict = ObjectMapper.ToDictionary(obj);
// iterate through each item in the dictionary, a key/value pair
// representing each property
foreach (KeyValuePair<string,object> kvp in dict) {
if (kvp.Value!=null && kvp.Value.GetType().IsClass) {
dict[kvp.Key]=null;
}
}
// map back to an instance
var newObject = ObjectMapper.ToNew<MyObject>(dict);
在任何一种情况下，newInstance.myChildren（以及任何其他非值类型的属性）的值都将为空。您可以轻松更改此映射中发生的规则。
希望这可以帮助。顺便说一句-从您的评论看来，JSON 并不是您真正的目标，而只是您认为可以帮助您实现目标的东西。如果你想以 json 结尾，只需序列化它的输出，例如
string json = JavaScriptSerializer.Serialize(newObject);
但如果这只是达到目的的一种手段，我不会涉及 json；如果您想留在 CLR 对象中，则无需使用 JSON 作为中介。
如果你想在 ASP.NET Core 项目中使用它，你可能无法实现自己的 JsonTextWriter。但是您可以自定义 DefaultContractResolver 和 IValueProvider
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
namespace customserialization
{
/// <summary>
/// IValueProvider personalizado para manejar max depth level
/// </summary>
public class CustomDynamicValueProvider : DynamicValueProvider, IValueProvider
{
MemberInfo _memberInfo;
MaxDepthHandler _levelHandler;
public CustomDynamicValueProvider(MemberInfo memberInfo, MaxDepthHandler levelHandler) : base(memberInfo)
{
_memberInfo = memberInfo;
_levelHandler = levelHandler;
}
public new object GetValue(object target)
{
//Si el valor a serializar es un objeto se incrementa el nivel de profundidad. En el caso de las listas el nivel se incrementa en el evento OnSerializing
if (((PropertyInfo)_memberInfo).PropertyType.IsClass) this._levelHandler.IncrementLevel();
var rv = base.GetValue(target);
//Al finalizar la obtención del valor se decrementa. En el caso de las listas el nivel se decrementa en el evento OnSerialized
if (((PropertyInfo)_memberInfo).PropertyType.IsClass) this._levelHandler.DecrementLevel();
return rv;
}
}
/// <summary>
/// Maneja los niveles de serialización
/// </summary>
public class MaxDepthHandler
{
int _maxDepth;
int _currentDepthLevel;
/// <summary>
/// Nivel actual
/// </summary>
public int CurrentDepthLevel { get { return _currentDepthLevel; } }
public MaxDepthHandler(int maxDepth)
{
this._currentDepthLevel = 1;
this._maxDepth = maxDepth;
}
/// <summary>
/// Incrementa el nivel actual
/// </summary>
public void IncrementLevel()
{
this._currentDepthLevel++;
}
/// <summary>
/// Decrementa el nivel actual
/// </summary>
public void DecrementLevel()
{
this._currentDepthLevel--;
}
/// <summary>
/// Determina si se alcanzó el nivel actual
/// </summary>
/// <returns></returns>
public bool IsMaxDepthLevel()
{
return !(this._currentDepthLevel < this._maxDepth);
}
}
public class ShouldSerializeContractResolver : DefaultContractResolver
{
MaxDepthHandler _levelHandler;
public ShouldSerializeContractResolver(int maxDepth)
{
this._levelHandler = new MaxDepthHandler(maxDepth);
}
void OnSerializing(object o, System.Runtime.Serialization.StreamingContext context)
{
//Antes de serializar una lista se incrementa el nivel. En el caso de los objetos el nivel se incrementa en el método GetValue del IValueProvider
if (o.GetType().IsGenericList())
_levelHandler.IncrementLevel();
}
void OnSerialized(object o, System.Runtime.Serialization.StreamingContext context)
{
//Despues de serializar una lista se decrementa el nivel. En el caso de los objetos el nivel se decrementa en el método GetValue del IValueProvider
if (o.GetType().IsGenericList())
_levelHandler.DecrementLevel();
}
protected override JsonContract CreateContract(Type objectType)
{
var contract = base.CreateContract(objectType);
contract.OnSerializingCallbacks.Add(new SerializationCallback(OnSerializing));
contract.OnSerializedCallbacks.Add(new SerializationCallback(OnSerialized));
return contract;
}
protected override IValueProvider CreateMemberValueProvider(MemberInfo member)
{
var rv = base.CreateMemberValueProvider(member);
if (rv is DynamicValueProvider) //DynamicValueProvider es el valueProvider usado en general
{
//Utilizo mi propio ValueProvider, que utilizar el levelHandler
rv = new CustomDynamicValueProvider(member, this._levelHandler);
}
return rv;
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
JsonProperty property = base.CreateProperty(member, memberSerialization);
var isObjectOrList = ((PropertyInfo)member).PropertyType.IsGenericList() || ((PropertyInfo)member).PropertyType.IsClass;
property.ShouldSerialize =
instance =>
{
var shouldSerialize = true;
//Si se alcanzo el nivel maximo y la propiedad (member) actual a serializar es un objeto o lista no se serializa (shouldSerialize = false)
if (_levelHandler.IsMaxDepthLevel() && isObjectOrList)
shouldSerialize = false;
return shouldSerialize;
};
return property;
}
}
public static class Util
{
public static bool IsGenericList(this Type type)
{
foreach (Type @interface in type.GetInterfaces())
{
if (@interface.IsGenericType)
{
if (@interface.GetGenericTypeDefinition() == typeof(ICollection<>))
{
// if needed, you can also return the type used as generic argument
return true;
}
}
}
return false;
}
}
}
并在您的控制器中使用它
[HttpGet]
public IActionResult TestJSON()
{
var obj = new Thing
{
id = 1,
reference = new Thing
{
id = 2,
reference = new Thing
{
id = 3,
reference = new Thing
{
id = 4
}
}
}
};
var settings = new JsonSerializerSettings()
{
ContractResolver = new ShouldSerializeContractResolver(2),
};
return new JsonResult(obj, settings);
}