Les comparto dos de las formas que considero
y como lo utilizo
El resultado es el mismo en ambos casos
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
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Operadores Sum y Aggregate
20/26Recursos
Aportes 16
Preguntas 0
Ordenar por:
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
Operador Aggregate
Se usa para realizar la acumulación de algún dato dentro de una variable y retornar este valor acumulado.
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)}");
Excelente el aggregate, estas dos son muy utiles.
Aggregate = Concatenar
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;
});
}
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.
```js
public string TituloLibrosFechaPublicacionpost2015()
{
return librosCollection
.Where(p => p.PublishedDate.Year > 2015)
.Aggregate("", (result, book) => result + book.Title + ", ");
}
```
```c#
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;
});
}
```
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;
});
}
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;
}
Solución sin “if”:
public int SumaCantidadPaginas(){
return libros.Where(p=>p.PageCount>=0 && p.PageCount<=500).Sum(p=>p.PageCount);
}
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;
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?