Operadores MinBy y MaxBy

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

Luca Cristian Manea

student•

posible solucion al caso de que nos devuelva un null public Book? lowerPageNumberBook(IEnumerable<Book> books){ return books.Where(b=>b.PageCount>0).FirstOrDefault() is null? new Book(): books.Where(b=>b.PageCount>0).MinBy(b=>b.PageCount); }

public Book? recentPublishDateBook(IEnumerable<Book> books){
    return books.MaxBy(b=>b.PublishedDate) is null? new Book(): books.MaxBy(b=>b.PublishedDate);
}

Leonardo Valdivieso

student•

podriamos buscar el libro y si es null devolvemos un libro vacío con new Book(); así no realizamos dos consultas parecidas.

JUAN ESTEBAN MORENO NORIEGA

student•

Si la función retorna un nullable, no es buena práctica hacer algo dentro de esta función con el nullable, pues se supone que si retorna null, la idea es hacer algo en el lugar en donde se ejecuta el método

Jorge Gonzales

student•

creo que se debería profundizar un poco mas y hacer consultas linq un poco mas complejas .

Boris Vargas Paucara

student•

Podria dar un ejemplo ?

Jimmy Buriticá Londoño

student•

Operadores MinBy y MaxBy

Nos permiten obtener el objeto que cumple una condición especifica.

José Ángel Soriano Soriano

student•

muy bueno el curso...

Rolando Fernández

student•

public IEnumerable<Book> GetBookMinPageCountNonZero()
    {
        return new List<Book>().Append(booksCollection.Where(p => p.PageCount > 0).MinBy(p => p.PageCount)!);
    }

    public IEnumerable<Book> GetBookMaxPublishedDate()
    {
        return new List<Book>().Append(booksCollection.MaxBy(p => p.PublishedDate)!);
    }

Retorno una lista para reutilizar la función que imprime los resultados y agrego el signo de exclamación al final para indicar que el valor de la consulta puede ser null.

Marta Maleyka Magallón Escobar

student•

Min se usa para encontrar el valor mínimo en una secuencia de elementos, mientras que MinBy se usa para encontrar el elemento que tiene el valor mínimo basado en una función de selección específica. La última requiere una biblioteca adicional como MoreLINQ para ser utilizada.

Leonardo Valdivieso

student•

y que pasa cuando hay varios libros con la misma cantidad de páginas y es la cantidad mayor? Retorna un libro cualquiera o retorna una colección de libros?

Miguel Teheran

teacher•

normalmente el hace un query sobre la lista, quedan los que tienen el mismo valor y luego ordena por otro campo generalmente es el ID o key, si quieres uno especifico puedes ordenar por nombre y luego hacer el MinBy o MaxBy

Kenneth David Gaitan Evanks

student•

En C#, los tipos de datos se dividen en dos categorías principales: primitivos y complejos.

Tipos Primitivos:

int: Números enteros.
double: Números decimales de doble precisión.
char: Un solo carácter.
bool: Valores de verdadero o falso.
string: Secuencias de caracteres (aunque se puede considerar un tipo complejo).

Tipos Complejos:

Arrays: Colecciones de elementos del mismo tipo.
Clases: Plantillas para crear objetos que pueden contener datos y métodos.
Estructuras: Tipos de datos que pueden contener varios campos.

Ambos tipos son esenciales para manipular datos en C# usando LINQ.

Andrés Medina

student•

Resumiendo:

Min y Max devuelven valores primitivos
MinBy y MaxBy devuelven tipos complejos

Joan Alexander Valerio Rodríguez

student•

Les comparto mi solución utilizando Extension Method y Query Expression 🤓

- MinBy
				//Extension Method
        return BooksCollections
            .Where(p => p.PageCount > 0)
            .MinBy(p => p.PageCount);
        
        //Query Expression
        var query = (from p in BooksCollections
                          where p.PageCount > 0
                          select p)
                          .MinBy(p => p.PageCount);
        
        if (query != null)
            Console.WriteLine($"This is the book with less pages: {query.Title} -  Quantity pages: {query.PageCount}");
        else
            Console.WriteLine("Not record found");
        
        return query;
        
