Operadores Take y Skip
Clase 15 de 26 • Curso de Manejo de Datos en C# con LINQ
Contenido del curso
Wilian Eduardo Soch
student•
hace 3 años
Clase 15 de 26 • Curso de Manejo de Datos en C# con LINQ
Contenido del curso
Wilian Eduardo Soch
Hans González
Rafael Varela Pérez
Giame Carlos Fajardo Santos
Gustavo Fernández
Luca Cristian Manea
César Augusto Poveda Floréz
Jorge Cardona
Miguel Teheran
Camilo González
Miguel Teheran
JOHN CARLOS ARRIETA ARRIETA
Jesus Maria Gonzalez Guardo
Juan Daniel Ramirez Coroy
Roberto Bravo
Jose Carlos Vega Moron
Aldhair Vera Camacho
Aldhair Vera Camacho
Joan Alexander Valerio Rodríguez
Argenis Valdez
Betzabhe Elizabeth Vega Aliaga
Emiliano Perez
Alvaro Augusto Perea Ospina
Angel Qui
Joel Angel David Barrantes Palacios
Miguel Angel Reyes Moreno
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);
Me pregunto si implica alguna diferencia en rendimiento en comparación al código de Hans
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.
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(); }
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.
En Query Expression como sería? Funciona LIMIT como en SQL?
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);
.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?
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
Excelente curso de formación.
Que la pasen muy bien. Bendiciones en su día a día.
Lo impplemente de esta forma
< public IEnumerable<Book> OrdenarPorTake(){ return librosCollection.Where(x => x.Categories.Contains("Java")).OrderBy(x => x.PublishedDate.Year).Take(3); }
>
public IEnumerable<Book> librosPaginas() { return librosCollection.Where(x => x.PageCount > 400) .Take(4) .Skip(2); }
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"));
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()   {   return PertenecePython("Java").Take(3);   }
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); }
public IEnumerable<Book> LibrosFiltrados() { return librosCollection .Where(p => p.PageCount > 400) .OrderBy(p => p.Title) .Skip(2) .Take(2); }
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; }
Reto Skip:
public IEnumerable<Book> LibrosConMasde400PagConSkip() { return librosCollection.Where(p=> p.PageCount >400) .Take(4) .Skip(2); }
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) ?? []; }
//... 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 👍:
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));