Operadores OrderBy y OrderByDescending

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

Guillermo Restrepo Botero

student•

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

student•

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

Ivan Perez

student•

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

Jimmy Buriticá Londoño

student•

Operadores OrderBy y OrderByDescending

Nos permiten ordenar una colección usando cualquier criterio.

Tomás Morales

student•

¿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

teacher•

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

student•

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

student•

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

student•

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

student•

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;

David Jafet Espejel Vázquez

student••

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

student•

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

Miguel Teheran

teacher•

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

student•

Mi propuesta de Mejora:

Daniel Alberto Vega Bejarano

student•

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

student•

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

student•

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

student•

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

Betzabhe Elizabeth Vega Aliaga

student•

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

Angel Qui

student•

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

}

Brahim Brian

student•

<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

student•

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

student•

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

student•

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

student•

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

Luca Cristian Manea

student•

public List<Book> getByCategoryOrderBy(IEnumerable<Book> books){ return (from b in books where b.Categories.Contains("Java")orderby b.Title select b).ToList() ; }

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

Ejercicio para aplicar el operador Where

Operadores All y Any

Operador Contains

Operadores OrderBy y OrderByDescending

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