如何使用 Json.NET 序列化 Task<TResult>？

Question

考虑

public class InQuestion<TType>
{
    // JsonConverter(typeof CustomConverter))
    public Task<TType> toConvert { get; set; }
}

如何使用 json.net（反）序列化这个类？

我认为我真正想要序列化的是底层的Task.Result，然后可以使用Task.FromResult() 对其进行反序列化。如果我要使用自定义 JsonConverter，我无法通过 Attribute 传递通用 TType，以在 JsonConverter 中重建（或检索）TType 对象。因此我被卡住了。

问题来自这段代码：

public class Program
{
    public class InQuestion<TType>
    {
        public Task<TType> toConvert { get; set; }
    }

    public class Result
    {
        public int value { get; set; }
    }

    public static async Task Main()
    {
        var questionable = new InQuestion<Result>();
        questionable.toConvert = Task.Run(async () => new Result { value = 42 });
        await questionable.toConvert; 

        string json = JsonConvert.SerializeObject(questionable);
        Debug.WriteLine(json); 
        InQuestion<Result> back = JsonConvert.DeserializeObject(json, typeof(InQuestion<Result>)) as InQuestion<Result>;
        Debug.Assert(back?.toConvert?.Result?.value == 42); 
    }
}

令我惊讶的是，在调用 JsonConvert.DeserializeObject 期间停止。 https://github.com/JamesNK/Newtonsoft.Json/issues/1886 讨论了这个问题并推荐了合理的“不要序列化/反序列化任务。”，但实际上并没有建议如何序列化底层任务.Result。

Answer 1

Task 是对未来值的承诺，当然您不能序列化尚未提供的值。

由于InQuestion 对象拥有Task 成员，您无法序列化和反序列化InQuestion 对象。

解决方法是将结果序列化，反序列化后重构InQuestion对象。

public static async Task Main()
{
    var questionable = new InQuestion<Result>();
    questionable.toConvert = Task.Run(async () => new Result { value = 42 });

    Result result = await questionable.toConvert;
    string json = JsonConvert.SerializeObject(result);
    
    Result back = JsonConvert.DeserializeObject(json, typeof<Result>) as Result;

    InQuestion<Result> reconstructed = new InQuestion<Result>()
    {
        toConvert = Task.FromResult(back)
    };
}

Answer 2

我已经找到了解决这个问题的两种方法。

来自Add support for generic JsonConverter instantiation：

    [JsonConverter(typeof(InQuestionConverter<>))]
    public class InQuestion<TResult>
    {
        public Task<TResult> toConvert { get; set; }
    }

    public class Result
    {
        public int value { get; set; }
        public string text { get; set; }

        public override bool Equals(object obj)
        {
            return obj is Result result &&
                   value == result.value &&
                   text == result.text;
        }
    }

    public class InQuestionConverter<TResult> : JsonConverter<InQuestion<TResult>>
    {
        public override InQuestion<TResult> ReadJson(JsonReader reader, Type objectType, InQuestion<TResult> existingValue, bool hasExistingValue, JsonSerializer serializer)
        {
            if (hasExistingValue)
                existingValue.toConvert = Task.FromResult(serializer.Deserialize<TResult>(reader));
            else
                existingValue = new InQuestion<TResult>
                {
                    toConvert = Task.FromResult(serializer.Deserialize<TResult>(reader))
                };
            return existingValue;
        }

        public override void WriteJson(JsonWriter writer, InQuestion<TResult> value, JsonSerializer serializer)
        {
            serializer.Serialize(writer, value.toConvert.Result, typeof(TResult));
        }
    }

    public sealed class CustomContractResolver : DefaultContractResolver
    {
        protected override JsonConverter ResolveContractConverter(Type objectType)
        {
            var typeInfo = objectType.GetTypeInfo();
            if (typeInfo.IsGenericType && !typeInfo.IsGenericTypeDefinition)
            {
                var jsonConverterAttribute = typeInfo.GetCustomAttribute<JsonConverterAttribute>();
                if (jsonConverterAttribute != null && jsonConverterAttribute.ConverterType.GetTypeInfo().IsGenericTypeDefinition)
                {
                    Type t = jsonConverterAttribute.ConverterType.MakeGenericType(typeInfo.GenericTypeArguments);
                    object[] parameters = jsonConverterAttribute.ConverterParameters;
                    return (JsonConverter)Activator.CreateInstance(t, parameters);
                }
            }
            return base.ResolveContractConverter(objectType);
        }
    }

    public static void Main()
    {
        var questionable = new InQuestion<Result>();
        questionable.toConvert = Task.Run(async () => { return new Result { value = 42, text = "fox" };  });
        questionable.toConvert.Wait();

        string json = JsonConvert.SerializeObject(questionable, Formatting.None, new JsonSerializerSettings { ContractResolver = new CustomContractResolver() });
        InQuestion<Result> back = JsonConvert.DeserializeObject(json, typeof(InQuestion<Result>), new JsonSerializerSettings { ContractResolver = new CustomContractResolver() }) as InQuestion<Result>;

        Debug.Assert(back.toConvert.Result.Equals(questionable.toConvert.Result));
        return;
    }

