Json.NET如何覆盖序列化，它通过一个属性定义自定义JsonConverter一种类型？ [英] Json.NET how to override serialization for a type that defines a custom JsonConverter via an attribute?

问题描述

我试图反序列化使用Json.NET和一个自定义JsonConverter对象的类。类目前定义使用JsonConverterAttribute默认序列化的转换器。我需要传递一个自定义转换器做一个自定义的反序列化。但是，反序列化似乎仍然使用默认的转换器。我怎样才能得到Json.NET喜欢我的自定义转换器？

下面是一个有点演示问题的示例代码。我使用NewtonSoft.Json 4.5.11：

 无效的主要（）
 {
 JsonConvert。 DeserializeObject<富>（{}）; //抛出默认转换
 VAR设置=新JsonSerializerSettings {=转换器新的[] {新CustomConverter（）}}; 
 JsonConvert.DeserializeObject<富>（{}，设置）; //仍抛出默认转换： -  / 
} 
 
 [JsonConverter（typeof运算（DefaultConverter））] 
公共类Foo {
} 
 
公共类DefaultConverter：JsonConverter {
公众覆盖布尔CanConvert（类型的objectType）
 {
返回typeof运算（富）.IsAssignableFrom（的objectType）; 
} 
 
公众覆盖对象ReadJson（JsonReader读者，类型的objectType，对象existingValue，JsonSerializer串行）
 {
抛出新的异常（在默认的转换器！ ）; 
} 
 
公共覆盖无效WriteJson（JsonWriter作家，对象的值，JsonSerializer串行）
 {
抛出新的异常（在默认的转换器！）; 
} 
} 
 
公共类CustomConverter：JsonConverter {
公众覆盖布尔CanConvert（类型的objectType）
 {
返回typeof运算（富） .IsAssignableFrom（的objectType）; 
} 
 
公众覆盖对象ReadJson（JsonReader读者，类型的objectType，对象existingValue，JsonSerializer串行）
 {
抛出新的异常（中的自定义转换器！ ）; 
} 
 
公共覆盖无效WriteJson（JsonWriter作家，对象的值，JsonSerializer串行）
 {
抛出新的异常（中的自定义转换器！）; 
} 
} 
  

解决方案

您需要使用自定义的合同解析器。默认合同解析器使用转换器仅当该类型未指定转换器设置

 类CustomContractResolver：DefaultContractResolver 
 { 
保护覆盖JsonConverter ResolveContractConverter（类型的​​objectType）
 {
如果（typeof运算（富）.IsAssignableFrom（的objectType））
返回NULL; //假装转换器未指定
返回base.ResolveContractConverter（的objectType）; 
} 
} 
  

用法：

  JsonConvert.DeserializeObject<富>（{}，新JsonSerializerSettings {
 ContractResolver =新CustomContractResolver（），
转换器=新[] {新CustomConverter（）}，
}）; 
  

I am trying to deserialize a class using Json.NET and a custom JsonConverter object. The class currently defines a converter for default serialization using the JsonConverterAttribute. I need to do a custom deserialization by passing in a custom converter. However, the deserialization still seems to be using the default converter. How can I get Json.NET to prefer my custom converter?

Here's a bit of sample code that demonstrates the issue. I'm using NewtonSoft.Json 4.5.11:

void Main()
{
    JsonConvert.DeserializeObject<Foo>("{}"); // throws "in the default converter"
    var settings = new JsonSerializerSettings { Converters = new[] { new CustomConverter() } };
    JsonConvert.DeserializeObject<Foo>("{}", settings); // still throws "in the default converter" :-/
}

[JsonConverter(typeof(DefaultConverter))]
public class Foo {
}

public class DefaultConverter : JsonConverter {
    public override bool CanConvert(Type objectType)
    {
        return typeof(Foo).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new Exception("in the default converter!");
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new Exception("in the default converter!");
    }
}

public class CustomConverter : JsonConverter {
    public override bool CanConvert(Type objectType)
    {
        return typeof(Foo).IsAssignableFrom(objectType);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new Exception("in the custom converter!");
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new Exception("in the custom converter!");
    }
}

解决方案

You need to use custom contract resolver. Default contract resolver uses converters from settings only if converter is not specified for the type.

class CustomContractResolver : DefaultContractResolver
{
    protected override JsonConverter ResolveContractConverter (Type objectType)
    {
        if (typeof(Foo).IsAssignableFrom(objectType))
            return null; // pretend converter is not specified
        return base.ResolveContractConverter(objectType);
    }
}

Usage:

JsonConvert.DeserializeObject<Foo>("{}", new JsonSerializerSettings {
    ContractResolver = new CustomContractResolver(),
    Converters = new[] { new CustomConverter() },
});

这篇关于Json.NET如何覆盖序列化，它通过一个属性定义自定义JsonConverter一种类型？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！