無法反序列化當前的JSON對象（空數組）

Question

我試圖使這個程序將所有這些對象格式化為樹視圖，為此（我使用JSON來排序對象），我需要解析JSON，所以我選擇了JSON.NET。

以下是格式化的示例：

{
    "Space": {
        "ClassName": "SpaceObject",
        "Name": "Space",
        "Children": {
            "Object1": {
                "ClassName": "Object",
                "Name": "Object1",
                "Children": []
            },
            "Object2": {
                "ClassName": "Object",
                "Name": "Object2",
                "Children": []
            }
        }
    }
}

public class CObject 
{
    [JsonProperty(PropertyName = "Name")]
    public string Name { get; set; }

    [JsonProperty(PropertyName = "ClassName")]
    public string ClassName { get; set; }

    [JsonProperty(PropertyName = "Children")]
    public IDictionary<string, CObject> Children { get; set; }
}

IDictionary<string, CObject> obj = JsonConvert.DeserializeObject<IDictionary<string, CObject>>(Json, new JsonSerializerSettings() {
    MissingMemberHandling = MissingMemberHandling.Ignore,
    NullValueHandling = NullValueHandling.Ignore,
});
foreach (var i in obj) {
    ExplorerView1.Nodes.Add(AddObject(i.Value));
}

我相信我發現了錯誤，這是由於子數組中沒有任何對象。 我不知道如何解決這個問題，任何人都可以幫忙嗎？

Answer 1

JsonSingleOrEmptyArrayConverter<T>從這個答案來反序列化JSON，當類型可以不同時幾乎JsonSingleOrEmptyArrayConverter<T>你的需要。 只需要增強它以允許當前的合同類型是字典合同以及對象合同。

首先，修改JsonSingleOrEmptyArrayConverter<T> ，如下所示：

public class JsonSingleOrEmptyArrayConverter<T> : JsonConverter where T : class
{
    //https://stackoverflow.com/questions/29449641/deserialize-json-when-type-can-be-different?rq=1
    public override bool CanConvert(Type objectType)
    {
        return typeof(T).IsAssignableFrom(objectType);
    }

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

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var contract = serializer.ContractResolver.ResolveContract(objectType);
        // Allow for dictionary contracts as well as objects contracts, since both are represented by 
        // an unordered set of name/value pairs that begins with { (left brace) and ends with } (right brace).
        if (!(contract is Newtonsoft.Json.Serialization.JsonObjectContract 
              || contract is Newtonsoft.Json.Serialization.JsonDictionaryContract))
        {
            throw new JsonSerializationException(string.Format("Unsupported objectType {0} at {1}.", objectType, reader.Path));
        }

        switch (reader.SkipComments().TokenType)
        {
            case JsonToken.StartArray:
                {
                    int count = 0;
                    while (reader.Read())
                    {
                        switch (reader.TokenType)
                        {
                            case JsonToken.Comment:
                                break;
                            case JsonToken.EndArray:
                                // You might want to allocate an empty object here if existingValue is null
                                // If so, do
                                // return existingValue ?? contract.DefaultCreator();
                                return existingValue;
                            default:
                                {
                                    count++;
                                    if (count > 1)
                                        throw new JsonSerializationException(string.Format("Too many objects at path {0}.", reader.Path));
                                    existingValue = existingValue ?? contract.DefaultCreator();
                                    serializer.Populate(reader, existingValue);
                                }
                                break;
                        }
                    }
                    // Should not come here.
                    throw new JsonSerializationException(string.Format("Unclosed array at path {0}.", reader.Path));
                }

            case JsonToken.Null:
                return null;

            case JsonToken.StartObject:
                existingValue = existingValue ?? contract.DefaultCreator();
                serializer.Populate(reader, existingValue);
                return existingValue;

            default:
                throw new InvalidOperationException("Unexpected token type " + reader.TokenType.ToString());
        }
    }

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

public static partial class JsonExtensions
{
    public static JsonReader SkipComments(this JsonReader reader)
    {
        while (reader.TokenType == JsonToken.Comment && reader.Read())
            ;
        return reader;
    }
}

然后反序列化如下：

var settings = new JsonSerializerSettings
{
    MissingMemberHandling = MissingMemberHandling.Ignore,
    NullValueHandling = NullValueHandling.Ignore,               
    Converters = { new JsonSingleOrEmptyArrayConverter<IDictionary<string, CObject>>() },
};

var obj = JsonConvert.DeserializeObject<IDictionary<string, CObject>>(Json, settings);

筆記：

• 我的假設是只在沒有子節點時才使用空數組[] 。 如果數組是非空的，則此假設將是錯誤的並且轉換器將無法正常工作。

• 轉換器為空數組返回null值。 如果您更喜歡空字典，請取消注釋以下行：

   // You might want to allocate an empty object here if existingValue is null // If so, do // return existingValue ?? contract.DefaultCreator(); 

在這里工作.Net小提琴。