Operadores Sum y Aggregate

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:0013:24

Operadores Sum y Aggregate

Curso de Manejo de Datos en C# con LINQ

Clase 20 de 26

Clase 20 / 26

Miguel Santiago Gómez Suárez

Hace 4 años

Les comparto cómo se resolvería el primer reto con el comando Aggregate:

public int SumaDeTodasLasPaginasLibrosEntre0y500()
    {
        return librosCollection.Where(p => p.PageCount >= 0 && p.PageCount <= 500)
        .Aggregate(0, (ValorSumado, next) => 
        {
            if(ValorSumado > 0) ValorSumado += next.PageCount;
            else ValorSumado += next.PageCount;
            return ValorSumado;
        });
    }

Rolando Fernández

Hace 4 años

Podrías omitir la consulta de ValorSumado > 0 porque se puede sumar un 0 con un valor X, fíjate que tanto dentro del IF como en el ELSE estás haciendo exactamente lo mismo. Por otro lado lo que podrías consultar en el IF es si el next.PageCount tiene valor para que no intente sumar ValorSumado con un null por ejemplo, en la lista de books que tenemos sabemos que no hay nulls pero en un ambiente laboral podría suceder.

Miguel Santiago Gómez Suárez

Hace 4 años

Tienes toda la razón, en realidad cuando copie el código no noté que estaba haciendo esas líneas innecesarias. Creo que fue por hacer todo automático. Algo mejor sería así

public int SumaDeTodasLasPaginasLibrosEntre0y500()
    {
        return librosCollection.Where(p => p.PageCount >= 0 && p.PageCount <= 500)
        .Aggregate(0, (ValorSumado, next) => 
        {
            ValorSumado += next.PageCount;
            return ValorSumado;
        });
    }```

Comentarios (19)19 comentarios

Mairon Andres Florez Alvarez

Valeria Delgado

Ojalá se hubieran abordado Func y Expression en este curso, ¡buen aporte!

Diego Andrés Castillo Ospina

Hace 3 años

Son tantas opciones que hace que uno se pierda a veces

Jimmy Buriticá Londoño

Operador Aggregate

Se usa para realizar la acumulación de algún dato dentro de una variable y retornar este valor acumulado.

Samuel Schulz

Para entenderlo más fácilmente:

Aggregate( valorInicialDelAcumulador, (Acumulador, Elemento), Funcion );

Definición: Aplica una función de acumulador a una secuencia. El valor de inicialización especificado se utiliza como valor inicial del acumulador y la función especificada se utiliza para seleccionar el valor resultante. https://learn.microsoft.com/es-es/dotnet/api/system.linq.enumerable.aggregate?view=net-7.0

José Juan Alcántara Rincón

Es como un reduce en otros lenguages

Oscar Fuentes Esteves

tampoco entiendo el reduce 😂

Miguel Angel Reyes Moreno

Pasando el año como parámetro:

public string LibrosDespuesDeAnioConcatedos(int anio)
        {
            return librosCollection
                .Where(book => book.PublishedDate.Year > anio)
                .Aggregate("", (TitulosLibros, next) =>
                    {
                        if(TitulosLibros != string.Empty)
                        {
                            TitulosLibros += " - " + next.Title;
                        }
                        else
                        {
                            TitulosLibros += next.Title;
                        }
                        return TitulosLibros;
                    }
                );
        }

//* Libros publicados después del 2015
        Console.WriteLine($"Libros publicados después del 2015: {queries.LibrosDespuesDeAnioConcatedos(2015)}");

Kenneth David Gaitan Evanks

Hace un año

La función Sum en LINQ se utiliza para calcular la suma de los valores de una colección, mientras que Aggregate permite realizar una operación más compleja, aplicando un acumulador a los elementos de la colección. Por ejemplo, Aggregate se puede usar para calcular sumas, promedios, o combinaciones personalizadas dependiendo del resultado que desees obtener. En resumen, Sum es específico para sumar, mientras que Aggregate es más flexible y permite diversas operaciones.

kolab Linkear

Gustavo Olmedo

Hace 2 años

Excelente el aggregate, estas dos son muy utiles.

Sabrina Sandí Quirós

Aggregate = Concatenar

Marta Maleyka Magallón Escobar

Es importante tener en cuenta que Aggregate puede usarse para realizar una variedad de operaciones de agregación, no solo sumas. Puedes definir cualquier lógica de agregación que necesites, lo que lo hace muy flexible para aplicaciones diversas.

En resumen, Sum() es una función útil en LINQ que permite calcular la suma de los valores en una secuencia, ya sea directamente en la secuencia o aplicando una proyección para obtener los valores relevantes antes de calcular la suma.

Betzabhe Elizabeth Vega Aliaga

public string TituloLibrosFechaPublicacionpost2015()
    {
        return librosCollection
            .Where(p => p.PublishedDate.Year > 2015)
            .Aggregate("", (result, book) => result + book.Title + ", ");
    }

Angel Qui

public int SumaPaginasConRango(int start = 0, int end = 500)
{
    return librosCollection
        .Where(p => p.PageCount >= start &&  p.PageCount <= end)
        .Sum(p => p.PageCount);
}

public string TitulosDeLibrosDespuesDel2015Concatenados()
{
    return librosCollection
        .Where(p => p.PublishedDate.Year > 2015)
        .Aggregate("", (TitulosLibros, next) =>
        {
            if (TitulosLibros != string.Empty)
                TitulosLibros += " - " + next.Title;
            else
                TitulosLibros = next.Title;
            return TitulosLibros;
    });
}

Alexis Gamaliel Sotelo Valdez

Asi me quedó el primer ejercicio de suma de páginas con Aggregate

public int GetSumOfPagesBetween0and500WithAggregate(){
        return booksCollection
        .Where(p => p.PageCount >0 &&p.PageCount<=500)
        .Aggregate(0,(book,nextBook) =>{
            book += nextBook.PageCount;
            return book;
        });
    }

JUAN DAVID MARTINEZ GONZALEZ

public int SumaTotalPaginasLibros()
    {
        //---->> Extension Method <<------
       // return librosCollection.Where(su => su.PageCount>0).Sum(sum => sum.PageCount);


        //---->> Extension Query <<------
       int suma = (from su 
                   in librosCollection 
                   where su.PageCount>0 
                   select su).Sum(x => x.PageCount);

      return suma;
    }

Rafael Varela Pérez

Solución sin "if":

Ricardo Mejía

public int SumaCantidadPaginas(){ return libros.Where(p=>p.PageCount>=0 && p.PageCount<=500).Sum(p=>p.PageCount); }

Luca Cristian Manea

Una version un ppoco mas reducida del codigo
return books.Where(p=>p.PublishedDate.Year> 2015).Aggregate("",(booksTitle, next)=>{ return booksTitle.Equals(string.Empty)?booksTitle +=next.Title :booksTitle+=" - "+next.Title;

Andres Felipe Narvaez Cabrera

Les comparto otra forma de usar el operador Sum. Usando la sobrecarga de metodos, se puede pasar un predicado para que evalue mientras suma en cada iteracion. Se obtiene el mismo resultado 😁

Jonathan Harley Sabogal toro

pero estas usando mas lineas de código con lo que puedes hacer con una

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 Sum y Aggregate

Progreso del curso

Introducción

Configuración de proyecto

Operadores básicos

Operadores de agregación

Agrupamiento de datos

Cierre de curso