- MaxBy
				//Extension Method
        return BooksCollections
            .MaxBy(P => P.PublishedDate);
        
        //Query Expression
        var query = (from p in BooksCollections
                          select p).MaxBy(p => p.PublishedDate);
        
        if (query != null)
            Console.WriteLine($"Book recent published date: {query.Title} - Date published: {query.PublishedDate.ToShortDateString()}");
        else
            Console.WriteLine("Not record found");

        return query;

Angel Qui

student•

public Book LibroConMenosPaginasNoCero()
{
    return librosCollection
        .Where(p => p.PageCount > 0)
        .MinBy(p => p.PageCount);
}

public Book LibroMasReciente()
{
    return librosCollection
        .MaxBy(p => p.PublishedDate);
}

Jerry Lee Minotta Rebellón

student•

Una buena opción es modificar la función ImprimirValores() para que pueda recibir una colección y/o un solo objeto Book. Así podremos usar la misma función para seguir imprimiendo las propiedades del Book(s) en "columnas":


void ImprimirValores(IEnumerable<Book> listBooks, Book OrgBook)
{
    Console.WriteLine("{0,-60} {1,15} {2,15}\n", "Titulo", "N paginas", "Fecha Publicacion");
    if (listBooks != null)
    {
        foreach (Book book in listBooks)
        {
            Console.WriteLine("{0,-60} {1,15} {2,15}", book.Title, book.PageCount, book.PublishedDate.ToShortDateString());
        }

    }
    else if (OrgBook != null)
    {
        Console.WriteLine("{0,-60} {1,15} {2,15}", OrgBook.Title, OrgBook.PageCount, OrgBook.PublishedDate.ToShortDateString());
    }
}

Para usarlo solo pasamos la colección o el objeto y la otra propiedad en null:


ImprimirValores(null, queries.BookMinPages());

public IEnumerable<Book> GetBookMinPageCountNonZero()
    {
        return new List<Book>().Append(booksCollection.Where(p => p.PageCount > 0).MinBy(p => p.PageCount)!);
    }

    public IEnumerable<Book> GetBookMaxPublishedDate()
    {
        return new List<Book>().Append(booksCollection.MaxBy(p => p.PublishedDate)!);
    }

- MinBy
				//Extension Method
        return BooksCollections
            .Where(p => p.PageCount > 0)
            .MinBy(p => p.PageCount);
        
        //Query Expression
        var query = (from p in BooksCollections
                          where p.PageCount > 0
                          select p)
                          .MinBy(p => p.PageCount);
        
        if (query != null)
            Console.WriteLine($"This is the book with less pages: {query.Title} -  Quantity pages: {query.PageCount}");
        else
            Console.WriteLine("Not record found");
        
        return query;
        
- MaxBy
				//Extension Method
        return BooksCollections
            .MaxBy(P => P.PublishedDate);
        
        //Query Expression
        var query = (from p in BooksCollections
                          select p).MaxBy(p => p.PublishedDate);
        
        if (query != null)
            Console.WriteLine($"Book recent published date: {query.Title} - Date published: {query.PublishedDate.ToShortDateString()}");
        else
            Console.WriteLine("Not record found");

        return query;

public Book LibroConMenosPaginasNoCero()
{
    return librosCollection
        .Where(p => p.PageCount > 0)
        .MinBy(p => p.PageCount);
}

public Book LibroMasReciente()
{
    return librosCollection
        .MaxBy(p => p.PublishedDate);
}

void ImprimirValores(IEnumerable<Book> listBooks, Book OrgBook)
{
    Console.WriteLine("{0,-60} {1,15} {2,15}\n", "Titulo", "N paginas", "Fecha Publicacion");
    if (listBooks != null)
    {
        foreach (Book book in listBooks)
        {
            Console.WriteLine("{0,-60} {1,15} {2,15}", book.Title, book.PageCount, book.PublishedDate.ToShortDateString());
        }

    }
    else if (OrgBook != null)
    {
        Console.WriteLine("{0,-60} {1,15} {2,15}", OrgBook.Title, OrgBook.PageCount, OrgBook.PublishedDate.ToShortDateString());
    }
}

Operadores MinBy y MaxBy

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