multiple - groupby() c#

GroupBy en expresiones lambda

Question

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

¿Cómo escribirías lo anterior como una expresión lambda? Estoy atrapado en el group into parte.

Answer 1

Entonces, para la mayoría de las respuestas aquí, todo el mundo parece estar tratando de obtener un objeto simple de Id hecho a partir del conteo del grupo, y la clave en sí que es group.Key.

Aunque ese es probablemente el principal uso de esto. Realmente no satisfacía mis necesidades.

Para mi propio caso, básicamente quería agrupar por alguna propiedad de objeto y luego obtener un objeto específico de ese grupo. Aquí hay un código de ejemplo.

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; }
    }
}

Si prefieres usar un bucle foreach (prefiero lambda porque me resulta más fácil de leer), pero si lo haces, podrías hacerlo así.

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());
            }

Espero que esto ayude a alguien. :)

Answer 2

Las continuaciones de consultas (seleccionar ... en y agrupar ... en, pero no unir ... en) son equivalentes a simplemente dividir la expresión de consulta. Así que me gusta pensar en tu ejemplo como:

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)
             };

Cambia esos a notación de puntos:

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

Entonces podrías combinarlos de nuevo:

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

Una vez que descubras lo que hace el compilador de C # con las expresiones de consulta, el resto es relativamente sencillo :)

Answer 3

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

Answer 4

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

Answer 5

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