C# 将数据行放入具有子对象和子对象的对象中_C#_Linq

C# 将数据行放入具有子对象和子对象的对象中

c# linq

C# 将数据行放入具有子对象和子对象的对象中,c#,linq,C#,Linq,我有以下表格中的一些数据： +---------+---------+--------------+---------------------+ | Group 1 | Child 1 | Grandchild 1 | Greatgrandchild 1 | | Group 1 | Child 1 | Grandchild 1 | Greatgrandchild 2 | | Group 1 | Child 1 | Grandchild 2 | Greatgrandchild 3 | | G

我有以下表格中的一些数据：

+---------+---------+--------------+---------------------+
| Group 1 | Child 1 | Grandchild 1 | Greatgrandchild 1  |
| Group 1 | Child 1 | Grandchild 1 | Greatgrandchild 2  |
| Group 1 | Child 1 | Grandchild 2 | Greatgrandchild 3  |
| Group 1 | Child 1 | Grandchild 2 | Greatgrandchild 4  |
| Group 1 | Child 2 | Grandchild 3 | Greatgrandchild 5  |
| Group 1 | Child 2 | Grandchild 3 | Greatgrandchild 6  |
| Group 1 | Child 2 | Grandchild 3 | Greatgrandchild 7  |
| Group 1 | Child 2 | Grandchild 4 | Greatgrandchild 8  |
| Group 1 | Child 2 | Grandchild 4 | Greatgrandchild 9  |
| Group 2 | Child 3 | Grandchild 5 | Greatgrandchild 10 |
| Group 2 | Child 3 | Grandchild 5 | Greatgrandchild 11 |
| Group 2 | Child 3 | Grandchild 6 | Greatgrandchild 12 |
| Group 2 | Child 3 | Grandchild 6 | Greatgrandchild 13 |
| Group 2 | Child 4 | Grandchild 7 | Greatgrandchild 14 |
| Group 2 | Child 4 | Grandchild 7 | Greatgrandchild 15 |
| Group 2 | Child 4 | Grandchild 8 | Greatgrandchild 16 |
| Group 2 | Child 4 | Grandchild 8 | Greatgrandchild 17 |
| Group 2 | Child 4 | Grandchild 8 | Greatgrandchild 18 |
+---------+---------+--------------+---------------------+

我希望它能将这些数据转换成有孩子的POCO：

+-List<Group>
  +-List<Child>
    +-List<Grandchild>
      +-List<Greatgrandchild>

我正在使用MVC，我想我可以使用LINQ来实现这一点

我可以通过一些分组来强行实现这一点：

        var sb = new StringBuilder();

        foreach (var courses in query.GroupBy(c => c.courseInfo))
        {
            foreach (var course in courses)
            {
                sb.AppendLine(course.courseInfo);

                foreach (var semesters in courses.Where(c => c == course).GroupBy(s => s.semester_name))
                {
                    foreach (var semester in semesters)
                    {
                        sb.AppendLine(semester.semester_name);

                        foreach (var quizzes in semesters.Where(s => s == semester).GroupBy(q => q.quiz_name))
                        {
                            foreach (var quiz in quizzes)
                            {
                                sb.AppendLine(quiz.quiz_name);

                                foreach (var student in quizzes.Where(q => q == quiz))
                                {
                                    sb.AppendLine(student.last_name);
                                }
                            }
                        }
                    }
                }
            }
        }

        var results = sb.ToString();

我可以使用上面的代码构建一个字符串，也可以构建我的类，但这显然不是一个“好”的方法。

这会让你接近：

var data = new List<Data>()
{
new Data(){Group="1", Child="1", Grandchild="1", Greatgrandchild="1"},
new Data(){Group="1", Child="1", Grandchild="1", Greatgrandchild="2"},
new Data(){Group="1", Child="1", Grandchild="2", Greatgrandchild="3"},
new Data(){Group="1", Child="1", Grandchild="2", Greatgrandchild="4"},
new Data(){Group="1", Child="2", Grandchild="3", Greatgrandchild="5"},
new Data(){Group="1", Child="2", Grandchild="3", Greatgrandchild="6"},
new Data(){Group="1", Child="2", Grandchild="4", Greatgrandchild="7"},
new Data(){Group="1", Child="2", Grandchild="4", Greatgrandchild="8"},
new Data(){Group="1", Child="2", Grandchild="5", Greatgrandchild="9"},
new Data(){Group="2", Child="3", Grandchild="5", Greatgrandchild="10"},
new Data(){Group="2", Child="3", Grandchild="6", Greatgrandchild="11"},
new Data(){Group="2", Child="3", Grandchild="6", Greatgrandchild="12"},
new Data(){Group="2", Child="3", Grandchild="7", Greatgrandchild="13"},
new Data(){Group="2", Child="4", Grandchild="7", Greatgrandchild="14"},
new Data(){Group="2", Child="4", Grandchild="8", Greatgrandchild="15"},
new Data(){Group="2", Child="4", Grandchild="8", Greatgrandchild="16"},
new Data(){Group="2", Child="4", Grandchild="9", Greatgrandchild="17"},
new Data(){Group="2", Child="4", Grandchild="9", Greatgrandchild="18"},
};

