Cláusula Lookup

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

Jimmy Buriticá Londoño

student•

Cláusula Lookup

Permite usar toda la colección en un diccionario y agrupar los datos por una propiedad.

Briam Flores Torres

student•

Query

public ILookup<char, Book> DictionaryBookByChar()
{
	// En el ToLookUp se pone los valores del diccionario que vas a retornar (char, book)
	return booksCollection.ToLookup(x => x.Title[0], x => x);
}

Diccionario de libros agrupados por primera letra del titulo

var dictionaryLookup = queries.DictionaryBookByChar();
PrintDictionary(dictionaryLookup, 'A');

Función para imprimir el diccionario que retorna el Query

void PrintDictionary(ILookup<char, Book> bookList, char letter)
{
	Console.WriteLine("{0,-60} {1, 15} {2, 15}\n", "Titulo", "N. Paginas", "Fecha publicacion");
	foreach (var item in bookList[letter])
	{
        	Console.WriteLine("{0,-60} {1, 15} {2, 15}",item.Title,item.PageCount,item.PublishedDate.Date.ToShortDateString()); 
	}

}

Rolando Fernández

student•

void printDictionary(ILookup<char, Book> listBooks, char letter)
{
    char letterUpper = Char.ToUpper(letter);
    if (listBooks[letterUpper].Count() == 0)
    {
        Console.WriteLine($"No hay libros que inicien con la letra '{letterUpper}'");
    } 
    else 
    {
        Console.WriteLine("{0, -60} {1, 15} {2, 15}\n", "Título", "Nro. Páginas", "Fecha de Publicación");
        foreach (var book in listBooks[letterUpper])
        {
            Console.WriteLine("{0, -60} {1, 15} {2, 15}", book.Title, book.PageCount, book.PublishedDate.ToShortDateString());
        }
    }
}

Agrego transformar cualquier carácter a mayúscula y un condicional que imprima un mensaje si no hay libros con dicho carácter.

Kenneth David Gaitan Evanks

student•

ToLookup en LINQ se utiliza para crear una colección de tipo Lookup<TKey, TElement>, que permite agrupar elementos por una clave específica. Es útil para acceder rápidamente a grupos de elementos, facilitando operaciones como la búsqueda y la manipulación de datos. En comparación con GroupBy, ToLookup materializa el resultado, creando una estructura que permite acceso directo por clave, mientras que GroupBy devuelve una secuencia que se evalúa de manera diferida.

Angel Qui

student•

En la manera que yo entendí, los grupos te dan un puñado de elementos que puedes ir filtrando con foreach y puedes hacer un tipo de separación a través de Key, y por el otro lado, los diccionarios te permiten encontrar un puñado de valores con una llave.

En otras palabras:

Grupos --> Te da grupos, que se pueden separar
Diccionarios --> Te da grupos filtrables

El concepto me sigue pareciendo un poco raro, pero por el momento entendible de una manera u otra. XD

Jorge Romero

student•

Hola, debido a tu comentario me puse a investigar y encontré lo siguiente:

Cuándo usar cada uno

Usa GroupBy:
- Si necesitas trabajar con datos de forma diferida o aplicar operaciones adicionales (como filtros, ordenamientos, etc.) antes de agrupar.
- Si solo necesitas iterar sobre los grupos una vez.
Usa Lookup:
- Si necesitas acceder varias veces a los mismos grupos por clave.
- Si priorizas la rapidez en búsquedas tras crear la estructura.

GroupBy es más flexible y adecuado para operaciones dinámicas, mientras que Lookup es más eficiente para búsquedas rápidas y reutilización de los datos ya agrupados.

Gustavo Fernández

student•

Utilizando el shortcut Ctrl + L tambien se puede limpiar la terminal, es lo mismo que escribir cls

Jerry Lee Minotta Rebellón

student•

Se puede retornar un IEnumerable<Book> y recibir como propiedad el carácter de búsqueda en lugar de ILookup<char, Book> en la función de ListadeLibros, con los siguientes cambios:

