SUM múltiple utilizando LINQ

Question

Tengo un ciclo como el siguiente, ¿puedo hacer lo mismo con múltiples SUM?

foreach (var detail in ArticleLedgerEntries.Where(pd => pd.LedgerEntryType == LedgerEntryTypeTypes.Unload && 
                   pd.InventoryType == InventoryTypes.Finished)) 
{ 
    weight += detail.GrossWeight; 
    length += detail.Length; 
    items += detail.NrDistaff; 
} 

Answer 1

punto de vista técnico, lo que tienes es probablemente la forma más eficiente de haz lo que estás preguntando Sin embargo, se podría crear un método de extensión en IEnumerable <T> llamado a cada uno que podría hacerlo más sencillo:

public static class EnumerableExtensions 
{ 
    public static void Each<T>(this IEnumerable<T> col, Action<T> itemWorker) 
    { 
     foreach (var item in col) 
     { 
      itemWorker(item); 
     } 
    } 
} 

y lo llaman así:

// Declare variables in parent scope 
double weight; 
double length; 
int items; 

ArticleLedgerEntries 
    .Where(
     pd => 
      pd.LedgerEntryType == LedgerEntryTypeTypes.Unload && 
      pd.InventoryType == InventoryTypes.Finished 
    ) 
    .Each(
     pd => 
     { 
      // Close around variables defined in parent scope 
      weight += pd.GrossWeight; 
      lenght += pd.Length; 
      items += pd.NrDistaff; 
     } 
    ); 

ACTUALIZACIÓN: Sólo una nota adicional. El ejemplo anterior se basa en un cierre. Las variables peso, longitud y elementos deben declararse en un ámbito principal, lo que les permite persistir más allá de cada llamada a la acción itemWorker. He actualizado el ejemplo para reflejar esto por claridad.

Answer 2

Puede llamar Sum tres veces, pero será más lento, ya que hará tres bucles.

Por ejemplo:

var list = ArticleLedgerEntries.Where(pd => pd.LedgerEntryType == LedgerEntryTypeTypes.Unload 
            && pd.InventoryType == InventoryTypes.Finished)) 

var totalWeight = list.Sum(pd => pd.GrossWeight); 
var totalLength = list.Sum(pd => pd.Length); 
var items = list.Sum(pd => pd.NrDistaff); 

Debido a la ejecución retardada, que también volverá a evaluar la Where llamada cada vez, aunque eso no es un problema tal en su caso. Esto podría evitarse llamando al ToArray, pero eso causará una asignación de matriz. (Y todavía correría tres bucles)

Sin embargo, a menos que tenga una gran cantidad de entradas o esté ejecutando este código en un bucle cerrado, no necesita preocuparse por el rendimiento.

---

EDITAR: Si realmente desea utilizar LINQ, se podría mal uso Aggregate, así:

int totalWeight, totalLength, items; 

list.Aggregate((a, b) => { 
    weight += detail.GrossWeight; 
    length += detail.Length; 
    items += detail.NrDistaff; 
    return a; 
}); 

Este es el código extraordinariamente feo, pero debe realizar casi tan bien como lazo recto.

También podría sumar en el acumulador, (vea el ejemplo a continuación), pero esto asignaría un objeto temporal para cada elemento en su lista, lo cual es una idea tonta. (Los tipos anónimos son inmutables)

var totals = list.Aggregate(
    new { Weight = 0, Length = 0, Items = 0}, 
    (t, pd) => new { 
     Weight = t.Weight + pd.GrossWeight, 
     Length = t.Length + pd.Length, 
     Items = t.Items + pd.NrDistaff 
    } 
); 

Answer 3

Usted sería capaz de hacer esto al estilo de pivote, usando la respuesta en este tema: Is it possible to Pivot data using LINQ?

Answer 4

Ok. Me doy cuenta de que no hay una manera fácil de hacerlo con LINQ. Tomaré may foreach loop porque entendí que no es tan malo. Gracias a todos ustedes

Answer 5

Usted también podría agrupar por cierto - 1 (que en realidad está incluido cualquiera de los artículos y luego tener que contar o summered):

var results = from x in ArticleLedgerEntries 
         group x by 1 
         into aggregatedTable 
         select new 
            { 
             SumOfWeight = aggregatedTable.Sum(y => y.weight), 
             SumOfLength = aggregatedTable.Sum(y => y.Length), 
             SumOfNrDistaff = aggregatedTable.Sum(y => y.NrDistaff) 
            }; 

En cuanto a tiempo de encendido, se casi tan bueno como el bucle (con una adición constante).