Operadores OrderBy y OrderByDescending

Guillermo Restrepo Botero

Estudiante

Sana Sugerencia: Importante para tener en cuenta en lo de las Escuelas: Alumno que venga del curso de programación, luego C#, luego este, se encuentra con malas prácticas de programación al no usar parámetros en los métodos. Ya existe un método que se llamaría "librosDeCategoria(string categoria)" y se enviaría "python" la primera vez y "java" la segunda. ImprimirValores(queries.librosDeCategoria("python") y luego ImprimirValores(queries.librosDeCategoria("java")

Rubian Esteban Ruiz Ospina

Estudiante

public IEnumerable<Book> BooksAbout(string BookName) { return bookCollection.Where(book => book.Title.Contains(BookName)); }

Ivan Perez

Estudiante

no veo que el curso diga "linq con clean code", hay otro curso de c# con codigo limpio y solid 🤓👌

Jimmy Buriticá Londoño

Estudiante

Operadores OrderBy y OrderByDescending

Nos permiten ordenar una colección usando cualquier criterio.

Tomás Morales

Estudiante

¿Una pregunta, en el entorno laboral se suele utilizar VSC o VS? Y que tan parecido es uno del otro para irme familiarizando con el entorno del IDE. De antemano muchas gracias.

Miguel Teheran

Profesor

En ambiente avanzados se usa mas Visual Studio professional ofrece muy buenas herramientas para hacer debugging y mas. Para hacer proyectos mas pequeños, demos o proyectos de microservicios me gusta usar Visual studio code por que es ligero, multiplataforma y familiar para todos los dev que usan otros lenguajes como Javascript y python.

Luca Cristian Manea

Estudiante

public List<Book>getByPagesOrderByDescendingQuery(IEnumerable<Book> books,int pages){ return (from b in books where b.PageCount > pages orderby b.PageCount descending select b).ToList(); }

public List<Book>getByPagesOrferByDescendingMethod(IEnumerable<Book> books,int pages){
    return books.Where(b=>b.PageCount > pages).OrderByDescending(b=>b.PageCount).ToList();
}

José Ángel Soriano Soriano

Estudiante

miguel una duda, puede subordenar otro campo con linq, esto lo haciamos asi con sql Por ejemplo Title y ademas PageCount

Select * from libroscollection co where co.PageCount>450 Order by co.Title, co.PageCount DESC

José Ángel Soriano Soriano

Estudiante

public IEnumerable<Book> LibrosdeJavaPorNombreAscendente() { return librosCollection.Where(co=> co.Categories.Contains("Java")).OrderBy(co=> co.PageCount).ThenBy (co => co.Title); } ya contesto el profe de volada.... Por si quiero agregar mas ordenamiento...

Ivan David Martinez Baron

Estudiante

Creo que en esta ocasión la query expression es más intuitiva...

<code> 
return from l in _librosCollection where l.Categories.Contains("Java") orderby l.Title, l.PageCount select l;

Diego Alejandro Muñoz Arcos

Estudiante

Asi he implementado la solucion al problema de ordenamiento descendente cuando los libros tengan mas de 500 paginas:

    //ORDERBY DESCENDING
    public IEnumerable<Book> booksSortedByPages(int pageCount)
    {
        return booksCollection.Where(book => book.PageCount > pageCount).OrderByDescending(book => book.PageCount);
    }

Obteniendo en consola:

Libros que tienen mas de 500 paginas en orden descendente:
Title                                                                  N. Paginas   Año de Publicacion

JavaScript: The Definitive Guide                                              706            6/06/2020
Python and Tkinter Programming                                                688            1/01/2000
GWT in Action                                                                 632            1/06/2007
Android in Action, Second Edition                                             592           14/01/2011
Flexible Rails                                                                592            1/01/2008
OSGi in Action                                                                576            6/04/2011
Up to Speed with Swing, Second Edition                                        560            1/10/1999
Brownfield Application Development in .NET                                    550           16/04/2010
Pool and DBCP: Creating and Using Object Pools                                521            1/03/2005
Grails in Action                                                              520            1/05/2009
Distributed Application Development with PowerBuilder 6.0                     504            1/06/1998

David Jafet Espejel Vázquez

Estudiante

•

Para reutilizar código y hacerlo mantenible, se puede separar el ordenamiento en otra función:

    private IEnumerable<Book> OrderByCriteria(Ordering order, IEnumerable<Book> books, Func<Book, object> keySelector)
    {
        if (order == Ordering.ASC) return books.OrderBy(keySelector);
        if (order == Ordering.DESC) return books.OrderByDescending(keySelector);
        
        Console.WriteLine("Order criteria not valid, returning IEnumerable<Book>");
        return books;
    }

