Cláusula Lookup

Cláusula Lookup

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

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.

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

}

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

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

Utilizando Extension Method y Query Expression. ```txt //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; ```

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

`lookup(colección, clave)`

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

        }

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

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