我正在写一个JsonConverter来执行一些我需要在读/写时完成的转换任务。特别是，我采用了现有的序列化行为，并在写入/读取时添加了一些附加属性。
在 内部JsonConverter，我想利用传递的JsonSerializer实例来执行大部分转换功能。但是，当我这样做时，我最终会进入一个递归循环，其中序列化程序调用我的转换器，该转换器调用调用转换器的序列化程序等。
我见过人们做诸如 use 之类的事情JsonConvert.SerializeObject，从序列化器实例中传入所有转换器，除了 this. 但是，这对我不起作用，因为它绕过了我在序列化程序上所做的所有其他自定义，例如自定义合同解析器和DateTime处理。
有没有办法我可以：
这是一个非常普遍的问题。使用“JsonConvert.SerializeObject”不是一个坏主意。但是，在某些情况下（通常是集合）可以使用的一个技巧是在写入时强制转换为接口，并在读取时反序列化为简单的派生。
下面是一个简单的转换器，它处理可能已经序列化为一组 KVP 而不是看起来像一个对象的字典（在这里显示我的年龄 :)）
注意“WriteJson”强制转换为 IDictionary<K,V>，“ReadJson”使用“DummyDictionary”。您最终得到了正确的结果，但使用了传递的序列化程序而不会导致递归。
/// <summary>
/// Converts a <see cref="KeyValuePair{TKey,TValue}"/> to and from JSON.
/// </summary>
public class DictionaryAsKVPConverter<TKey, TValue> : JsonConverter
{
/// <summary>
/// Determines whether this instance can convert the specified object type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>
/// <c>true</c> if this instance can convert the specified object type; otherwise, <c>false</c>.
/// </returns>
public override bool CanConvert(Type objectType)
{
if (!objectType.IsValueType && objectType.IsGenericType)
return (objectType.GetGenericTypeDefinition() == typeof(Dictionary<,>));
return false;
}
/// <summary>
/// Writes the JSON representation of the object.
/// </summary>
/// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
/// <param name="value">The value.</param>
/// <param name="serializer">The calling serializer.</param>
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var dictionary = value as IDictionary<TKey, TValue>;
serializer.Serialize(writer, dictionary);
}
/// <summary>
/// Reads the JSON representation of the object.
/// </summary>
/// <param name="reader">The <see cref="JsonReader"/> to read from.</param>
/// <param name="objectType">Type of the object.</param>
/// <param name="existingValue">The existing value of object being read.</param>
/// <param name="serializer">The calling serializer.</param>
/// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
Dictionary<TKey, TValue> dictionary;
if (reader.TokenType == JsonToken.StartArray)
{
dictionary = new Dictionary<TKey, TValue>();
reader.Read();
while (reader.TokenType == JsonToken.StartObject)
{
var kvp = serializer.Deserialize<KeyValuePair<TKey, TValue>>(reader);
dictionary[kvp.Key] = kvp.Value;
reader.Read();
}
}
else if (reader.TokenType == JsonToken.StartObject)
// Use DummyDictionary to fool JsonSerializer into not using this converter recursively
dictionary = serializer.Deserialize<DummyDictionary>(reader);
else
dictionary = new Dictionary<TKey, TValue>();
return dictionary;
}
/// <summary>
/// Dummy to fool JsonSerializer into not using this converter recursively
/// </summary>
private class DummyDictionary : Dictionary<TKey, TValue> { }
}
您确实可以使用传递给转换器的序列化程序实例，并排除当前转换器。但是，这不是线程安全的（请参阅此答案的评论）
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
serializer.Converters.Remove(this);
serializer.Serialize(writer, value);
serializer.Converters.Add(this);
}
对不起，但也许我很困惑。我使用这些方法来序列化我的对象：
using System;
using Newtonsoft.Json;
namespace Utilities
{
public static class serializer
{
public static string SerializeObject(object objectModel) {
return JsonConvert.SerializeObject(objectModel);
}
public static object DeserializeObject<T>(string jsonObject)
{
try
{
return JsonConvert.DeserializeObject<T>(jsonObject);
}
catch (Exception ex) { return null; }
}
}
}我使用了这段代码：
userLoged = (modelUser)serializer.DeserializeObject<modelUser>((string)Session["userLoged"]);希望这有用。