C# 当值可以是对象或空数组时反序列化JSON

我正在使用VKAPI。有时服务器可以返回空数组而不是对象，例如：

personal: [] //when it is empty

或

我用JsonConvert.DeserializeObject反序列化了大部分json，这部分json用

MainObject = ((MainObject["response"].GetObject())["user"].GetObject())["personal"].GetObject();
try
{
Convert.ToByte(MainObject["political"].GetNumber();
} 
catch {}

但当应用程序处理大量例外时，它会使应用程序运行缓慢。刚才我意识到这里还有一些字段，当数组为空时可能会返回数组。我只是不知道如何快速清晰地完成。有什么建议吗

我的反序列化类（字段为空时不起作用）：

另一个想法（不为空时不起作用）：

公共列表个人{get；set；}

不要使用try-catch在两种可能性之间切换，只需检查第一个字符即可。如果是“[”，则为空；如果是“{”，则进行反序列化

编辑：

---

现在考虑到对象不是JSON的全部，这给了我一个想法：API返回不一致的JSON序列化时，我们遇到了类似的问题。最后，我们使用了NewtonSoft的ServiceStack.Text库（可从NuGet获得）。我们序列化为JToken对象，而不是目标类。然后，我们处理JToken结构以进行逐段反序列化。

您可以进行如下操作，查找指定类型的对象或空数组。如果是对象，则反序列化该对象。如果是空数组，则返回null：

public class JsonSingleOrEmptyArrayConverter<T> : JsonConverter where T : class
{
    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);
        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:
                                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;
    }
}

公共类JSONSingleOremptyAryConverter:JsonConverter其中T:class
{
公共覆盖布尔CanConvert（类型objectType）
{
返回typeof（T）.IsAssignableFrom（objectType）；
}
公共重写bool可以写入{get{return false；}}
公共重写对象ReadJson（JsonReader阅读器，类型objectType，对象existingValue，JsonSerializer序列化程序）
{
var contract=serializer.ContractResolver.ResolveContract（objectType）；
if（！（合同是Newtonsoft.Json.Serialization.JsonObjectContract | |合同是Newtonsoft.Json.Serialization.JsonDictionaryContract））
{
抛出新的JsonSerializationException（string.Format（“不支持的对象类型{0}位于{1}.”，对象类型，reader.Path））；
}
开关（reader.SkipComments（）.TokenType）
{
案例JsonToken.StartArray：
{
整数计数=0；
while（reader.Read（））
{
开关（reader.TokenType）
{
案例JsonToken。评论：
打破
案例JsonToken.EndArray：
返回现有值；
违约：
{
计数++；
如果（计数>1）
抛出新的JsonSerializationException（string.Format（“路径{0}.”，reader.path处的对象太多”）；
existingValue=existingValue？？contract.DefaultCreator（）；
序列化程序。填充（读取器，现有值）；
}
打破
}
}
//我不应该来这里。
抛出新的JsonSerializationException（string.Format（“路径{0}处的未关闭数组，reader.path））；
}
案例JsonToken.Null：
返回null；
案例JsonToken.StartObject：
existingValue=existingValue？？contract.DefaultCreator（）；
序列化程序。填充（读取器，现有值）；
返回现有值；
违约：
抛出新的InvalidOperationException（“意外的令牌类型”+reader.TokenType.ToString（））；
}
}
公共重写void WriteJson（JsonWriter编写器、对象值、JsonSerializer序列化器）
{
抛出新的NotImplementedException（）；
}
}
公共静态部分类JsonExtensions
{
公共静态JsonReader SkipComments（此JsonReader阅读器）
{
while（reader.TokenType==JsonToken.Comment&&reader.Read（））
;
返回读取器；
}
}

然后像这样使用它：

public class User
{
    //some other fields...
    [JsonConverter(typeof(JsonSingleOrEmptyArrayConverter<Personal>))]
    public Personal personal { get; set; }
    //some other fields...
}

公共类用户
{
//其他一些领域。。。
[JsonConverter（类型（JSONSingleOremptyAryConverter））]
公共个人{get；set；}
//其他一些领域。。。
}

您现在应该能够将用户反序列化到

user

类中

注:

• 转换器可以通过属性或在中应用

• 转换器不是为处理简单类型（如字符串）而设计的，它是为映射到JSON对象的类而设计的。这是因为它用于避免在读取过程中出现无限递归

---

工作示例.Net会摆弄和.

这是一个有趣的想法，但问题是我在任何情况下都需要这么做，而且我有很多不同的json文件。最好在类本身中认识到这一点。而且，它只是json的一小部分，我不确定我是否可以快速检查它……我明白了，我的印象是这是whole JSON文件我们在API返回不一致的JSON序列化时遇到了类似的问题。最后，我们使用了NewtonSoft的ServiceStack.Text库（可从NuGet获得）。我们序列化为JToken对象，而不是目标类。然后我们处理JToken结构以进行逐段反序列化。您知道吗，是否还有其他类型的对象可以更大规模地反序列化？是的，JToken。在您的情况下，如果对象为空，JToken也将是JArray。如果不是，则它将是JObject（如果我没记错的话，JToken是JArray和JObject的基类）。您可以使用“is”操作符进行测试，并进行相应的反序列化。尝试从这里调整SingleOrArrayConverter：感谢您的好主意，这是一个

public List<Personal> personal { get; set; }

public class JsonSingleOrEmptyArrayConverter<T> : JsonConverter where T : class
{
    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);
        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:
                                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;
    }
}

public class User
{
    //some other fields...
    [JsonConverter(typeof(JsonSingleOrEmptyArrayConverter<Personal>))]
    public Personal personal { get; set; }
    //some other fields...
}