Operadores Take y Skip

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

Hans González

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

Rafael Varela Pérez

Obtuve el mismo resultado de la siguiente forma:


return librosColection
                .Where(l => l.PageCount > 400)
                .Skip(2)
                .Take(2);

Giame Carlos Fajardo Santos

Me pregunto si implica alguna diferencia en rendimiento en comparación al código de Hans

Gustavo Fernández

Implica diferencia cuando se trabaja con grandes volúmenes de datos... En este caso sería mejor aplicar primero Skip y luego Take, para hacer más eficiente la reducción de datos procesados.

Alejandro Betancur

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

Luca Cristian Manea

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

Cristhian Alexis Vera Sandoval

Hace 5 meses

que son los operadores Take y Skip y cual es la mejor manera de ordenar

Take y Skip son tus herramientas quirúrgicas para la paginación: uno extrae una porción y el otro descarta el resto. Pero cuidado: si no ordenas tus datos primero, tus "páginas" serán un caos de objetivos móviles.

¿Por qué crees que el orden de tus datos es un requisito previo indispensable antes de siquiera tocar esos operadores?

César Augusto Poveda Floréz

Hace 8 meses

Hola, solo tengo una observación o apreciación mas bien sobre el ejercicio de tercer y cuarto libro. Según como esta redactado el reto, habla de una posición. Aunque no aclaro y puede ser ambiguo en que orden, siento que hace falta el order. Porque el resultado no seria el tercer y cuarto libro, ya que no están ordenados, seria el tercer y cuarto, pero del subgrupo que tomo el take, asi que según yo quedo faltando el order.

Saludos.

Jorge Cardona

En Query Expression como sería? Funciona LIMIT como en SQL?

Miguel Teheran

Profesor

No existe como tal una equivalencia de Take entonces lo ideal seria hacer el query con query expression y luego envolver todo el resultado con paratenresis y obtener la cantidad de elementos que necesites.

var query = (MyQuery) .Take(2);

Camilo González

.TakeWhile sirve para lo mismo que .Where? Ambos filtran una colección en base a una condición. Hay algunos casos en los que se recomiende usar uno antes que el otro?

Miguel Teheran

Profesor

Es diferente. Where aplica la condición para toda la colección lo que hace TakeWhile es ir tomando los elementos que cumpla la condición y cuando uno no la cumpla se sale del ciclo y no continua evaluando los siguientes registros

JOHN CARLOS ARRIETA ARRIETA

Excelente curso de formación.

Usar Take es parecido realizar una consulta con MySQL = Limit, MS SS = Top, Oracle = RowNum
Usar TakeWhile es parecido a usar lo mismo operadores pero en la consulta externa de una subconsulta SQL.

Que la pasen muy bien. Bendiciones en su día a día.

Jesus Maria Gonzalez Guardo

Lo impplemente de esta forma < public IEnumerable<Book> OrdenarPorTake(){ return librosCollection.Where(x => x.Categories.Contains("Java")).OrderBy(x => x.PublishedDate.Year).Take(3); } >

Juan Daniel Ramirez Coroy

public IEnumerable<Book> librosPaginas() { return librosCollection.Where(x => x.PageCount > 400) .Take(4) .Skip(2); }

Roberto Bravo

Aqui mi solucion con parámetros

public IEnumerable<Book> skipBooksOrderedByPublishedDate(int taken, int skipped, string category = "all")
    {
        if(category == "all" || category == "")
        {
            return collection
            .Where(book => book.PageCount > 400)
            .OrderByDescending(book => book.PublishedDate)
            .Take(taken)
            .Skip(skipped);
        }
        else    
        {
            return collection
            .Where(book => book.Categories.Contains(category) && book.PageCount > 400)
            .OrderByDescending(book => book.PublishedDate)
            .Take(taken)
            .Skip(skipped);
        }
    }
```Aquí el llamado a la función

```js
// Take 2 books ordered by published date
printValues(queries.skipBooksOrderedByPublishedDate(4, 2));

// Take 2 books ordered by published date
printValues(queries.skipBooksOrderedByPublishedDate(4, 2, "Java"));

Jose Carlos Vega Moron

Podemos reutilizar funciones que ya hemos creado para el ejercicio de Take:

public IEnumerable<Book> PertenecePython(string categorie)
        {
            return librosCollection.Where(x => x.Categories.Contains(categorie)).OrderBy(x => x.Title);
        }
public IEnumerable<Book> EjercicioTake()
        {
            return PertenecePython("Java").Take(3);
        }
```        public IEnumerable\<Book> EjercicioTake()

&#x20;       {

&#x20;           return PertenecePython("Java").Take(3);

&#x20;       }

Aldhair Vera Camacho

public IEnumerable<Book> LibrosFiltrados()
    {
        return librosCollection
                .Where(p => p.PageCount > 400)
                .OrderBy(p => p.Title)
                .Skip(2)
                .Take(2);
    }
```public IEnumerable\<Book> LibrosFiltrados()    {        return librosCollection                .Where(p => p.PageCount > 400)                .OrderBy(p => p.Title)                .Skip(2)                .Take(2);    }

Aldhair Vera Camacho

public IEnumerable<Book> LibrosFiltrados() { return librosCollection .Where(p => p.PageCount > 400) .OrderBy(p => p.Title) .Skip(2) .Take(2); }

Joan Alexander Valerio Rodríguez

public IEnumerable<Book> TakeThreeBooksDate()
    {
        // Utilizando el operador Take selecciona los primeros 3 libros con fecha de publicación más reciente que estén categorizados en Java.
        
        //Extension Method
        return BooksCollections
        .Where(p => p.Categories.Contains("Java"))
        .OrderByDescending(p => p.PublishedDate)
        .Take(3);
        
        //Query expression
        var query = (from p in BooksCollections
                    where p.Categories.Contains("Java")
                    orderby p.PublishedDate descending
                    select p).Take(3);
                                                
        return query;
    }

    public IEnumerable<Book> SkipAndTakeBooksPageCount()
    {
        // Utilizando el operador Skip selecciona el tercer y cuarto libro de los que tengan más de 400 páginas.
        
        //Extension Method
        return BooksCollections
        .Where(p => p.PageCount > 400)
        .Take(4)
        .Skip(2);
            

        //Query expression
        var query = (from p in BooksCollections
                    where p.PageCount > 400
                    select p).Take(4).Skip(2);

        return query;
    }

Argenis Valdez

Reto Skip:

public IEnumerable<Book> LibrosConMasde400PagConSkip() { return librosCollection.Where(p=> p.PageCount >400) .Take(4) .Skip(2); }

Betzabhe Elizabeth Vega Aliaga

public IEnumerable<Book> TresPrimerosLibrosFechaRecienteCatJava()
    {
        return  librosCollection.Where(p => p.Categories.Contains("Java")).OrderByDescending(p => p.PublishedDate).Take(3);
    }

Emiliano Perez

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) ?? []; }

Alvaro A. Perea Ospina

//... 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()

{

&#x20;   return CollectionBooks.Where(p => p.PageCount > 400).Skip(2).Take(2);

}

Angel Qui