Cláusula GroupBy

Contenido del curso

Introducción

Configuración de proyecto

Operadores básicos

Operadores de agregación

Agrupamiento de datos

Cierre de curso

26
Recapitulación sobre LINQ
03:20 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:007:33

Cláusula GroupBy

Curso de Manejo de Datos en C# con LINQ

Clase 22 de 26

Clase 22 / 26

Comentarios (10)10 comentarios

Jimmy Alexander Soza Ortiz

Hace 4 años

Función usada para imprimir los agrupamientos por año

void ImprimirGrupo(IEnumerable<IGrouping<int,Book>> ListadeLibros)
{
    foreach(var grupo in ListadeLibros)
    {
        Console.WriteLine("");
        Console.WriteLine($"Grupo: { grupo.Key }");
        Console.WriteLine("{0,-60} {1, 15} {2, 15}\n", "Titulo", "N. Paginas", "Fecha publicacion");
        foreach(var item in grupo)
        {
            Console.WriteLine("{0,-60} {1, 15} {2, 15}",item.Title,item.PageCount,item.PublishedDate.Date.ToShortDateString()); 
        }
    }
}

Miguel Angel Reyes Moreno

Hace 3 años

Jimmy Buriticá Londoño

Hace 4 años

Cláusula GroupBy

Permite agrupar los datos por una propiedad.

Luca Cristian Manea

Hace 4 años

Query public IEnumerable<IGrouping<int,Book>>booksAfter2000GroupByYearQuery(IEnumerable<Book>books){ return from b in books where b.PublishedDate.Year>=2000 group b by b.PublishedDate.Year; }

Jerry Lee Minotta Rebellón

Hace 3 años

Se puede modificar la función imprimirValores() que hemos estado usando para imprimir la lista de libros, para que reciba: un libro, una lista de libros o una lista de listas de libros (es lo que devuelve el groupBy):


void printValues(IEnumerable<Book> listBooks, Book aBook, IEnumerable<IGrouping<int, Book>> ListBooksGrouped)
{
    Console.WriteLine("{0,-60} {1,15} {2,15}\n", "Titulo", "N paginas", "Fecha Publicacion");
    if (listBooks != null)
    {
        BookListPrint(listBooks);
    }
    else if (aBook != null)
    {
        Console.WriteLine("{0,-60} {1,15} {2,15}", aBook.Title, aBook.PageCount, aBook.PublishedDate.ToShortDateString());
    }
    else if (ListBooksGrouped != null)
    {
        foreach (var group in ListBooksGrouped)
        {
            Console.WriteLine("\n Grupo: " + group.Key);
            BookListPrint(group);
        }
    }
}

Agregamos la funcion BookListPrint() para reutilizar algunas lineas de código que se repiten:

void BookListPrint(IEnumerable<Book> listBooks)
{
    foreach (Book book in listBooks)
    {
        Console.WriteLine("{0,-60} {1,15} {2,15}", book.Title, book.PageCount, book.PublishedDate.ToShortDateString());
    }
}

Y finalmente llamamos la función pasando los(el) elementos que necesitamos y los demás en null:

printValues(null, null, queries.AllBooksSince2000GruopByYear());

Miguel Angel Reyes Moreno

Hace 3 años

Podemos poner el año como parámetro:

public IEnumerable<IGrouping<int, Book>> LibrosAPartirDeAnioAgrupadosPorAnio(int anio)
        {
            return librosCollection.Where(book => book.PublishedDate.Year >= anio).OrderBy(book => book.PublishedDate).GroupBy(book => book.PublishedDate.Year);
        }

//* Libros publicados a partir del 2000 agrupados por año
        ImprimirGrupo(queries.LibrosAPartirDeAnioAgrupadosPorAnio(2000));

Joan Alexander Valerio Rodríguez

Hace 2 años

Les comparto mis ejercicios, también usando Query Expression:

//Extension Method
return BooksCollections
       .Where(p => p.PublishedDate.Year >= 2000)
       .GroupBy(p => p.PublishedDate.Year);
        