Donde se ve que manejo un enum, que por defecto son estáticos, así que al menos en mi caso que Rider me hace un wrapper de la función main, lo declaro fuera de la clase:

public enum Ordering
{
    ASC,
    DESC,
    NONE
}
public class LinqQueries

Entonces las funciones de ordenamiento por página y título quedan como:

    public IEnumerable<Book> GetBooksByPageCount(int pageCount, Ordering orderCriteria = Ordering.NONE)
    {
        IEnumerable<Book> result = _booksCollection.Where(book => book.PageCount >= pageCount);
        if (orderCriteria != Ordering.NONE)
        {
            return OrderByCriteria(orderCriteria, result, book => book.PageCount);
        }
        return result;
    }

    public IEnumerable<Book> GetBooksByCategoryKeyWord(string keyWord, Ordering orderCriteria = Ordering.NONE)
    {   
        IEnumerable<Book> result = 
                from _book in _booksCollection
                where _book.Categories.Contains(keyWord)
                select _book;

        if (orderCriteria != Ordering.NONE)
        {
            return OrderByCriteria(orderCriteria, result, book => book.Title);
        }
        return result;
    }

Y el ejemplo de uso:

PrintBookValues(linqQueries.GetBooksByCategoryKeyWord("Python"));
PrintBookValues(linqQueries.GetBooksByPageCount(250, Ordering.DESC));

En este caso solo hay ascendente y descendente, por lo que podría ser un poco mucho de boilerplate y se podrían llamar diferentes funciones wrapper con parámetros booleanos y diferentes nombres para cada caso ascendente y descendente, pero la ventaja es que es extendible a otros casos de uso donde requiramos más opciones en los queries.

Esteban Sánchez Ruiz

Estudiante

Alguien me puede aportar un ejemplo del segundo reto en Query Expresion por favor

Miguel Teheran

Profesor

Se utiliza una keyword para colocar el order by:

IEnumerable<Decimal> query =
    from product in products.AsEnumerable()
    orderby product.Field<Decimal>("ListPrice") descending
    select product.Field<Decimal>("ListPrice");

https://learn.microsoft.com/en-us/dotnet/framework/data/adonet/query-expression-syntax-examples-ordering-linq-to-dataset

kolab Linkear

Estudiante

Mi propuesta de Mejora:

Daniel Alberto Vega Bejarano

Estudiante

yo los ordene por Title =)

public IEnumerable<Book> LibrosMasDe450PaginasDescendente()

{

return librosCollection.Where(p => p.PageCount > 450).OrderByDescending(t => t.Title);

}

Joan Alexander Valerio Rodríguez

Estudiante

//OrderBy
//Extension method
return BooksCollections.Where(p => p.Categories.Contains("Java")).OrderBy(p => p.Title);
        
//Query expression
var query = from p in BooksCollections
            where p.Categories.Contains("Java")
            orderby p.Title
            select p;                             
return query;

//OrderByDescending
//Extension method
return BooksCollections.Where(p => p.PageCount > 450).OrderByDescending(p => p.PageCount);
        
//Query expression
var query = from p in BooksCollections
            where p.PageCount > 450
            orderby p.PageCount descending
            select p;
return query;

Angel Eduardo Ramos Mena

Estudiante

Aquí mi aporte sobre cómo resolver el reto 2 por el método query y elextensión:

            //Extension Method
            return booksCollection.Where(x => x.pageCount > 450).OrderByDescending(p => p.pageCount);

            //Query Method
            return from books in booksCollection where books.pageCount > 450 orderby books.pageCount descending select books; 
