Usando el operador Where

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

Mairon Andres Florez Alvarez

student•

1. Como aporte, se modificó un poco el código que traía de clase anterior, agregue el método de GetCustomFilter utilizando el delegado como parámetro Func<Book, bool> para poder filtrar a conveniencia desde donde se invoque una instancia de esta clase LinqQueries, como se aprecia en la imagen 2. Combinando esta forma con delegados y Linq se saca un poder increíble al momento de por ejemplo filtrar:

LinqQueries queries = new LinqQueries();
Func<Book, bool> filtro = x => x.PublishedDate.Year >= 2000 && x.PageCount > 600;
var filtrado = queries.GetCustomFilter(filtro);

_Y ahí mismo se puede concatenar más condiciones dando un dinamismo en el filtrado que de otra manera es mas complicado. _

2. También se modificó la clase de Book.cs sobrescribiendo el método ToString() para devolver el string parseado que estamos mostrando por consola para ver el Titulo, páginas y fecha publicación y el signo de pregunta al final del tipo de cada propiedad es para dejar la propiedad de tipo Nullable o que acepta valores null. En la sección o archivo de Program.cs solo de crea la instancia nueva, se crea la variable filtro que tiene la definición de la expresión de nuestro filtro (año publicación >= 2000 y además que las páginas sean mayor a 600) Lo importante de esta parte es que podemos desde la instancia aplicar el filtro que se quiera, y no depender de la clase con la implementacion.

_3. Aqui el resultado _

4. y como ya es costumbre la imagen completa

Cristian Tinipuclla

student•

Buen aporte, a veces me cuesta leer aportes complejos o muy extensos, pero este ha valido la pena. 👏

Cristopher Alexander Reyes Portillo

student•

definición IEnumerable

Frandel Corporan Rodríguez

student•

Gracias Heroe

Jimmy Buriticá Londoño

student•

Documentación oficial de LINQ

en Microsoft

Kevin Castellano

student•

Si hicieron colocaron como nullable las propiedades string de libros les aparecerá una advertencia en las query. Para solucionarlo usé el operador (??) de esta manera:

public IEnumerable<Book> BooksInActionAndMoreThan250Pages()
    {
        // Extension method
         return collectionBook.Where(book => book.PageCount > 250 && (book.Title ?? String.Empty).Contains("in Action"));

        // Query Expression
        //return from l in collectionBook where l.PageCount > 250 && (l.Title ?? String.Empty).Contains("in Action") select l;
    }

Beto Martinez

student•

Asi quedo mi Query

public IEnumerable<Book> LibrosDespues2000 => libros.Where(libro => libro.PublishedDate.Year > 2000);

Cristancho Arbld

student•

public IEnumerable<Book> LibrosMasDe250Paginas(string method, int pages, string title)
    {
        if (method is "method")
        {
            return _booksCollection.Where(x => x.PageCount > pages && x.Title.Contains(title));
        }
        else if (method is "query")
        {
            return from b in _booksCollection
                   where b.PageCount > pages && b.Title.Contains(title)
                   select b;
        }
        else
        {
            return Enumerable.Empty<Book>();
        }
    }

Juan Diego Sánchez Rodríguez

student•

Me encantaría un curso como este para manejar colecciones en Java, sería increible.

Angel Qui

student•

Mi solución

Program.cs

IEnumerable<Book> tempBooks = queries.LibrosConXMasPaginas(250);
PrintValues(queries
    .LibrosQueContieneXPalabraEnTitulo("in Action", tempBooks));

```**LinqQueries:**

```js
    public IEnumerable<Book> LibrosConXMasPaginas(int maxPages, List<Book> libros = null)
    {
        // we making the program scalable 
        if(libros == null)
        {
            libros = librosCollection;
        }

        // extension method
        return libros.Where(p => p.PageCount > maxPages);

        // query expression
        //return from l in libros where l.PageCount > maxPages select l;
    }

    public IEnumerable<Book> LibrosQueContieneXPalabraEnTitulo(string palabra, IEnumerable<Book> libros = null)
    {
        // we making the program scalable 
        if (libros == null)
        {
            libros = librosCollection;
        }

        // extension method
        return libros.Where(p => p.Title.Contains($"{palabra}"));

        // query expression
        //return from l in libros where l.Title.Contains($"{palabra}") select l;
    }
}

Mairon Andres Florez Alvarez

student•

Reto 2: Filtro paginas > 250 y titulo contiene "in Action"

Sergio Sanchez

student•

Quizas un

ToLower()

para manejar el "iN actioN" en caso de que exista.

Reynaldo Enrique Hernández Fuentes

student•

Comparto una versión con parámetros

