我在 ASP.NET webapi 代码库中工作，我们在很大程度上依赖于通过 JSON.NET 自动支持将消息主体的 JSON 反序列化为 .NET 对象。

作为为我们的一项资源构建补丁支持的一部分，我非常想区分 JSON 对象中不存在的可选属性与显式为 null 的同一属性。我的意图是将第一个用于“不要更改那里的内容”与“删除此内容”。

有谁知道是否可以标记我的 C# DTO，以便在它们被反序列化时 JSON.NET 可以告诉我它是哪种情况？现在它们只是作为 null 出现，我不知道为什么。

相反，如果有人能想出一个更好的设计，不需要我这样做，同时仍然支持补丁动词，我很想听听你的建议。

作为一个具体的例子，考虑将传递给 put 的这个有效负载:

{
  "field1": "my field 1",
  "nested": {
    "nested1": "something",
    "nested2": "else"
  }
}

现在，如果我只想更新 field1，我应该能够将其作为 HTTP 补丁发送:

{
  "field1": "new field1 value"
}

并且嵌套值将保持不变。但是，如果我发送这个:

{
  "nested": null
}

我想知道这意味着我应该明确删除嵌套数据。

最佳答案

如果你使用 Json.Net 的 LINQ-to-JSON API (JTokens、JObjects 等)来解析 JSON，您可以区分 null 值和 JSON 中根本不存在的字段。例如:

JToken root = JToken.Parse(json);

JToken nested = root["nested"];
if (nested != null)
{
    if (nested.Type == JTokenType.Null)
    {
        Console.WriteLine("nested is set to null");
    }
    else
    {
        Console.WriteLine("nested has a value: " + nested.ToString());
    }
}
else
{
    Console.WriteLine("nested does not exist");
}

fiddle :https://dotnetfiddle.net/VJO7ay

更新

如果您使用 Web API 反序列化为具体对象，您仍然可以通过创建自定义 JsonConverter 来使用上述概念来处理您的 DTO。问题是您的 DTO 上需要有一个位置来存储反序列化期间的字段状态。我建议使用像这样的基于字典的方案:

enum FieldDeserializationStatus { WasNotPresent, WasSetToNull, HasValue }

interface IHasFieldStatus
{
    Dictionary<string, FieldDeserializationStatus> FieldStatus { get; set; }
}

class FooDTO : IHasFieldStatus
{
    public string Field1 { get; set; }
    public BarDTO Nested { get; set; }
    public Dictionary<string, FieldDeserializationStatus> FieldStatus { get; set; }
}

class BarDTO : IHasFieldStatus
{
    public int Num { get; set; }
    public string Str { get; set; }
    public bool Bool { get; set; }
    public decimal Dec { get; set; }
    public Dictionary<string, FieldDeserializationStatus> FieldStatus { get; set; }
}

然后，自定义转换器将使用上述 LINQ-to-JSON 技术来读取反序列化对象的 JSON。对于目标对象中的每个字段，它会向该对象的 FieldStatus 字典添加一个项目，指示该字段是否有值、明确设置为 null 或在 JSON 中不存在。代码可能如下所示:

class DtoConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return (objectType.IsClass && 
                objectType.GetInterfaces().Any(i => i == typeof(IHasFieldStatus)));
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var jsonObj = JObject.Load(reader);
        var targetObj = (IHasFieldStatus)Activator.CreateInstance(objectType);

        var dict = new Dictionary<string, FieldDeserializationStatus>();
        targetObj.FieldStatus = dict;

        foreach (PropertyInfo prop in objectType.GetProperties())
        {
            if (prop.CanWrite && prop.Name != "FieldStatus")
            {
                JToken value;
                if (jsonObj.TryGetValue(prop.Name, StringComparison.OrdinalIgnoreCase, out value))
                {
                    if (value.Type == JTokenType.Null)
                    {
                        dict.Add(prop.Name, FieldDeserializationStatus.WasSetToNull);
                    }
                    else
                    {
                        prop.SetValue(targetObj, value.ToObject(prop.PropertyType, serializer));
                        dict.Add(prop.Name, FieldDeserializationStatus.HasValue);
                    }
                }
                else
                {
                    dict.Add(prop.Name, FieldDeserializationStatus.WasNotPresent);
                }
            }
        }

        return targetObj;
    }

    public override bool CanWrite
    {
        get { return false; }
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

上述转换器将适用于任何实现了IHasFieldStatus 接口(interface)的对象。 (请注意，您不需要在转换器中实现 WriteJson 方法，除非您还打算对序列化执行一些自定义操作。由于 CanWrite 返回 false，转换器将不会在序列化期间使用。)

现在，要在 Web API 中使用转换器，您需要将其插入到配置中。将此添加到您的 Application_Start() 方法:

var config = GlobalConfiguration.Configuration;
var jsonSettings = config.Formatters.JsonFormatter.SerializerSettings;
jsonSettings.C‌​onverters.Add(new DtoConverter());

如果您愿意，可以像这样用 [JsonConverter] 属性装饰每个 DTO，而不是在全局配置中设置转换器:

[JsonConverter(typeof(DtoConverter))]
class FooDTO : IHasFieldStatus
{
    ...
}

有了转换器基础结构，您就可以在反序列化后查询 DTO 上的 FieldStatus 字典，以查看任何特定字段发生了什么。这是一个完整的演示(控制台应用程序):

public class Program
{
    public static void Main()
    {
        ParseAndDump("First run", @"{
            ""field1"": ""my field 1"",
            ""nested"": {
                ""num"": null,
                ""str"": ""blah"",
                ""dec"": 3.14
            }
        }");

        ParseAndDump("Second run", @"{
            ""field1"": ""new field value""
        }");

        ParseAndDump("Third run", @"{
            ""nested"": null
        }");
    }

    private static void ParseAndDump(string comment, string json)
    {
        Console.WriteLine("--- " + comment + " ---");

        JsonSerializerSettings settings = new JsonSerializerSettings();
        settings.Converters.Add(new DtoConverter());

        FooDTO foo = JsonConvert.DeserializeObject<FooDTO>(json, settings);

        Dump(foo, "");

        Console.WriteLine();
    }

    private static void Dump(IHasFieldStatus dto, string indent)
    {
        foreach (PropertyInfo prop in dto.GetType().GetProperties())
        {
            if (prop.Name == "FieldStatus") continue;

            Console.Write(indent + prop.Name + ": ");
            object val = prop.GetValue(dto);
            if (val is IHasFieldStatus)
            {
                Console.WriteLine();
                Dump((IHasFieldStatus)val, "  ");
            }
            else
            {
                FieldDeserializationStatus status = dto.FieldStatus[prop.Name];
                if (val != null) 
                    Console.Write(val.ToString() + " ");
                if (status != FieldDeserializationStatus.HasValue)
                    Console.Write("(" + status + ")");
                Console.WriteLine();
            }
        }
    }   
}

输出:

--- First run ---
Field1: my field 1 
Nested: 
  Num: 0 (WasSetToNull)
  Str: blah 
  Bool: False (WasNotPresent)
  Dec: 3.14 

--- Second run ---
Field1: new field value 
Nested: (WasNotPresent)

--- Third run ---
Field1: (WasNotPresent)
Nested: (WasSetToNull)

fiddle :https://dotnetfiddle.net/xyKrg2

关于c# - Json.NET 序列化中有没有办法区分 "null because not present"和 "null because null"？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29024284/