var result = data.GroupBy(d => d.Group).Select(d => new
{
    Group = d.Key,
    Childs = d.GroupBy(d2 => d2.Child).Select(d2 => new
    {
        Group = d2.Key,
        GrandChilds = d2.GroupBy(d3 => d3.Grandchild).Select(d3 => new
        {
            Group = d3.Key,
            GreatGrandchilds = d3.Select(d4 => d4.Greatgrandchild)
        })
    })
});

var数据=新列表（）
{
新数据（）{Group=“1”，Child=“1”，granten=“1”，greatgranten=“1”}，
新数据（）{Group=“1”、Child=“1”、granten=“1”、greatgranten=“2”}，
新数据（）{Group=“1”、Child=“1”、granten=“2”、greatgranten=“3”}，
新数据（）{Group=“1”，Child=“1”，granten=“2”，greatgranten=“4”}，
新数据（）{Group=“1”，Child=“2”，granten=“3”，greatgranten=“5”}，
新数据（）{Group=“1”，Child=“2”，granten=“3”，greatgranten=“6”}，
新数据（）{Group=“1”，Child=“2”，granten=“4”，greatgranten=“7”}，
新数据（）{Group=“1”，Child=“2”，granten=“4”，greatgranten=“8”}，
新数据（）{Group=“1”，Child=“2”，granten=“5”，greatgranten=“9”}，
新数据（）{Group=“2”、Child=“3”、granten=“5”、greatgranten=“10”}，
新数据（）{Group=“2”、Child=“3”、granten=“6”、greatgranten=“11”}，
新数据（）{Group=“2”、Child=“3”、granten=“6”、greatgranten=“12”}，
新数据（）{Group=“2”、Child=“3”、granten=“7”、greatgranten=“13”}，
新数据（）{Group=“2”、Child=“4”、granten=“7”、greatgranten=“14”}，
新数据（）{Group=“2”、Child=“4”、granten=“8”、greatgranten=“15”}，
新数据（）{Group=“2”，Child=“4”，granten=“8”，greatgranten=“16”}，
新数据（）{Group=“2”、Child=“4”、granten=“9”、greatgranten=“17”}，
新数据（）{Group=“2”、Child=“4”、granten=“9”、greatgranten=“18”}，
};
var result=data.GroupBy（d=>d.Group）。选择（d=>new
{
组=d.键，
Childs=d.GroupBy（d2=>d2.Child）。选择（d2=>new
{
组=d2.键，
孙子=d2.GroupBy（d3=>d3.孙子）。选择（d3=>new
{
组=d3.键，
曾孙=d3.选择（d4=>d4.曾孙）
})
})
});

在LINQPad中运行会产生这种结构（我只扩展了其中一行，以便图像适合）：

要完全到达您想要的位置，您需要创建类来表示每个“生成”，并返回该类的实例，而不是像我的示例那样返回新的匿名类型。

这将使您接近：

var data = new List<Data>()
{
new Data(){Group="1", Child="1", Grandchild="1", Greatgrandchild="1"},
new Data(){Group="1", Child="1", Grandchild="1", Greatgrandchild="2"},
new Data(){Group="1", Child="1", Grandchild="2", Greatgrandchild="3"},
new Data(){Group="1", Child="1", Grandchild="2", Greatgrandchild="4"},
new Data(){Group="1", Child="2", Grandchild="3", Greatgrandchild="5"},
new Data(){Group="1", Child="2", Grandchild="3", Greatgrandchild="6"},
new Data(){Group="1", Child="2", Grandchild="4", Greatgrandchild="7"},
new Data(){Group="1", Child="2", Grandchild="4", Greatgrandchild="8"},
new Data(){Group="1", Child="2", Grandchild="5", Greatgrandchild="9"},
new Data(){Group="2", Child="3", Grandchild="5", Greatgrandchild="10"},
new Data(){Group="2", Child="3", Grandchild="6", Greatgrandchild="11"},
new Data(){Group="2", Child="3", Grandchild="6", Greatgrandchild="12"},
new Data(){Group="2", Child="3", Grandchild="7", Greatgrandchild="13"},
new Data(){Group="2", Child="4", Grandchild="7", Greatgrandchild="14"},
new Data(){Group="2", Child="4", Grandchild="8", Greatgrandchild="15"},
new Data(){Group="2", Child="4", Grandchild="8", Greatgrandchild="16"},
new Data(){Group="2", Child="4", Grandchild="9", Greatgrandchild="17"},
new Data(){Group="2", Child="4", Grandchild="9", Greatgrandchild="18"},
};