public IEnumerable<Book> GetBooksByPagesAndTitle(int pages, string filterTitle)

{

return booksCollection.Where(book => book.PageCount > pages && book.Title!.Contains(filterTitle));

}

Musicar SAS

student••

Aquí hay una solución optima para las dos soluciones escribiendolas usando el modo function

Laura Valentina Bernate Gordillo

student•

el reto where 2

 return librosCollection.Where(p => p.PageCount > 250 && p.Title.Contains("Action"));

Yasmiver Alejandro Aponte Romero

student•

No me queda claro por que en el primer reto se usa .Year public IEnumerable<Book> LibrosDespuesDel2000()

{

//Método de extensión

//return librosCollection.Where(p => p.PublishedDate.Year > 2000);

//querie de expression

return from l in librosCollection where l.PublishedDate.Year > 2000 select l;

}

juan.velez613

student•

buen dia como se puede hacer un where tipo Condicion ? Expresion1 : Expresion2; en linq ?

Miguel Teheran

teacher•

Puedes dar un poco más de contexto? la idea del where es filtrar la información y apoyarnos de los operadores (y/o) && y || para combinar las condiciones

Daniel Alfaro Ramírez

student•

Qué tal, quise hacer un nuevo método con Query Expression para mostrar los libros cuyo autor contiene a "Robi" pero n otrae resultados. Supongo que es debido a que se maneja diferente el filtrar un arreglo de string. Mi query es el siguiente:

return from l in librosCollection where l.Authors.Contains("Robi") select l;

Miguel Teheran

teacher•

Pregunta Authors es una colección de strings? por que sino estarias haciendo mal la comparación, también revisa por fa si estas respetando mayusculas y minusculas. en general se ve bien.

Daniel Alfaro Ramírez

student•

Así es, la declaración es la siguiente:

public string[] Authors { get; set; }

Respecto a las mayúsculas y minúsculas no hay errores de compilación ni en tiempo de ejecución.

Leonardo Valdivieso

student•

Tarda lo mismo la consulta si es una expresion query o un extension method?

Miguel Teheran

teacher•

Si, en teoria no tiene gran diferencia la traducción a SQL es practicamente la misma

kolab Linkear

student•

Esta es la propuesta de mejora que propongo sobre los métodos, de paso devuelve la data ordenada:

Jonathan Harley Sabogal toro

student•

return booksCollection.Where(p => p.PageCount > 250 && p.Title!.Contains("in Action"));
```return booksCollection.Where(p => p.PageCount > 250 && p.Title!.Contains("in Action"));

Jorge Luis Garza Gutierrez

student•

Que tal, yo hice un metodo un poco mas dinamico donde puedes pasar por parametro una keyword y minPageCount

Podria ser util para un buscador y se reutiliza mucho el codigo.

José Manuel Correa Bañuelos

student•

Mi solución al reto:

public IEnumerable<Book> BooksInActionAndMoreThan250Pages()
    {
        // Extension method
         return collectionBook.Where(book => book.PageCount > 250 && (book.Title ?? String.Empty).Contains("in Action"));

        // Query Expression
        //return from l in collectionBook where l.PageCount > 250 && (l.Title ?? String.Empty).Contains("in Action") select l;
    }

public IEnumerable<Book> LibrosMasDe250Paginas(string method, int pages, string title)
    {
        if (method is "method")
        {
            return _booksCollection.Where(x => x.PageCount > pages && x.Title.Contains(title));
        }
        else if (method is "query")
        {
            return from b in _booksCollection
                   where b.PageCount > pages && b.Title.Contains(title)
                   select b;
        }
        else
        {
            return Enumerable.Empty<Book>();
        }
    }

IEnumerable<Book> tempBooks = queries.LibrosConXMasPaginas(250);
PrintValues(queries
    .LibrosQueContieneXPalabraEnTitulo("in Action", tempBooks));

```**LinqQueries:**

```js
    public IEnumerable<Book> LibrosConXMasPaginas(int maxPages, List<Book> libros = null)
    {
        // we making the program scalable 
        if(libros == null)
        {
            libros = librosCollection;
        }

        // extension method
        return libros.Where(p => p.PageCount > maxPages);

        // query expression
        //return from l in libros where l.PageCount > maxPages select l;
    }

    public IEnumerable<Book> LibrosQueContieneXPalabraEnTitulo(string palabra, IEnumerable<Book> libros = null)
    {
        // we making the program scalable 
        if (libros == null)
        {
            libros = librosCollection;
        }

        // extension method
        return libros.Where(p => p.Title.Contains($"{palabra}"));

        // query expression
        //return from l in libros where l.Title.Contains($"{palabra}") select l;
    }
}

Usando el operador Where

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