自定义排序 Dictionary<string, JToken> 使用 LINQ 向下遍历

Question

我目前将Dictionary<string, JToken> item 定义为对象类。这不是根对象，而是第二级。

public class Root
{
    public string name { get; set; }
    public string description { get; set; }
    public Table Table {get; set; }

}
public class Table
{
    public Name name { get; set; }
    [JsonExtensionData]
    public Dictionary<string, JToken> item { get; set; }

}

有了这个，我希望在这个类中反序列化和排序传入的 json。目前所有的 json 对象都是无序的。我希望使用每个对象中的属性来创建订单。

请查看 JSON 结构：

 {
        'name': 'Customer Table',
        'Table': {
            'name': {
                'id': 'name',
                'type': 'info'
                'description': 'Customer table info'
            },
            'RowId-123': {
                'id': 'RowId-123',
                'type': 'Row',
                'children': [
                    'ColumnId-367'
                ],
                'index': 1,
                'parentId': 'custom'
            },
            'ColumnId-367': {
                'id': 'ColumnId-367',
                'type': 'Column',
                'children': [],
                'parentId': 'RowId-123'
            },
            'RowId-476': {
                'id': 'RowId-476',
                'type': 'Row'
                'components': [
                    'ColumnId-317',
                    'ColumnId-327'
                ],
                'index': 2,
                'parentId': 'custom'
            },
            'ColumnId-317': {
                'id': 'ColumnId-317',
                'type': 'Column'
                'components': [],
                'index': 0,
                'parentId': 'RowId-476'
            },
            'ColumnId-327': {
                'id': 'ColumnId-327',
                'type': 'Column',
                'components': [],
                'index': 1,
                'parentId': 'RowId-476'
            },
            'TextContent12': {
                'id': 'TextContent12',
                'type': 'Text',
                'index': 0,
                'parentId': 'custom'
            }
        }
    }

我在下面有 Linq 查询。

           //Get all objects that has parent custom top level layer.
            var top = root.Table.item.Values
            .Where(x => x["parentId"].Value<string>() == "custom")
            .OrderBy(i => i["index"]);

            //Only looks at Index 0 and Row type.
            var row = root.Table.item.Values
            .FirstOrDefault(x => x["type"].Value<string>() == "Row" && x["index"].Value<int>() == 0);

            //Get children column of row.
            var column = root.Table.item.Values
            .Where(x => x["parentId"]?.Value<string>() == row["id"].Value<string>())
            .OrderBy(i => i["index"]);

我正在努力组合我的 linq 查询以循环遍历索引并获得我想要的输出。如何将查询组合在一起，这将根据不在行或行对象内的 Item 的最大值增加索引以产生以下输出。

Index 0 Content:
'TextContent12': {
                'id': 'TextContent12',
                'type': 'Text',
                'index': 0,
                'parentId': 'custom'
            }


Index 1 Content:
 'RowId-123': {
                'id': 'RowId-123',
                'type': 'Row',
                'children': [
                    'ColumnId-367'
                ],
                'index': 1,
                'parentId': 'custom'
            },
            'ColumnId-367': {
                'id': 'ColumnId-367',
                'type': 'Column',
                'children': [],
                'parentId': 'RowId-123'
            }

Index 2 Content:

'RowId-476': {
                'id': 'RowId-476',
                'type': 'Row'
                'components': [
                    'ColumnId-317',
                    'ColumnId-327'
                ],
                'index': 2,
                'parentId': 'custom'
            },
            'ColumnId-317': {
                'id': 'ColumnId-317',
                'type': 'Column'
                'components': [],
                'index': 0,
                'parentId': 'RowId-476'
            },
            'ColumnId-327': {
                'id': 'ColumnId-327',
                'type': 'Column',
                'components': [],
                'index': 1,
                'parentId': 'RowId-476'
            }

Answer 1

您实际上并不需要知道最大索引来循环遍历项目。您已经使用OrderBy 来确保它们按索引排列。所以你只需要在每个级别都有一个foreach 循环。如果想知道当前项在循环体内的索引是多少，可以使用item["index"]获取，如下图：

我认为这就是你要找的东西：

// Get all objects at the top level (parentId is "custom") ordered by index
var top = root.Table.item.Values
    .Where(x => x["parentId"].Value<string>() == "custom")
    .OrderBy(i => i["index"]);

// Loop through top level items 
foreach (JToken item in top)
{
    Console.WriteLine("Index " + item["index"] + " Content:");
    Console.WriteLine(item.ToString());  // output item JSON - could be Row or something else 

    // Check whether the current item is a Row
    if (item["type"].Value<string>() == "Row")
    {
        // If so, get all items which have this row as a parent ordered by index
        var children = root.Table.item.Values
            .Where(x => x["parentId"].Value<string>() == item["id"].Value<string>())
            .OrderBy(i => i["index"]);

        // loop through the child items
        foreach (JToken child in children)
        {
            Console.WriteLine(child.ToString());  // output child JSON
        }
    }

    Console.WriteLine();
}

小提琴：https://dotnetfiddle.net/Rvs675

顺便说一句，您的 JSON 存在一些不一致之处，我不确定这些是否是预期的，或者您是否手动编辑 JSON 并因此引入错误（似乎很可能）。例如：

• ColumnId-367 没有 index 值，而所有其他项目都有。由于我们试图通过index 进行排序，这引发了一些关于索引丢失时应该发生什么的问题。如果这是真的可能，您可能需要对代码进行一些调整以解决此问题。
• RowId-123 有一个 children 数组，而 RowId-476 有一个 components 数组。出于这个问题的目的，这似乎并不重要，因为我们使用ParentId 来关联这些项目。但这仍然让我想知道哪个是正确的，以及这是否会导致以后出现问题。
• 整个 JSON 中的各种属性之间缺少逗号分隔符，这将导致无法正确解析。

记住，“garbage in, garbage out”。