Question

from x in myCollection
    group x by x.Id into y
    select new { 
       Id = y.Key, 
       Quantity = y.Sum(x => x.Quantity)
    };

你如何将上述内容写成lambda表达式？我被困在group into部分。

Answer 1

查询延续（选择... into和group ... into，但 not join ... into）等同于仅拆分查询表达式。所以我想把你的例子想象成：

var tmp = from x in myCollection
          group x by x.Id;
var result = from y in tmp
             select new { 
               Id = y.Key, 
               Quantity = y.Sum(x => x.Quantity)
             };

将这些更改为点表示法：

var tmp = myCollection.GroupBy(x => x.Id);
var result = tmp.Select(y => new { 
               Id = y.Key, 
               Quantity = y.Sum(x => x.Quantity)
             });

然后你可以将它们组合起来：

var tmp = myCollection.GroupBy(x => x.Id)
                      .Select(y => new { 
                                Id = y.Key, 
                                Quantity = y.Sum(x => x.Quantity)
                              });

一旦你弄清楚C＃编译器对查询表达式的作用，剩下的就相对简单了：）

Answer 2

myCollection.GroupBy(x => x.Id)
            .Select(y => new {
                                 Id = y.Key,
                                 Quantity = y.Sum(x => x.Quantity)
                             });

Answer 3

myCollection
    .GroupBy(x => x.Id)
    .Select(x => 
        new 
        { 
          Id = x.Key, 
          Quantity = x.Sum(y => x.Quantity
        });

Answer 4

        var mostFrequent =
            lstIn.Where(i => !string.IsNullOrEmpty(i))
                 .GroupBy(s => s)
                 .OrderByDescending(g => g.Count())
                 .Select(s => s.Key)
                 .FirstOrDefault();

Answer 5

所以，对于这里的大部分答案，每个人似乎都在处理从组的计数中获取Id的简单对象，以及Key本身的group.Key。

虽然这可能是这个的主要用途。没有真正满足我的需求。

对于我自己的情况，我基本上想要通过一些对象属性进行分组，然后从该组中获取特定对象。这是一个示例代码。

using System;
using System.Collections.Generic;
using System.Linq;

public class Program
{
    public static void Main()
    {
        Console.WriteLine("Hello World");
        var response = new List<ResponseClass>();
            var listOfStudents = new List<Student>();
            // Insert some objects into listOfStudents object.
            listOfStudents.GroupBy(g => g.Class).ToList()
                .ForEach(g => response.Add(g.OrderByDescending(s => s.CreatedOn).Select(a =>
                new ResponseClass
                {
                    SName = a.StudentName,
                    SAge = a.Age,
                    SClass = a.Class,
                    SCreatedOn = a.CreatedOn,
                    RandomProperty = Guid.NewGuid().ToString()
                })
                .First()));

                Console.WriteLine("This compiles and should work just fine");
    }
    class Student
    {
        public string StudentName { get; set; }
        public int Age { get; set; }
        public string Class { get; set; }
        public DateTime CreatedOn { get; set; }
    }

    class ResponseClass
    {
        public string SName { get; set; }
        public int SAge { get; set; }
        public string SClass { get; set; }
        public DateTime SCreatedOn { get; set; }
        public string RandomProperty { get; set; }
    }
}

如果您更愿意使用foreach循环（我更喜欢lambda，因为我觉得它更容易阅读），但如果你这样做，你可以这样做。

foreach (IGrouping<string, Student> groupedStudents in listOfStudents.GroupBy(g => g.Class))
            {
                response.Add(groupedStudents.OrderByDescending(x => x.CreatedOn).Select(a =>
                new ResponseClass
                {
                    SName = a.StudentName,
                    SAge = a.Age,
                    SClass = a.Class,
                    SCreatedOn = a.CreatedOn,
                    RandomProperty = Guid.NewGuid().ToString()
                }).First());
            }

希望这有助于某人。：）

LambB表达式中的GroupBy

5 个答案: