Operadores MinBy y MaxBy

Contenido del curso

Introducción

Configuración de proyecto

Operadores básicos

Operadores de agregación

Agrupamiento de datos

Cierre de curso

26
Recapitulación sobre LINQ
03:20 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0011:09

Operadores MinBy y MaxBy

Curso de Manejo de Datos en C# con LINQ

Clase 19 de 26

Clase 19 / 26

Comentarios (12)12 comentarios

Luca Cristian Manea

Hace 4 años

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

Hace 4 años

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

Hace 3 años

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

Hace 4 años

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

Boris Vargas Paucara

Hace 3 años

Podria dar un ejemplo ?

Jimmy Buriticá Londoño

Hace 4 años

Operadores MinBy y MaxBy

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

José Ángel Soriano Soriano

Hace 4 años

muy bueno el curso...

Rolando Fernández

Hace 4 años

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.

Kenneth David Gaitan Evanks

Hace un año

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.

Marta Maleyka Magallón Escobar

Hace 3 años

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

Hace 4 años

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

Profesor

Hace 4 años

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

Andrés Medina

Hace 2 años

Resumiendo:

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

Joan Alexander Valerio Rodríguez

Hace 2 años

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

Hace 3 años

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

Hace 3 años

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

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

Operadores MinBy y MaxBy

Progreso del curso

Introducción

Configuración de proyecto

Operadores básicos

Operadores de agregación

Agrupamiento de datos

Cierre de curso