在Json.net中使用自定义的JsonConverter和TypeNameHandling
我有一个类接口类型的属性，如：
public class Foo
{
public IBar Bar { get; set; }
}
我也有可以在运行时设置的IBar接口的多个具体实现。 其中一些具体的类需要一个定制的JsonConverter用于序列化和反序列化。
利用TypeNameHandling.Auto选项，需要IBar类的非转换器可以完美地序列化和反序列化。 另一方面，自定义序列化的类没有$type名称输出，并且在按预期序列化时，它们不能被反序列化为它们的具体类型。
我试图在自定义JsonConverter自己写出$type名称元数据; 然而，在反序列化转换器然后被完全绕过。
是否有解决方法或适当的方式来处理这种情况？
我解决了类似的问题，并找到了解决方案。 这不是很优雅，我认为应该有更好的方法，但至少它是有效的。 所以我的想法是让JsonConverter每一个实现每种类型的IBar和一个转换器IBar本身。
那么让我们从模型开始吧：
public interface IBar { }
public class BarA : IBar { }
public class Foo
{
public IBar Bar { get; set; }
}
现在让我们为IBar创建转换器。 它仅在反序列化JSON时使用。 它会尝试读取$type变量并调用转换器来实现类型：
public class BarConverter : JsonConverter
{
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
throw new NotSupportedException();
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var jObj = JObject.Load(reader);
var type = jObj.Value<string>("$type");
if (type == GetTypeString<BarA>())
{
return new BarAJsonConverter().ReadJson(reader, objectType, jObj, serializer);
}
// Other implementations if IBar
throw new NotSupportedException();
}
public override bool CanConvert(Type objectType)
{
return objectType == typeof (IBar);
}
public override bool CanWrite
{
get { return false; }
}
private string GetTypeString<T>()
{
var typeOfT = typeof (T);
return string.Format("{0}, {1}", typeOfT.FullName, typeOfT.Assembly.GetName().Name);
}
}
这是BarA类的转换器：
public class BarAJsonConverter : BarBaseJsonConverter
{
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
// '$type' property will be added because used serializer has TypeNameHandling = TypeNameHandling.Objects
GetSerializer().Serialize(writer, value);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
var existingJObj = existingValue as JObject;
if (existingJObj != null)
{
return existingJObj.ToObject<BarA>(GetSerializer());
}
throw new NotImplementedException();
}
public override bool CanConvert(Type objectType)
{
return objectType == typeof(BarA);
}
}
您可能会注意到它是从BarBaseJsonConverter类继承的，而不是JsonConverter 。 而且我们也不使用WriteJson和ReadJson方法中的serializer参数。 在自定义转换器中使用serializer参数存在问题。 你可以在这里阅读更多。 我们需要创建JsonSerializer新实例，而基类很适合这样的情况：
public abstract class BarBaseJsonConverter : JsonConverter
{
public JsonSerializer GetSerializer()
{
var serializerSettings = JsonHelper.DefaultSerializerSettings;
serializerSettings.TypeNameHandling = TypeNameHandling.Objects;
var converters = serializerSettings.Converters != null
? serializerSettings.Converters.ToList()
: new List<JsonConverter>();
var thisConverter = converters.FirstOrDefault(x => x.GetType() == GetType());
if (thisConverter != null)
{
converters.Remove(thisConverter);
}
serializerSettings.Converters = converters;
return JsonSerializer.Create(serializerSettings);
}
}
JsonHelper只是创建JsonSerializerSettings的类：
public static class JsonHelper
{
public static JsonSerializerSettings DefaultSerializerSettings
{
get
{
return new JsonSerializerSettings
{
Converters = new JsonConverter[] { new BarConverter(), new BarAJsonConverter() }
};
}
}
}
现在它可以工作，并且您仍然可以使用自定义转换器进行序列化和反序列化：
var obj = new Foo { Bar = new BarA() };
var json = JsonConvert.SerializeObject(obj, JsonHelper.DefaultSerializerSettings);
var dObj = JsonConvert.DeserializeObject<Foo>(json, JsonHelper.DefaultSerializerSettings);
使用上面Alesandr Ivanov的答案中的信息，我创建了一个通用的WrappedJsonConverter<T>类，它包装（和展开）需要转换器的具体类，使用$wrappedType元数据属性，该属性遵循与标准$type相同的类型名称序列化。
WrappedJsonConverter<T>作为转换器添加到接口（即IBar ）中，否则此包装对于不需要转换器的类完全透明，并且不需要对包装转换器进行更改。
我使用了稍微不同的hack来解决转换器/序列化器循环（静态字段），但它不需要任何关于使用的序列化器设置的知识，并且允许IBar对象图具有子IBar属性。
对于包装的对象，Json看起来像：
"IBarProperty" : {
"$wrappedType" : "Namespace.ConcreteBar, Namespace",
"$wrappedValue" : {
"ConvertedID" : 90,
"ConvertedPropID" : 70
...
}
}
完整的要点可以在这里找到。
public class WrappedJsonConverter<T> : JsonConverter<T> where T : class
{
[ThreadStatic]
private static bool _canWrite = true;
[ThreadStatic]
private static bool _canRead = true;
public override bool CanWrite
{
get
{
if (_canWrite)
return true;
_canWrite = true;
return false;
}
}
public override bool CanRead
{
get
{
if (_canRead)
return true;
_canRead = true;
return false;
}
}
public override T ReadJson(JsonReader reader, T existingValue, JsonSerializer serializer)
{
var jsonObject = JObject.Load(reader);
JToken token;
T value;
if (!jsonObject.TryGetValue("$wrappedType", out token))
{
//The static _canRead is a terrible hack to get around the serialization loop...
_canRead = false;
value = jsonObject.ToObject<T>(serializer);
_canRead = true;
return value;
}
var typeName = jsonObject.GetValue("$wrappedType").Value<string>();
var type = JsonExtensions.GetTypeFromJsonTypeName(typeName, serializer.Binder);
var converter = serializer.Converters.FirstOrDefault(c => c.CanConvert(type) && c.CanRead);
var wrappedObjectReader = jsonObject.GetValue("$wrappedValue").CreateReader();
wrappedObjectReader.Read();
if (converter == null)
{
_canRead = false;
value = (T)serializer.Deserialize(wrappedObjectReader, type);
_canRead = true;
}
else
{
value = (T)converter.ReadJson(wrappedObjectReader, type, existingValue, serializer);
}
return value;
}
public override void WriteJson(JsonWriter writer, T value, JsonSerializer serializer)
{
var type = value.GetType();
var converter = serializer.Converters.FirstOrDefault(c => c.CanConvert(type) && c.CanWrite);
if (converter == null)
{
//This is a terrible hack to get around the serialization loop...
_canWrite = false;
serializer.Serialize(writer, value, type);
_canWrite = true;
return;
}
writer.WriteStartObject();
{
writer.WritePropertyName("$wrappedType");
writer.WriteValue(type.GetJsonSimpleTypeName());
writer.WritePropertyName("$wrappedValue");
converter.WriteJson(writer, value, serializer);
}
writer.WriteEndObject();
}
}
上一篇: Using custom JsonConverter and TypeNameHandling in Json.net
下一篇: ReceiverRestrictedContext cannot be cast to android.app.Activity