public IEnumerable<Book> DiccionaryBooksInitialCharacter(char character)
    {
        var diccionary = librosCollection.ToLookup(p => p.Title[0], p => p);
        return diccionary[character];
    }

De esa forma podemos reutilizar la función de imprimir variables:


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

Para llamarla solo pasamos el caracter de busqueda a la funcion del objeto queries:

printValues(queries.DiccionaryBooksInitialCharacter('S'), null, null);

Henry Espinoza

student•

¿Que seria mas eficiente usar la clausula where o lookup?

Joan Alexander Valerio Rodríguez

student•

Utilizando Extension Method y Query Expression.

//Extension Method
return BooksCollections
       .ToLookup(p => p.Title[0], p => p);
        
//Query Expression
var query = (from p in BooksCollections
            select p).ToLookup(p => p.Title[0]);
        
return query;

Eduardo David Santiago Carrillo

student•

lookup(colección, clave)

ROMMEL DUAREZ SAENZ

student•

ToLookup(clave, valor)

Miguel Angel Reyes Moreno

student•

Podemos guardar el formato del output en una variable:

string formatoDiccionario = "{0,-60} {1, 15} {2, 15}";

void PrintDictionary(ILookup<char, Book> bookList, char letter)
        {
            Console.WriteLine($"{formatoDiccionario}\n", "Titulo", "N. Paginas", "Fecha publicacion");
            foreach (var item in bookList[letter])
            {
                Console.WriteLine($"{formatoDiccionario}", item.Title, item.PageCount, item.PublishedDate.Date.ToShortDateString());
            }

        }

José Eduardo Vinagre de Dios

student•

Así me quedo el método ImprimirDiccionario reutilizando el método ImprimirValores

void ImprimirDiccionario(ILookup<char, Book> ListaDeLibros, char letra)
{
    ImprimirValores(ListaDeLibros[letra]);
}

void PrintDictionary(ILookup<char, Book> bookList, char letter)
{
	Console.WriteLine("{0,-60} {1, 15} {2, 15}\n", "Titulo", "N. Paginas", "Fecha publicacion");
	foreach (var item in bookList[letter])
	{
        	Console.WriteLine("{0,-60} {1, 15} {2, 15}",item.Title,item.PageCount,item.PublishedDate.Date.ToShortDateString()); 
	}

}

void printDictionary(ILookup<char, Book> listBooks, char letter)
{
    char letterUpper = Char.ToUpper(letter);
    if (listBooks[letterUpper].Count() == 0)
    {
        Console.WriteLine($"No hay libros que inicien con la letra '{letterUpper}'");
    } 
    else 
    {
        Console.WriteLine("{0, -60} {1, 15} {2, 15}\n", "Título", "Nro. Páginas", "Fecha de Publicación");
        foreach (var book in listBooks[letterUpper])
        {
            Console.WriteLine("{0, -60} {1, 15} {2, 15}", book.Title, book.PageCount, book.PublishedDate.ToShortDateString());
        }
    }
}

public IEnumerable<Book> DiccionaryBooksInitialCharacter(char character)
    {
        var diccionary = librosCollection.ToLookup(p => p.Title[0], p => p);
        return diccionary[character];
    }

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

//Extension Method
return BooksCollections
       .ToLookup(p => p.Title[0], p => p);
        
//Query Expression
var query = (from p in BooksCollections
            select p).ToLookup(p => p.Title[0]);
        
return query;

string formatoDiccionario = "{0,-60} {1, 15} {2, 15}";

void PrintDictionary(ILookup<char, Book> bookList, char letter)
        {
            Console.WriteLine($"{formatoDiccionario}\n", "Titulo", "N. Paginas", "Fecha publicacion");
            foreach (var item in bookList[letter])
            {
                Console.WriteLine($"{formatoDiccionario}", item.Title, item.PageCount, item.PublishedDate.Date.ToShortDateString());
            }

        }

Cláusula Lookup

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