```            //Extension Method

&#x20;           return booksCollection.Where(x => x.pageCount > 450).OrderByDescending(p => p.pageCount);



&#x20;           //Query Method

&#x20;           return from books in booksCollection where books.pageCount > 450 orderby books.pageCount descending select books;&#x20;

Betzabhe Elizabeth Vega Aliaga

Estudiante

 public IEnumerable<Book> orderByDescLibrosmay450pag()
    {
        return librosCollection.Where(p => p.PageCount > 450). OrderByDescending(p => p.PageCount);
    }

Betzabhe Elizabeth Vega Aliaga

Estudiante

public IEnumerable<Book> orderByCategoryJava()
    {
        return librosCollection.Where(p => p.Categories.Contains("Java")).OrderBy(p => p.Title);
    }

Angel Qui

Estudiante

Añadí parámetros para ver qué tal quedaba y no se ve tan mal. Ni idea si sea mejor de X o Y manera:

Program.cs // Ordenador de manera descendente todos los libros con más de 450 páginas

var librosConMas450 = queries.LibrosConXMasPaginas(450);

PrintValues(queries.LibrosPorNombreDescendente(librosConMas450));

LinqQueries.cs

public IEnumerable<Book> LibrosConXMasPaginas(int maxPages, List<Book> libros = null)

{

// we making the program scalable

if(libros == null)

{

libros = librosCollection;

}

// extension method

return libros.Where(p => p.PageCount > maxPages);

// query expression

//return from l in libros where l.PageCount > maxPages select l;

}

public IEnumerable<Book> LibrosPorNombreDescendente(IEnumerable<Book> libros = null)

{

if (libros == null)

libros = librosCollection;

return libros.OrderByDescending(p => p.Title);

}

Santiago Garzon

Estudiante

<code> 
using Linq;

LinqQueries queries = new();

// Inicializamos el filter y el orderBy
Func<Book, bool> filter = b => b.Title != null;
Func<Book, IComparable> orderBy = b => b.PublishedDate.Year;

filter = b => b.PageCount > 450;
orderBy = b => b.PageCount;

PrintValues(queries.GetBooksFromQuery(filter, orderBy, false));

void PrintValues(IEnumerable<Book> books)
{
    Console.WriteLine("{0,-60}| {1, 10}| {2, 11}\n", "Titulo", "N. Paginas", "Fecha publicacion");
    foreach (var book in books)
    {
        Console.WriteLine("{0,-60}| {1, 10}| {2, 11}", book.Title, book.PageCount, book.PublishedDate.ToShortDateString());
    }
    Console.WriteLine($"\nTotal libros: {books.ToList().Count}");
}

using System.Text.Json;

namespace Linq;

public class LinqQueries
{
    private List<Book> Books = new();
    public LinqQueries()
    {
        using (StreamReader reader = new StreamReader("books.json"))
        {
            string json = reader.ReadToEnd();
            Books = JsonSerializer.Deserialize<List<Book>>(json, new JsonSerializerOptions() { PropertyNameCaseInsensitive = true })!;
        }
    }

    public IEnumerable<Book> GetAllBooks() => Books;

    public IEnumerable<Book> BooksAfter2000() =>
        Books.Where(b => b.PublishedDate.Year > 2000).OrderBy(b => b.PublishedDate.Year);

    public IEnumerable<Book> GetBooksFromQuery(Func<Book, bool> filter, Func<Book, IComparable> orderBy)
        => Books.Where(filter).OrderBy(orderBy);

    public IEnumerable<Book> GetBooksFromQuery(Func<Book, bool> filter, Func<Book, IComparable> orderBy, bool ascending)
    {
        var books = Books.Where(filter);
        return ascending ? books.OrderBy(orderBy) : books.OrderByDescending(orderBy);
    }
}

Joel Angel David Barrantes Palacios

Estudiante

Desde mi punto de vista estas deben ser las implementaciones usando linq:

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

        //linq query
        return from book in CollectionBook where book.Categories.Contains(category) orderby book.Title select book;
    }

    public IEnumerable<Book> GetBooksByPagesAndSortedDescending(int pages)
    {
        //extension method
        // return CollectionBook.Where(book => (book.PageCount ?? 0) > pages).OrderByDescending(book => book.PageCount);

        //linq query
        return from book in CollectionBook where book.PageCount > pages orderby book.PageCount descending select book;
    }

Miguel Angel Reyes Moreno

Estudiante

query con c# y linq:

public IEnumerable<Book> LibrosMasDeXPaginasDescendente(int pages)
        {
            return librosCollection.Where(book => book.PageCount > pages).OrderByDescending(book => book.PageCount);
        }

usando el método:

//* Libros de Java - Ordenados por nombre descendente
        ImprimirValores(queries.LibrosMasDeXPaginasDescendente(450));

output: Titulo N. Paginas Fecha publicacion

JavaScript: The Definitive Guide 706 06/06/2020 Python and Tkinter Programming 688 01/01/2000 GWT in Action 632 01/06/2007 Android in Action, Second Edition 592 14/01/2011 Flexible Rails 592 01/01/2008 OSGi in Action 576 06/04/2011 Up to Speed with Swing, Second Edition 560 01/10/1999 Brownfield Application Development in .NET 550 16/04/2010 Pool and DBCP: Creating and Using Object Pools 521 01/03/2005 Grails in Action 520 01/05/2009 Distributed Application Development with PowerBuilder 6.0 504 01/06/1998

JUAN DAVID MARTINEZ GONZALEZ

Estudiante

using System.Security.Cryptography.X509Certificates;
using System.Linq;


public class LinqQueries
{

    private List<Book> librosCollection = new List<Book>();

    public LinqQueries()
    {
        using(StreamReader reader = new StreamReader("books.json"))
        {
            string json = reader.ReadToEnd();
            this.librosCollection = System.Text.Json.JsonSerializer.Deserialize<List<Book>>(json, new System.Text.Json.JsonSerializerOptions() {PropertyNameCaseInsensitive = true});
        }
    }

    public IEnumerable<Book> TodaLaColeccion()
    {
        return librosCollection;
    }

    public IEnumerable<Book> ListaLibrosDespues2000()
    {
         // ---> Extension method
        //return this.librosCollection.Where(lib => lib.PublishedDate.Year > 2000);


        // ---> Extension spresion
        return from list in this.librosCollection where list.PublishedDate.Year > 2000 select list;
    }

    public IEnumerable<Book> ListaLibrosMasd250PagConPalabrasInAction()
    {
        // ---> Extension method
        //return this.librosCollection.Where(p => p.PageCount > 250 && p.Title.Contains("in Action"));

        // ---> Extension method
        return from lista in this.librosCollection where lista.PageCount > 250 && lista.Title.Contains("in Action") select lista;

    }
 
    public bool TodosLibrosTienenStatus()
    {
        return librosCollection.All(x => x.Status != string.Empty);
    }

    public bool TodosLibrosPublicadosAnio2005()
    {
        return librosCollection.Any(x => x.PublishedDate.Year > 2005);
    }

    public IEnumerable<Book> CategoriasMicrosoft()
    {
        return librosCollection.Where(x => x.Categories.Contains("Microsoft .NET"));
    }

    public IEnumerable<Book> CategoriasJava()
    {
        return librosCollection.Where(x => x.Categories.Contains("Java")).OrderBy(x => x.Title);
    }

    public IEnumerable<Book> TodosLibrosMasd450Pag()
    {
        return librosCollection.Where(x => x.PageCount > 450).OrderByDescending(x => x.PageCount);
    }

}

using System.Xml.Serialization;
using System.Net.Mime;
// See https://aka.ms/new-console-template for more information
LinqQueries queries = new LinqQueries();

//ImprimirValores(queries.TodaLaColeccion());
//ImprimirValores(queries.ListaLibrosDespues2000());

// LIBROS QUE TIENE MAS DE 250 PAG Y TIENE EN EL TITULO LA PALABRAS IN ACTION
//ImprimirValores(queries.ListaLibrosMasd250PagConPalabrasInAction());

Console.WriteLine($"{queries.TodosLibrosTienenStatus()}");

Console.WriteLine("=====================================");

Console.WriteLine($"{queries.TodosLibrosPublicadosAnio2005()}");

Console.WriteLine("=====================================");

ImprimirValores(queries.CategoriasMicrosoft());

Console.WriteLine("=====================================");

ImprimirValores(queries.CategoriasJava());

Console.WriteLine("=====================================");

ImprimirValores(queries.TodosLibrosMasd450Pag());

void ImprimirValores(IEnumerable<Book> listadelibros)
{
    Console.WriteLine("{0,-60} {1, 15} {2, 15}\n", "Titulo", "N. Paginas", "Fecha publicacion");
    foreach(var item in listadelibros)
    {
        Console.WriteLine("{0,-60} {1, 15} {2, 15}", item.Title, item.PageCount, item.PublishedDate.ToShortDateString());
    }
}```