//Query Expression
var query = (from p in BooksCollections
             where p.PublishedDate.Year > 2000
             select p).GroupBy(p => p.PublishedDate.Year);
        
return query;

Diego Alejandro Muñoz Arcos

Hace 8 meses•editado

He ordenado los datos usando OrderBy

public IEnumerable<IGrouping<int, Book>> librosPublicadosDespues2000AgrupadosAno()
    {
        return booksCollection.Where(books => books.PublishedDate.Year > 2000).OrderBy(book => book.PublishedDate).GroupBy(book => book.PublishedDate.Year);
    }

Angel Qui

Hace 3 años

void ImprimirGrupo(IEnumerable<IGrouping<int, Book>> ListaDeLibros)
{
    foreach(var grupo in ListaDeLibros)
    {
        Console.WriteLine("");
        Console.WriteLine($"***************  Año: {grupo.Key}  ***************");
        Console.WriteLine("{0,-60} {1, 15} {2, 15}\n", "Título", "N. Páginas", "Fecha publicación");
        foreach(var item in grupo)
        {
            Console.WriteLine("{0,-60} {1, 15} {2, 15}", item.Title, item.PageCount, item.PublishedDate);
        }
    }
}

// retornar todos los libros que fueron publicados a partir del 2000
// agrupados por anio
public IEnumerable<IGrouping<int, Book>> LibrosDespuesDel2000AgrupadosPorAno()
{
    return librosCollection
        .Where(p => p.PublishedDate.Year >= 2000)
        .GroupBy(p => p.PublishedDate.Year);
}

Joel Angel David Barrantes Palacios

Hace 3 años

Esta seria una mejor manera de ordenar los datos de los grupos:

he usado ambas formas,

public IEnumerable<IGrouping<int,Book>> GetBooksPublishedAndGroupByYear(int year)
    {
        //extension method
        // return CollectionBook
        //         .Where(book => book.PublishedDate.Year >= year)
        //         .OrderBy(book => book.PublishedDate.Year)
        //         .ThenBy(book => book.PublishedDate.Month)
        //         .GroupBy(book => book.PublishedDate.Year);


        //linq query
        return from book in CollectionBook 
           where book.PublishedDate.Year >= year
           orderby book.PublishedDate.Year, book.PublishedDate.Month
           group book by book.PublishedDate.Year;
    }

Ricardo Mejía

Hace 4 años

//AGREGANDO UN FILTRO MAS NUMERO DE PÁGINAS public IEnumerable<IGrouping<int,Book>> LibrosAgrupadosPorAno(){

    return libros.Where(p=>p.PublishedDate.Year>200 && p.PageCount>=100).GroupBy(p=>p.PublishedDate.Year);
}

void ImprimirGrupo(IEnumerable<IGrouping<int,Book>> ListadeLibros)
{
    foreach(var grupo in ListadeLibros)
    {
        Console.WriteLine("");
        Console.WriteLine($"Grupo: { grupo.Key }");
        Console.WriteLine("{0,-60} {1, 15} {2, 15}\n", "Titulo", "N. Paginas", "Fecha publicacion");
        foreach(var item in grupo)
        {
            Console.WriteLine("{0,-60} {1, 15} {2, 15}",item.Title,item.PageCount,item.PublishedDate.Date.ToShortDateString()); 
        }
    }
}

void printValues(IEnumerable<Book> listBooks, Book aBook, IEnumerable<IGrouping<int, Book>> ListBooksGrouped)
{
    Console.WriteLine("{0,-60} {1,15} {2,15}\n", "Titulo", "N paginas", "Fecha Publicacion");
    if (listBooks != null)
    {
        BookListPrint(listBooks);
    }
    else if (aBook != null)
    {
        Console.WriteLine("{0,-60} {1,15} {2,15}", aBook.Title, aBook.PageCount, aBook.PublishedDate.ToShortDateString());
    }
    else if (ListBooksGrouped != null)
    {
        foreach (var group in ListBooksGrouped)
        {
            Console.WriteLine("\n Grupo: " + group.Key);
            BookListPrint(group);
        }
    }
}

