Operadores Sum y Aggregate

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

Mairon Andres Florez Alvarez

student•

Les comparto dos de las formas que considero

y como lo utilizo

El resultado es el mismo en ambos casos

Valeria Delgado

student•

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

Diego Andrés Castillo Ospina

student•

Son tantas opciones que hace que uno se pierda a veces

Samuel Schulz

student•

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

student•

Es como un reduce en otros lenguages

Oscar Fuentes Esteves

student•

tampoco entiendo el reduce 😂

Jimmy Buriticá Londoño

student•

Operador Aggregate

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

Miguel Angel Reyes Moreno

student•

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

student•

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

student•

Gustavo Olmedo

student•

Excelente el aggregate, estas dos son muy utiles.

Sabrina Sandí Quirós

student•

Aggregate = Concatenar

Miguel Santiago Gómez Suárez

student•

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

student•

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

student•

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

Marta Maleyka Magallón Escobar

student•

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.

Marta Maleyka Magallón Escobar

student•

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

student•

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

Angel Qui

student•

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

student•

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

student•

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

student•

Solución sin "if":

Ricardo Mejía

student•

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

Luca Cristian Manea

student•

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;

Mairon Andres Florez Alvarez

student•

Una version un poco mas reducida y con mayor posibilidad para filtrar

public string TitulosSeparadosGuion(Func<Book, bool> where)
    => string.Join(" - ", this._librosLt.Where(where).Select(x => x.Title));

Uso o invocacion del metodo:

LinqQueries queries = new LinqQueries();

var titulos = queries.TitulosSeparadosGuion(x => x.PublishedDate.Year > 2005 && x.Title != string.Empty);

Console.WriteLine(titulos);

Andres Felipe Narvaez Cabrera

student•

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

student•

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

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

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

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

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

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

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

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

Operadores Sum y Aggregate

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