Usando el operador Where

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

definición IEnumerable

Documentación oficial de LINQ

en Microsoft

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

Asi quedo mi Query

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

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

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

Hecho desde Program.cs

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

PrintBooks(books.GetBooks().Where(book => book.PageCount > 250 && book.Title.Contains("in Action")));

 public List<Book> FilterBooks(int year, int pages, string textToSearch)
    {
        var filteredList = collectionBooks.ToList().AsQueryable();

        if (year > 0)
        {
            filteredList = filteredList.Where(book => book.publishedDate.Year > year);
        }

        if (pages > 0)
        {
            filteredList = filteredList.Where(book => book.pageCount > pages);
        }

        if (textToSearch != "")
        {
            filteredList = filteredList.Where(book => book.title.Contains(textToSearch));
        }

        return filteredList.ToList();
    }```

yo elegí crear mi propio metodo de filtrado por paginas y texto

public IEnumerable<Book> GetBookByPageAndByTitle(int page, string title)
    {
        //extension method
        //return CollectionBook.FindAll(book => book.PageCount > page && book.Title.Contains(title));

        //linq query
            return from book in CollectionBook where (book.PageCount ?? 0) > page && (book.Title?.Contains(title) ?? false) select book;

    }

Reto de la clase antes de ver el vídeo (Y sí es muy similar a SQL):

public IEnumerable<Book> MasDe200PaginasYTituloContieneAction()
        {
            return from book in librosCollection
                        where book.PageCount > 250
                        && book.Title.Contains("in Action")
                        select book;
        }

Aca mi solucion

    public IEnumerable<Book> BooksWithMoreThan250Pages()
    {
        // return booksCollection.Where(b => b.PageCount > 250 && b.Title.Contains("action"));

        return from b in booksCollection where b.PageCount > 250 && b.Title.Contains("action") select b;
    }```

Definitivamente enamorado de Linq

 public IEnumerable<Book> TodaLaColeccion()
        {
            // extension method
            // return this.librosCollection.OrderBy(book => book.Title);
            // query method
            return from book in this.librosCollection
                   orderby book.Title
                   select book;
        }

        public IEnumerable<Book> LibrosPublicadosDespuesDel2000()
        {
            // extension method
            // return this.librosCollection.Where(book => book.PublishedDate.Year > 2000);
            // query method
            return from book in this.librosCollection
                   where book.PublishedDate.Year > 2000
                   select book;
        }

        public IEnumerable<Book> LibrosConMasDe250Paginas()
        {
            // extension method
            // return this.librosCollection.Where(book => book.PageCount > 250 && book.Title.Contains("in Action"));
            // query method
            return from book in this.librosCollection
                   where book.PageCount > 250 && book.Title.Contains("in Action")
                   select book;
        }

// Reto 1
public IEnumerable<Book> LibrosDespuesDeCiertoAnio(string method, int year)
    {
        if (method is "method")
        {
            // Extension method
            return _booksCollection.Where(x => x.PublishedDate.Year > year).OrderByDescending(x => x.PublishedDate);
        }
        else if (method is "query")
        {
            // Query expresion
            return from b in _booksCollection
                where b.PublishedDate.Year > year
                orderby b.PublishedDate descending
                select b;
        }
        else 
        {
            return Enumerable.Empty<Book>();
        }
    }

Cordial saludo Miguel. Sería muy bueno que en los próximos videos que hagas uses parámetros al crear los métodos. Muy bueno el curso. Gracias