如何让 ReadJson 返回“默认”行为 - 好像 CanConvert 返回 false

Question

• 我创建了JsonConverter 的实现
• CanConvert 总是返回 true。
• 在ReadJson 中，我有时只想使用“默认”行为，就好像CanConvert 返回了false，而我的ReadJson 从未被调用过。
• 其他各种帖子建议我对以下内容进行一些变体：

existingValue = existingValue ?? serializer
                                     .ContractResolver
                                     .ResolveContract(objectType)
                                     .DefaultCreator();
serializer.Populate(reader, existingValue);

• 但是，这会在 .DefaultCreator() 上抛出 NullReferenceException。
• existingValue 始终是 null
• 从序列化程序返回的ContractResolver 是我自己的。它扩展了 json.net 的内置 CamelCasePropertyNamesContractResolver 并简单地覆盖了方法 CreateConstructorParameters 和 CreatePropertyFromConstructorParameter

我该如何告诉 json.net -“开个玩笑，我不知道如何创建这个东西，如果我告诉你我无法创建它，你会做任何事情来创建它”

请注意，我已简化问题以供讨论。我预计有人会回答“只需让CanCreate 返回false”事实上，在许多情况下，我可以而且应该创建对象。

Answer 1

从您的问题和 cmets 看来，您在某些情况下希望转换器读取但不写入，而在其他情况下您希望转换器写入但不读取。通过将功能拆分为两个转换器，然后让每个转换器的 CanConvert 方法在适当的时间返回 true 或 false，您已经解决了这个问题。这当然是一种可行的方法，并且似乎对您有用，这很棒。但是，我想提供一个替代解决方案。

除了CanConvert 方法之外，基础JsonConverter 提供了两个可以覆盖的虚拟布尔属性：CanRead 和CanWrite。 （默认情况下两者都返回 true。）这些属性直接控制 ReadJson 和 WriteJson 是否由特定转换器的序列化程序调用。因此，例如，如果 CanRead 返回 false，则不会调用 ReadJson，而是使用默认读取行为，即使 CanConvert 返回 true。这使您可以非常巧妙地设置非对称转换器。例如，您可能有一种情况，您想将疯狂的 JSON 格式反序列化为更健全的对象结构，但是当您再次序列化它时，您不想回到疯狂的 JSON 格式——您只想要默认序列化。在这种情况下，您将在转换器中覆盖 CanWrite 以始终返回 false。然后你可以将WriteJson 的实现留空，或者让它抛出一个NotImplementedException;它永远不会被调用。

您的情况听起来比这要复杂一些，但您仍然应该能够操纵CanRead 和CanWrite 属性来实现您想要的结果。下面是一个人为的示例，它显示了我们如何根据情境变量打开和关闭 ReadJson 和 WriteJson 方法。

public class Program
{
    public static void Main(string[] args)
    {
        string json = @"{""keys"":[""foo"",""fizz""],""values"":[""bar"",""bang""]}";

        CustomConverter converter = new CustomConverter();
        JsonSerializerSettings settings = new JsonSerializerSettings();
        settings.Converters.Add(converter);

        // Here we are reading a JSON object containing two arrays into a dictionary
        // (custom read) and then writing out the dictionary JSON (standard write)
        Console.WriteLine("--- Situation 1 (custom read, standard write) ---");
        converter.Behavior = ConverterBehavior.CustomReadStandardWrite;
        json = DeserializeThenSerialize(json, settings);

        // Here we are reading a simple JSON object into a dictionary (standard read)
        // and then writing out a new JSON object containing arrays (custom write)
        Console.WriteLine("--- Situation 2 (standard read, custom write) ---");
        converter.Behavior = ConverterBehavior.StandardReadCustomWrite;
        json = DeserializeThenSerialize(json, settings);
    }

    private static string DeserializeThenSerialize(string json, JsonSerializerSettings settings)
    {
        Console.WriteLine("Deserializing...");
        Console.WriteLine(json);
        var dict = JsonConvert.DeserializeObject<Dictionary<string, string>>(json, settings);
        foreach (var kvp in dict)
        {
            Console.WriteLine(kvp.Key + ": " + kvp.Value);
        }

        Console.WriteLine("Serializing...");
        json = JsonConvert.SerializeObject(dict, settings);
        Console.WriteLine(json);
        Console.WriteLine();

        return json;
    }
}

enum ConverterBehavior { CustomReadStandardWrite, StandardReadCustomWrite }

class CustomConverter : JsonConverter
{
    public ConverterBehavior Behavior { get; set; }

    public override bool CanConvert(Type objectType)
    {
        return typeof(IDictionary<string, string>).IsAssignableFrom(objectType);
    }

    public override bool CanRead
    {
        get { return Behavior == ConverterBehavior.CustomReadStandardWrite; }
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        Console.WriteLine("ReadJson was called");

        // Converts a JSON object containing a keys array and a values array
        // into a Dictionary<string, string>
        JObject jo = JObject.Load(reader);
        return jo["keys"].Zip(jo["values"], (k, v) => new JProperty((string)k, v))
                         .ToDictionary(jp => jp.Name, jp => (string)jp.Value);
    }

    public override bool CanWrite
    {
        get { return Behavior == ConverterBehavior.StandardReadCustomWrite; }
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        Console.WriteLine("WriteJson was called");

        // Converts a dictionary to a JSON object containing 
        // a keys array and a values array from the dictionary
        var dict = (Dictionary<string, string>)value;
        JObject jo = new JObject(new JProperty("keys", new JArray(dict.Keys)),
                                 new JProperty("values", new JArray(dict.Values)));
        jo.WriteTo(writer);
    }
}

输出：

--- Situation 1 (custom read, standard write) ---
Deserializing...
{"keys":["foo","fizz"],"values":["bar","bang"]}
ReadJson was called
foo: bar
fizz: bang
Serializing...
{"foo":"bar","fizz":"bang"}

--- Situation 2 (standard read, custom write) ---
Deserializing...
{"foo":"bar","fizz":"bang"}
foo: bar
fizz: bang
Serializing...
WriteJson was called
{"keys":["foo","fizz"],"values":["bar","bang"]}

小提琴：https://dotnetfiddle.net/BdtSoN