C# 在多个交互中选择

我正在尝试构建此对象：

[
    {
        "color" : "red",
        "category" : "tshirts",
        "Items" : [
            {
                "r" : 1,
                "n" : "name: E624E",
                "s" : 9819217.000
            }, {
                "r" : 2,
                "n" : "name: 00F37",
                "s" : 9791564.000
            }, {
                "r" : 3,
                "n" : "name: 75B02",
                "s" : 9790543.000
            }, {
                "r" : 4,
                "n" : "name: 08864",
                "s" : 9485392.000
            }
        ]
    }, 
    {
        "color" : "red",
        "category" : "shoes",
        "Items" : [
            {
                "r" : 1,
                "n" : "name: 20272",
                "s" : 9949541.000
            }, {
                "r" : 2,
                "n" : "name: 1E496",
                "s" : 9926730.000
            }, {
                "r" : 3,
                "n" : "name: 00F37",
                "s" : 9926493.000
            }, {
                "r" : 4,
                "n" : "name: 48A44",
                "s" : 9923929.000
            }
        ]
    }
]

我构建它的方式是使用Linq，迭代颜色和类别的集合：

var colors = ctx.Colors.Select(x => x.Color).Distinct().ToList();

foreach (var color in colors)
{
    var categories = ctx.Categories.Where(x => x.Color == color).Select(x => x.Category).Distinct().ToList();

    foreach (var cat in categories)
    {
        List<ItemAttribute> iattr = (from i in ctx.Item
                                     where i.Color == color && i.Category == cat
                                     select new ItemAttribute { 
                                          r = i.R,
                                          n = i.N,
                                          s = i.S
                                      }).ToList();
        this.ItemStuff.Add(iattr);
    }
}

var colors=ctx.colors.Select（x=>x.Color.Distinct（）.ToList（）；
foreach（颜色中的颜色变量）
{
var categories=ctx.categories.Where（x=>x.Color==Color）.Select（x=>x.Category.Distinct（）.ToList（）；
foreach（类别中的var cat）
{
列出iattr=（从ctx.Item中的i开始）
其中i.Color==颜色和i.Category==类别
选择新项目属性{
r=i.r，
n=i.n，
s=i.s
}).ToList（）；
this.ItemStuff.Add（iattr）；
}
}

这是可行的，我得到了期望的结果，但是性能很糟糕，而且看起来很冗长

---

有人能提供一些关于改进这方面的见解吗？

也许您正在寻找这样的东西：

var results = 
    from i in ctx.Items
    group i by new { i.Color, i.Category } into g
    select new ItemGroup
    {
        color = g.Key.Color,
        category = g.Key.Category
        items =
            (from i in g 
             select new ItemAttribute
             { 
                 r = i.R,
                 n = i.N,
                 s = i.S
             })
            .ToArray()
    };

或使用流利的语法：

var results = ctx.Items
    .GroupBy(i => new { i.Color, i.Category })
    .Select(g => new ItemGroup
    {
        color = g.Key.Color,
        category = g.Key.Category
        items = g.Select(i => new ItemAttribute
                { 
                    r = i.R,
                    n = i.N,
                    s = i.S
                })
                .ToArray()
    };

---

也许你在寻找这样的东西：

var results = 
    from i in ctx.Items
    group i by new { i.Color, i.Category } into g
    select new ItemGroup
    {
        color = g.Key.Color,
        category = g.Key.Category
        items =
            (from i in g 
             select new ItemAttribute
             { 
                 r = i.R,
                 n = i.N,
                 s = i.S
             })
            .ToArray()
    };

或使用流利的语法：

var results = ctx.Items
    .GroupBy(i => new { i.Color, i.Category })
    .Select(g => new ItemGroup
    {
        color = g.Key.Color,
        category = g.Key.Category
        items = g.Select(i => new ItemAttribute
                { 
                    r = i.R,
                    n = i.N,
                    s = i.S
                })
                .ToArray()
    };

---

您的代码在多个地方遵循相同的次优模式：您一次只处理一种颜色或一个类别，而不是按颜色或类别进行分组。当您迭代

颜色时，在外部循环中执行此操作，然后当您迭代
类别时，在嵌套循环中执行相同操作

这会多次转到
ctx
，每次都有一个单独的查询。除了极少数例外，在循环中查询肯定会降低性能。最好是获取所有内容，按颜色/类别分组，然后按照需要的方式生成结果

以下是一种方法：

var items = ctx.Item.Select(i => new ItemAttribute { 
    r = i.R
,   n = i.N
,   s = i.S
})
.GroupBy(i => new { i.Color, i.Category })
.OrderBy(p => p.Key.Color)
.ThenBy(p => p.Key.Category);

此时，您将拥有按颜色和类别分组的所有项目组，这些项目在单个查询中检索。现在剩下的是迭代组，并将数据添加到您正在填充的结构中。
您的代码在多个地方遵循相同的次优模式：您一次只处理一种颜色或一个类别，而不是按颜色或类别对所有内容进行分组。当您迭代
颜色时，在外部循环中执行此操作，然后当您迭代
类别时，在嵌套循环中执行相同操作

这会多次转到
ctx
，每次都有一个单独的查询。除了极少数例外，在循环中查询肯定会降低性能。最好是获取所有内容，按颜色/类别分组，然后按照需要的方式生成结果

以下是一种方法：

var items = ctx.Item.Select(i => new ItemAttribute { 
    r = i.R
,   n = i.N
,   s = i.S
})
.GroupBy(i => new { i.Color, i.Category })
.OrderBy(p => p.Key.Color)
.ThenBy(p => p.Key.Category);

此时，您将拥有按颜色和类别分组的所有项目组，这些项目在单个查询中检索。现在剩下的是迭代组，并将数据添加到正在填充的结构中。
这是LINQ到实体，不是吗？您的示例代码没有太多意义。您正在从
类别
中选择
颜色
？另外，结果将类似于一个
列表
。请向我们展示更多的真实代码。啊……你说得对，我简化了代码并重命名了实体，只是更新了它……它是LINQ to entities，不是吗？你的示例代码没有太多意义。您正在从
类别
中选择
颜色
？另外，结果将类似于一个
列表
。请向我们展示更多的真实代码。啊……你说得对，我简化了代码并重命名了实体，刚刚更新了它……明白了，我知道性能会因为单独的查询而变得糟糕，使用完整的集合是解决方法，但只是不知道怎么做。但现在我要感谢你的帮助。非常感谢。我知道，由于单独的查询，性能很差，使用完整的查询集是解决问题的办法，但我不知道如何解决。但现在我要感谢你的帮助。非常感谢。