Cláusula Lookup

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:58

Cláusula Lookup

Curso de Manejo de Datos en C# con LINQ

Clase 24 de 26

Clase 24 / 26

Comentarios (12)12 comentarios

Jimmy Buriticá Londoño

Hace 4 años

Cláusula Lookup

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

Briam Flores Torres

Hace 4 años

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

Hace 4 años

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

Hace un año

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

Hace 3 años

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

Hace 2 años

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

Hace 2 años

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

Jerry Lee Minotta Rebellón

Hace 3 años

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

Hace 2 años

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

Joan Alexander Valerio Rodríguez

Hace 2 años

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

Hace 3 años

lookup(colección, clave)

ROMMEL DUAREZ SAENZ

Hace 2 años

ToLookup(clave, valor)

Miguel Angel Reyes Moreno

Hace 3 años

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

Hace 3 años

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

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

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

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

        }

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 Lookup

Progreso del curso

Introducción

Configuración de proyecto

Operadores básicos

Operadores de agregación

Agrupamiento de datos

Cierre de curso