Question

我有一个名为Person的类，有2个属性Age和Name

我试图将人们分为3个不同的年龄组。

我希望我的最终结果是这样的：

YoungGroup (<20 y old):
    Person1Name, Age
    Person4Name, Age
    Person3Name, Age
AdultGroup (20> y <40 old):
    Person2Name, Age
    Person7Name, Age
    Person5Name, Age
SeniorGroup (40> y old):
    Person6Name, Age
    Person8Name, Age
    Person9Name, Age

我想只使用group子句（没有连接，如果它甚至可能吗？）

这就是我试过的

var multiplegrps = from p in people
                   group p by p.Age into groups
                   let age = groups.Key
                   select new
                   {
                       YoungGroup = from p in groups
                                    where age <= 20
                                    group p by p.Age,
                       AdultGroup = from p in groups
                                    where age >= 21 && age <= 40
                                    group p by p.Age,
                      SeniorGroup = from p in groups
                                    where age >= 41
                                    group p by p.Age
                   };

要么它有效，要么我实际上不知道如何打印它：

foreach (var item in multiplegrps)
{
    foreach (var i in item.YoungGroup)
    {
        Console.WriteLine($"{i.Key}");
    }
}

我确实得到了正确的密钥，但我无法访问这些名称，而且我必须为每个组编写3个内部foreach

P.S。我想用纯查询来做，没有lambdas没有新的扩展方法

P.S。我解决了它并从@khoroshevj得到了关于使用多个三元运算符的想法，它很简单：

        var peopleMultiGrouping = from p in people
                                  let ageSelection =
                                        p.Age < 20
                                            ? "Young" 
                                            : p.Age >= 20 && p.Age <= 40
                                                ? "Adult" 
                                                : "Senior"
                                  group p by ageSelection;

        foreach (var p in peopleMultiGrouping)
        {
            Console.WriteLine($"{p.Key}");
            foreach (var i in p)
            {
                Console.WriteLine($" {i.Age}");
            }
        }

Answer 1

你可以做这样的事情

dangerouslySetInnerHTML

Answer 2

你有没有试过像：

var multiplegrps = people.GroupBy(x=> x.age)
                         .ToDictionary(x=>x.Key,
                                       x=>x.Select(y=>new {  
                                                 YoungGroup=y.where(z=>z.age<= 20), 
                                                 AdultGroup=y.Where(z=>z.age >=21 && a.age <= 40), 
                                                SeniorGroup=y.Where(z=> z.age >=41) 
                                                          });

这只是一个想法，没试过......

Answer 3

您的解决方案确实按预期工作。问题在于您打印结果的方式。

在第二级循环中，i的类型为IGrouping<int, Person>，它基本上代表具有公共密钥的对象集合。

它显然具有Key属性，因为您正在访问它，但它没有Value属性。

您可以执行另一个嵌套循环来迭代IGrouping，然后您就可以访问完整的Person属性，或者如果您只想将其保留为两个 - 然后，您可以将item.YoungGroup与SelectMany展平为IEnumerable<Person>，然后像这样迭代它：

foreach (var item in multiplegrps)
{
       foreach (var person in item.YoungGroup.SelectMany(x => x))
       {
            Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
       }
}

Answer 4

?_escaped_fragment_=

Answer 5

我解决了它并从@khoroshevj得到了关于使用多个三元运算符的想法，它很简单：

        var peopleMultiGrouping = from p in people
                                  let ageSelection =
                                        p.Age < 20
                                        ? "Young" 
                                        : p.Age >= 20 && p.Age <= 40
                                            ? "Adult" 
                                            : "Senior"
                                  group p by ageSelection;

        foreach (var p in peopleMultiGrouping)
        {
            Console.WriteLine($"{p.Key}");
            foreach (var i in p)
            {
                Console.WriteLine($" {i.Age}");
            }
        }

C＃Linq Query - 从集合中提取多个组（嵌套组？）

5 个答案: