Operadores Take y Skip

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

Wilian Eduardo Soch

student•

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

student•

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

student•

Obtuve el mismo resultado de la siguiente forma:


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

Giame Carlos Fajardo Santos

student•

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

Gustavo Fernández

student•

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.

Luca Cristian Manea

student•

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

Jorge Cardona

student•

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

Miguel Teheran

teacher•

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

student•

.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

teacher•

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

student•

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

student•

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

student•

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

Roberto Bravo

student•

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

student•

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

student•

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

student•

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

Joan Alexander Valerio Rodríguez

student•

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

student•

Reto Skip:

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

Betzabhe Elizabeth Vega Aliaga

student•

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

Emiliano Perez

student•

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 Augusto Perea Ospina

student•

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

student•

Mis soluciones 👍:

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

Joel Angel David Barrantes Palacios

student•

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

Miguel Angel Reyes Moreno

student•

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

Miguel Angel Reyes Moreno

student•

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