var result = data.GroupBy(d => d.Group).Select(d => new
{
    Group = d.Key,
    Childs = d.GroupBy(d2 => d2.Child).Select(d2 => new
    {
        Group = d2.Key,
        GrandChilds = d2.GroupBy(d3 => d3.Grandchild).Select(d3 => new
        {
            Group = d3.Key,
            GreatGrandchilds = d3.Select(d4 => d4.Greatgrandchild)
        })
    })
});

var数据=新列表（）
{
新数据（）{Group=“1”，Child=“1”，granten=“1”，greatgranten=“1”}，
新数据（）{Group=“1”、Child=“1”、granten=“1”、greatgranten=“2”}，
新数据（）{Group=“1”、Child=“1”、granten=“2”、greatgranten=“3”}，
新数据（）{Group=“1”，Child=“1”，granten=“2”，greatgranten=“4”}，
新数据（）{Group=“1”，Child=“2”，granten=“3”，greatgranten=“5”}，
新数据（）{Group=“1”，Child=“2”，granten=“3”，greatgranten=“6”}，
新数据（）{Group=“1”，Child=“2”，granten=“4”，greatgranten=“7”}，
新数据（）{Group=“1”，Child=“2”，granten=“4”，greatgranten=“8”}，
新数据（）{Group=“1”，Child=“2”，granten=“5”，greatgranten=“9”}，
新数据（）{Group=“2”、Child=“3”、granten=“5”、greatgranten=“10”}，
新数据（）{Group=“2”、Child=“3”、granten=“6”、greatgranten=“11”}，
新数据（）{Group=“2”、Child=“3”、granten=“6”、greatgranten=“12”}，
新数据（）{Group=“2”、Child=“3”、granten=“7”、greatgranten=“13”}，
新数据（）{Group=“2”、Child=“4”、granten=“7”、greatgranten=“14”}，
新数据（）{Group=“2”、Child=“4”、granten=“8”、greatgranten=“15”}，
新数据（）{Group=“2”，Child=“4”，granten=“8”，greatgranten=“16”}，
新数据（）{Group=“2”、Child=“4”、granten=“9”、greatgranten=“17”}，
新数据（）{Group=“2”、Child=“4”、granten=“9”、greatgranten=“18”}，
};
var result=data.GroupBy（d=>d.Group）。选择（d=>new
{
组=d.键，
Childs=d.GroupBy（d2=>d2.Child）。选择（d2=>new
{
组=d2.键，
孙子=d2.GroupBy（d3=>d3.孙子）。选择（d3=>new
{
组=d3.键，
曾孙=d3.选择（d4=>d4.曾孙）
})
})
});

在LINQPad中运行会产生这种结构（我只扩展了其中一行，以便图像适合）：

要完全达到目的，您需要创建类来表示每个“生成”，并返回该类的实例，而不是像我的示例那样返回新的匿名类型。

我也这么认为。也许你可以尝试一下，然后我们可以帮助你解决尝试后可能遇到的问题。例如，LINQ的一个扩展方法可能会有所帮助。@MikeMcCaughan我和GroupBy some一起玩过，它变成了一个有很多foreach循环的怪物。如果你“玩过”东西，你应该展示这些尝试。否则，你可能会收到一些你认为是“有点怪兽”的答案，但其他人却不这么认为。我也这么认为。也许你可以尝试一下，然后我们可以帮助你解决尝试后可能遇到的问题。例如，LINQ的一个扩展方法可能会有所帮助。@MikeMcCaughan我和GroupBy some一起玩过，它变成了一个有很多foreach循环的怪物。如果你“玩过”东西，你应该展示这些尝试。否则，你可能会收到一些你认为“有点怪兽”的答案，但其他人却不这么认为。