返回类型中引用类型的可空性与被覆盖的成员不匹配

Question

我正在使用一个返回 JSON 的 API，其中一个值可以是 false 或对象。为了解决这个问题，我创建了一个自定义 JsonConverter<T>。

internal class JsonFalseOrObjectConverter<T> : JsonConverter<T> where T : class
{
    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType == JsonTokenType.False)
        {
            return null;
        }
        else
        {
            return JsonSerializer.Deserialize<T>(ref reader);
        }
    }
}

问题是我得到以下编译器错误：

可能的空引用返回。

我可以将返回的类型设置为T?，但我会收到错误：

返回类型中引用类型的可空性与被覆盖的成员不匹配。

我该如何解决这个问题？

Answer 1

您已声明泛型类型是（不可为空的）T，但您返回的是null。这显然是无效的。

如果您不在乎，您需要让您的转换器实现 JsonConverter<T?> 或使用 null 宽恕运算符。

internal class JsonFalseOrObjectConverter<T> : JsonConverter<T?> where T : class
{
    public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        ...
    }

    public override void Write(Utf8JsonWriter writer, T? value, JsonSerializerOptions options)
    {
        ...
    }
}

或

public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
    if (reader.TokenType == JsonTokenType.False)
    {
        return null!;
    }
    ...
}

Answer 2

最简单的解决方案是return null!：

#nullable enable

internal class JsonFalseOrObjectConverter<T> : JsonConverter<T> where T : class
{
    public override T Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType == JsonTokenType.False)
        {
            return null!;
        }
        else
        {
            return JsonSerializer.Deserialize<T>(ref reader);
        }
    }

    public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options){}
}    

引用类是可为空的，因此当遇到T? 时，编译器只使用T。

更好的选择是创建类似于 F# 的 Option type 的东西，如果设置了值，则包含 Some value，如果 value 为 false，则包含 None。通过将 Option 设为结构，即使属性缺失或为 null，我们也会获得默认的 None 值：

readonly struct Option<T> 
{
    public readonly T Value {get;}

    public readonly bool IsSome {get;}
    public readonly bool IsNone =>!IsSome;

    public Option(T value)=>(Value,IsSome)=(value,true);    

    public void Deconstruct(out T value)=>(value)=(Value);
}

//Convenience methods, similar to F#'s Option module
static class Option
{
    public static Option<T> Some<T>(T value)=>new Option<T>(value);    
    public static Option<T> None<T>()=>default;
}

如果遇到 false，反序列化器可以返回 None() 或 default：

internal class JsonFalseOrObjectConverter<T> : JsonConverter<Option<T>> where T : class
{
    public override Option<T> Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
    {
        if (reader.TokenType == JsonTokenType.False)
        {
            return Option.None<T>(); // or default
        }
        else
        {
            return Option.Some(JsonSerializer.Deserialize<T>(ref reader));
        }
    }

    public override void Write(Utf8JsonWriter writer, Option<T> value, JsonSerializerOptions options)
    {
        switch (value)
        {
            case Option<T> (_    ,false) :
                JsonSerializer.Serialize(writer,false,options);
                break;
            case Option<T> (var v,true) :
                JsonSerializer.Serialize(writer,v,options);
                break;
        }
    }
}    

Write 方法展示了如何使用模式匹配处理Option<T>。

使用此序列化程序，以下类：

class Category
{
    public string Name{get;set;}
}


class Product
{
    public string Name{get;set;}

    public Option<Category> Category {get;set;}
}

可以使用为缺少的类别生成的false 进行序列化：

var serializerOptions = new JsonSerializerOptions
{ 
    Converters = { new JsonFalseOrObjectConverter<Category>() }
};

var product1=new Product{Name="A"};
var json=JsonSerializer.Serialize(product1,serializerOptions);

这会返回：

{"Name":"A","Category":false}

反序列化此字符串会返回一个Product，其Category 是一个没有值的Option<Category>：

var product2=JsonSerializer.Deserialize<Product>(json,serializerOptions);
Debug.Assert(product2.Category.IsNone);

模式匹配表达式可用于提取和使用具有值的类别的属性，例如：

string category=product2.Category switch { Option<Category> (_    ,false) =>"No Category",
                                        Option<Category> (var v,true)  => v.Name};

或者

if(product2.Category is Option<Category>(var cat,true))
{
    Console.WriteLine(cat.Name);
}