C# 使用表示查询的未知数量的嵌套数组反序列化JSON

我有一些JSON，如下所示

{
  "queryEntry": [
    [
      {
        "type": "expression",
        "key": "Account.Name",
        "operators": "=",
        "value": "asd"
      }
    ],
    {
      "type": "conjunction",
      "value": "OR",
      "key": null,
      "operators": null
    },
    [
      {
        "type": "expression",
        "key": "Account.TotalEmployees",
        "operators": "=",
        "value": "123"
      },
      {
        "type": "conjunction",
        "value": "AND",
        "key": null,
        "operators": null
      },
      [
        {
          "type": "expression",
          "key": "Account.LastYearRevenue",
          "operators": "=",
          "value": "123"
        },
        {
          "type": "conjunction",
          "value": "OR",
          "key": null,
          "operators": null
        },
        [
          {
            "type": "expression",
            "key": "Account.Last5YearRevenue",
            "operators": "=",
            "value": "123"
          }
        ]
      ]
    ],
    {
      "type": "conjunction",
      "value": "AND",
      "key": null,
      "operators": null
    },
    [
      {
        "type": "expression",
        "key": "Account.OwnerName",
        "operators": "=",
        "value": "asd"
      }
    ]
  ]
}

这实际上是SQL中的一个

where

条件，我们是从jQuery生成的。我必须将此字符串反序列化为C#中的类

---

有人能告诉我应该创建什么类来反序列化这个吗？此外，还不知道嵌套数组的深度。

您可以使用JsonConvert进行如下转换

MyData tmp = JsonConvert.DeserializeObject<MyData>(json);
foreach (string typeStr in tmp.type[0])
{
    // Do something with typeStr
}

公共字符串t； 公共图书馆

}

---

这是一种很难使用的JSON格式，因为它是一种递归数组结构，其中数组可以包含对象或数组，也可以包含两者的组合。我可以看到JSON对象表示查询的各个部分，但查询子表达式不在我预期的对象中。相反，数组似乎被用作对查询进行分组的文字括号

我认为将其反序列化为半正常类结构的最佳方法是使用，其中一个类既表示查询的单个部分（即表达式或连接），也表示查询的一个分组。大概是这样的：

class QueryEntry
{
    public string Type { get; set; }
    public string Key { get; set; }
    public string Operators { get; set; }
    public string Value { get; set; }
    public List<QueryEntry> Group { get; private set; }
    public bool IsGroup { get { return Group.Count > 0; } }

    public QueryEntry()
    {
        Group = new List<QueryEntry>();
    }
}

var root = JsonConvert.DeserializeObject<RootObject>(json, new QueryEntryConverter());

现在，由于JSON可以是任何级别的对象或异类数组，我们不能将这个类扔到JSON.Net上，然后期望它立即正确地反序列化。（您正在使用，不是吗？您的问题没有说。）我们需要使用一个自定义来将JSON结构转换为复合类结构：

class QueryEntryConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(QueryEntry);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        QueryEntry entry = new QueryEntry();
        JToken token = JToken.Load(reader);
        if (token.Type == JTokenType.Object)
        {
            serializer.Populate(token.CreateReader(), entry);
        }
        else if (token.Type == JTokenType.Array)
        {
            foreach (JToken child in token)
            {
                entry.Group.Add(child.ToObject<QueryEntry>(serializer));
            }
        }
        return entry;
    }

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

然后我们可以做：

Console.WriteLine(root.QueryEntry.ToString());

如果您的问题中有JSON，那么输出将是：

（（Account.Name=asd）或（Account.TotalEmployees=123和（Account.LastYearRevenue=123或（Account.Last5YearRevenue=123））和（Account.OwnerName=asd））

---

这是一个有效的演示：

类似的要求-检查此项-嗨，Ankit，如果对象有限制，此项工作正常。但是问题是，同一个对象可以在自身内部重复。是的，这就是为什么对象列表将是更好的选择。如果要查询反序列化对象，考虑使用JSON.NET Hi-KANIT，我会尝试它自身的对象可以是数组（嵌套数组）中的数组。我们如何反序列化呢？谢谢你，布莱恩。这太完美了。是的，我使用的是

Json.Net

在这种情况下，我们可以从JsonConverter继承吗？@TheBoxyBear是的，您可以。

var root = JsonConvert.DeserializeObject<RootObject>(json, new QueryEntryConverter());

    public override string ToString()
    {
        if (IsGroup)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append('(');
            foreach (QueryEntry entry in Group)
            {
                sb.Append(entry.ToString());
            }
            sb.Append(')');
            return sb.ToString();
        }
        else if (Type == "expression")
        {
            return Key + ' ' + Operators + ' ' + Value;
        }
        else if (Type == "conjunction")
        {
            return ' ' + Value + ' ';
        }
        return string.Empty;
    }

Console.WriteLine(root.QueryEntry.ToString());