Cláusula GroupBy

Clase 22 de 26 • Curso de Manejo de Datos en C# con LINQ

Jimmy Alexander Soza Ortiz

student•

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

student•

Jimmy Buriticá Londoño

student•

Cláusula GroupBy

Permite agrupar los datos por una propiedad.

Luca Cristian Manea

student•

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

student•

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

student•

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

student•

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

student••

He ordenado los datos usando OrderBy

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

Angel Qui

student•

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

student•

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

student•

//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&lt;IGrouping&lt;int, Book&gt;&gt; librosPublicadosDespues2000AgrupadosAno()
    {
        return booksCollection.Where(books =&gt; books.PublishedDate.Year &gt; 2000).OrderBy(book =&gt; book.PublishedDate).GroupBy(book =&gt; 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;
    }

Cláusula GroupBy

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

Ejercicio para aplicar el operador Where

Operadores All y Any

Operador Contains

Operadores OrderBy y OrderByDescending

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