启用自定义ContractResolver，它将指向JsonConverter<TResult> 的正确通用实例化，其中序列化很简单。这需要配置 JsonSerializerSettings 并为整个 InQuestion 类提供序列化（请注意，转换器不检查此示例中的 Task.IsCompleted）。

或者，仅在 Task<T> 类型的属性上使用 JsonConverterAttribute 并依靠反射从非泛型转换器中检索 TResult 类型：

    public class InQuestion<TResult>
    {
        [JsonConverter(typeof(FromTaskOfTConverter))]
        public Task<TResult> toConvert { get; set; }
    }

    public class FromTaskOfTConverter : JsonConverter
    {
        public override bool CanConvert(Type objectType)
        {
            return IsDerivedFromTaskOfT(objectType);
        }

        static bool IsDerivedFromTaskOfT(Type type)
        {
            while (type.BaseType != typeof(object))
            {
                if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task<>))
                    return true;
                type = type.BaseType;
            }
            return false;
        }

        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            Debug.Assert(IsDerivedFromTaskOfT(objectType));
            Type TResult = objectType.GetGenericArguments()[0];
            object ResultValue = serializer.Deserialize(reader, TResult);
            return typeof(Task).GetMethod("FromResult").MakeGenericMethod(TResult).Invoke(null, new[] { ResultValue });
        }

        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            Type objectType = value.GetType();
            Debug.Assert(IsDerivedFromTaskOfT(objectType));

            Type TResult = objectType.GetGenericArguments()[0];
            Type TaskOfTResult = typeof(Task<>).MakeGenericType(TResult);

            if ((bool)TaskOfTResult.GetProperty("IsCompleted").GetValue(value) == true)
            {
                object ResultValue = TaskOfTResult.GetProperty("Result").GetValue(value);
                serializer.Serialize(writer, ResultValue, TResult);
            }
            else
            {
                serializer.Serialize(writer, Activator.CreateInstance(TResult));
            }
        }
    }

    public static void Main()
    {
        var questionable = new InQuestion<Result>();
        questionable.toConvert = Task.Run(async () => { return new Result { value = 42, text = "fox" }; });
        questionable.toConvert.Wait();

        string json = JsonConvert.SerializeObject(questionable);
        InQuestion<Result> back = JsonConvert.DeserializeObject(json, typeof(InQuestion<Result>)) as InQuestion<Result>;

        Debug.Assert(back.toConvert.Result.Equals(questionable.toConvert.Result));
        return;
    }

尽管如此，我不会将其标记为已接受，因为我对泛型反射和 json.net 缺乏了解。