Jimmy Alexander Soza Ortiz

Estudiante

Con query expresion sería asi:

public IEnumerable<Book> BooksJavaForName(){
   return (from b in librosCollection where b.Categories.Contains("Java") orderby b.Title select b);
}

public IEnumerable<Book> BooksMajor450Pages(){
   return from b in librosCollection where b.PageCount > 450 orderby b.PageCount descending select b;
}

Operadores OrderBy y OrderByDescending

Introducción

Bienvenida al curso

Prerrequisitos

¿Qué es LINQ?

Programación declarativa vs. imperativa

Utilizando LINQ por primera vez

Configuración de proyecto

Creando el proyecto base

Configurando clases

Importando datos

Operadores básicos

Usando el operador Where

CLASE EN ACTUALIZACIÓN (sáltala y avanza a la siguiente)- Ejercicio para aplicar el operador Where

Operadores All y Any

Operador Contains

Operadores OrderBy y OrderByDescending

CLASE EN ACTUALIZACIÓN (sáltala y avanza a la siguiente)- Ejercicio operador OrderBy

Operadores Take y Skip

Selección dinámica de datos

Operadores de agregación

Operadores LongCount y Count

Operadores Min y Max

Operadores MinBy y MaxBy

Operadores Sum y Aggregate

Operador Average

Agrupamiento de datos

Cláusula GroupBy

Ejercicio cláusula GroupBy

Cláusula Lookup

Cláusula Join

Cierre de curso

Recapitulación sobre LINQ