void BookListPrint(IEnumerable<Book> listBooks)
{
    foreach (Book book in listBooks)
    {
        Console.WriteLine("{0,-60} {1,15} {2,15}", book.Title, book.PageCount, book.PublishedDate.ToShortDateString());
    }
}

public IEnumerable<IGrouping<int, Book>> LibrosAPartirDeAnioAgrupadosPorAnio(int anio)
        {
            return librosCollection.Where(book => book.PublishedDate.Year >= anio).OrderBy(book => book.PublishedDate).GroupBy(book => book.PublishedDate.Year);
        }

//Extension Method
return BooksCollections
       .Where(p => p.PublishedDate.Year >= 2000)
       .GroupBy(p => p.PublishedDate.Year);
        
//Query Expression
var query = (from p in BooksCollections
             where p.PublishedDate.Year > 2000
             select p).GroupBy(p => p.PublishedDate.Year);
        
return query;

public IEnumerable<IGrouping<int, Book>> librosPublicadosDespues2000AgrupadosAno()
    {
        return booksCollection.Where(books => books.PublishedDate.Year > 2000).OrderBy(book => book.PublishedDate).GroupBy(book => book.PublishedDate.Year);
    }

void ImprimirGrupo(IEnumerable<IGrouping<int, Book>> ListaDeLibros)
{
    foreach(var grupo in ListaDeLibros)
    {
        Console.WriteLine("");
        Console.WriteLine($"***************  Año: {grupo.Key}  ***************");
        Console.WriteLine("{0,-60} {1, 15} {2, 15}\n", "Título", "N. Páginas", "Fecha publicación");
        foreach(var item in grupo)
        {
            Console.WriteLine("{0,-60} {1, 15} {2, 15}", item.Title, item.PageCount, item.PublishedDate);
        }
    }
}

// retornar todos los libros que fueron publicados a partir del 2000
// agrupados por anio
public IEnumerable<IGrouping<int, Book>> LibrosDespuesDel2000AgrupadosPorAno()
{
    return librosCollection
        .Where(p => p.PublishedDate.Year >= 2000)
        .GroupBy(p => p.PublishedDate.Year);
}

public IEnumerable<IGrouping<int,Book>> GetBooksPublishedAndGroupByYear(int year)
    {
        //extension method
        // return CollectionBook
        //         .Where(book => book.PublishedDate.Year >= year)
        //         .OrderBy(book => book.PublishedDate.Year)
        //         .ThenBy(book => book.PublishedDate.Month)
        //         .GroupBy(book => book.PublishedDate.Year);


        //linq query
        return from book in CollectionBook 
           where book.PublishedDate.Year >= year
           orderby book.PublishedDate.Year, book.PublishedDate.Month
           group book by book.PublishedDate.Year;
    }

Introducción

Bienvenida al curso

Prerrequisitos

¿Qué es LINQ?

Programación declarativa vs. imperativa

Utilizando LINQ por primera vez

Configuración de proyecto

Creando el proyecto base

Configurando clases

Importando datos

Operadores básicos

Usando el operador Where

CLASE EN ACTUALIZACIÓN (sáltala y avanza a la siguiente)- Ejercicio para aplicar el operador Where

Operadores All y Any

Operador Contains

Operadores OrderBy y OrderByDescending

CLASE EN ACTUALIZACIÓN (sáltala y avanza a la siguiente)- Ejercicio operador OrderBy

Operadores Take y Skip

Selección dinámica de datos

Operadores de agregación

Operadores LongCount y Count

Operadores Min y Max

Operadores MinBy y MaxBy

Operadores Sum y Aggregate

Operador Average

Agrupamiento de datos

Cláusula GroupBy

Ejercicio cláusula GroupBy

Cláusula Lookup

Cláusula Join

Cierre de curso

Recapitulación sobre LINQ

Cláusula GroupBy

Progreso del curso

Introducción

Configuración de proyecto

Operadores básicos

Operadores de agregación

Agrupamiento de datos

Cierre de curso