No tienes acceso a esta clase

¬°Contin√ļa aprendiendo! √önete y comienza a potenciar tu carrera

Operadores Take y Skip

15/26
Recursos

Aportes 13

Preguntas 2

Ordenar por:

¬ŅQuieres ver m√°s aportes, preguntas y respuestas de la comunidad?

TakeWhile

Devuelve los elementos de una secuencia siempre que el valor de una condición especificada sea true y luego omite los elementos restantes.

https://learn.microsoft.com/es-es/dotnet/api/system.linq.enumerable.takewhile?view=net-7.0

SkipWhile

Omite los elementos de una secuencia en tanto que el valor de una condición especificada sea true y luego devuelve los elementos restantes.

https://learn.microsoft.com/es-es/dotnet/api/system.linq.enumerable.skipwhile?view=net-7.0

Es importante mencionar que cuando estas trabajando con tus querys debes analizar el orden de las funciones.
Por ejemplo si colocas el take primero que el where el where va hacer la condicion en relacion a los valores que devolvio el take y viceversa

    //RETO: UTILIZANDO EL OPERADOR SKIP SELECCIONA EL TERCER Y CUARTO LIBRO DE LOS QUE TENGAN M√ĀS DE 400 P√ĀGINAS 
    public IEnumerable<Book> ListaDeLibros3eroY4toCon400Paginas()
    {
        return librosCollection.Where(p=>p.PageCount>400)
        .OrderByDescending(p=>p.PageCount)
        .Take(4)// los primeros 4
        .Skip(2); //omite el primero y el segundo
    }

Obtuve el mismo resultado de la siguiente forma:


return librosColection
                .Where(l => l.PageCount > 400)
                .Skip(2)
                .Take(2);
public List<Book>getTop3ByCategoryOrderByDateDescending(IEnumerable<Book> books,string categorie){
    return (from b  in books  where b.Categories.Contains("Java") orderby b.PublishedDate descending select b).Take(3).ToList();
}

public List<Book> getByPagesTakeSkip(IEnumerable<Book> books,int pages, int skip, int take){
    return ((from b in books where b.PageCount>pages orderby b.PageCount select b).Take(take)).Skip(skip).ToList();
}
```js public IEnumerable<Book> TresPrimerosLibrosFechaRecienteCatJava() { return librosCollection.Where(p => p.Categories.Contains("Java")).OrderByDescending(p => p.PublishedDate).Take(3); } ```
Mi solución```c# public IEnumerable<Book> GetBooksByCategoryTake(string category, int take) { // Extension method return librosCollection?.Where(book => book.Categories.Contains(category)) .OrderByDescending(book => book.PublishedDate) .Take(take) ?? []; } ```
```c# //... Segundo desafio con los operadores Skip y Take: //... Simplemente se saltan los 2 primeros titulos y se toman los 2 siguientes (3 , 4) public IEnumerable<Book> FirstsBoooksWithMore400Pages() { return CollectionBooks.Where(p => p.PageCount > 400).Skip(2).Take(2); } ```//... Segundo desafio con los operadores Skip y Take: public IEnumerable\<Book> FirstsBoooksWithMore400Pages() { return CollectionBooks.Where(p => p.PageCount > 400).Skip(2).Take(2); }
Mis soluciones ūüĎć: ```js public IEnumerable<Book> goGrazy() { return librosCollection .Where(l => l.Categories.Contains("Java")) .OrderByDescending(l => l.PublishedDate) .Take(3); } public IEnumerable<Book> goCrazyDeluxe() { return librosCollection .Where(l => l.PageCount > 400) .OrderByDescending(l => l.PageCount) .Skip(2) .Take(2); } ```

mi forma:

public IEnumerable<Book> GetThreeFirstBooksByCategoryAndSortedByDate(string category)
    {
        //extension method
        // return CollectionBook.Where(book => (book.Categories ?? Enumerable.Empty<String>()).Contains(category)).OrderBy(book => book.PublishedDate).Take(3);

        //linq query
        // return (from book in CollectionBook 
        //         where (book.Categories ?? Enumerable.Empty<String>()).Contains(category) 
        //         orderby book.PublishedDate descending
        //         select book).Take(3);

        return (from book in CollectionBook 
                where (book.Categories ?? Enumerable.Empty<String>()).Contains(category) 
                orderby book.PublishedDate 
                select book).TakeLast(3);
    }

    public IEnumerable<Book> GetThirdAndFourthBookByPages(int pages)
    {
        //extension method
        // return CollectionBook.Where(book => (book.PageCount ?? 0) > pages).Take(4).Skip(2);

        //linq query
        return (from book in CollectionBook 
                where book.PageCount > pages 
                select book).Take(4).Skip(2);
    }

Antes de ver el vídeo, reto operador Skip:

public IEnumerable<Book> LibroPosicionMasDeXPaginas(int first, int second, int pageQuantity)
        {
            return librosCollection.Where(book => book.PageCount > pageQuantity).Take(first).Skip(second);
        }

us√°ndolo:

//* Tercer y cuarto libro con m√°s de 400 p√°ginas
        ImprimirValores(queries.LibroPosicionMasDeXPaginas(4, 2, 400));

Antes de ver el vídeo, reto operador Take:

public IEnumerable<Book> PrimerosLibrosRecientesCategorizados(int quantity, string category)
        {
            return librosCollection.Where(book => book.Categories.Contains(category)).OrderBy(book => book.PublishedDate).Take(quantity);
        }

us√°ndolo:

//* Primeros 3 libros con fecha de publicación más reciente categorizados en Java
        ImprimirValores(queries.PrimerosLibrosRecientesCategorizados(3, "Java"));
// Take the first 3 books with the most recent publication date and that are from Java.

public IEnumerable<Book> TakeAnyBooksOrderByPulishedDateBelongsToJava(int numberBooks)
    {
        return booksCollection.Where(book => book.Categories.Contains("Java")).OrderBy(book => book.PublishedDate).Take(numberBooks);
    }