Get sumę dwóch kolumn w jednej kwerendzie LINQ

Question

powiedzmy, że mam tabeli o nazwie przedmioty (ID int Sporządzono int, Total int)

mogę to zrobić przez dwa zapytania:

int total = m.Items.Sum(p=>p.Total) 
int done = m.Items.Sum(p=>p.Done) 

Ale chciałbym to zrobić w jednym zapytaniu, coś takiego:

var x = from p in m.Items select new { Sum(p.Total), Sum(p.Done)}; 

pewnością istnieje sposób, aby wywołać funkcje agregujące od składni LINQ ...?

Answer 1

będzie to rade:

from p in m.Items 
group p by 1 into g 
select new 
{ 
    SumTotal = g.Sum(x => x.Total), 
    SumDone = g.Sum(x => x.Done) 
}; 

Answer 2

z klasą pomocnik krotki, albo własne lub — w .NET 4 — tych standardowych można to zrobić:

var init = Tuple.Create(0, 0); 

var res = m.Items.Aggregate(init, (t,v) => Tuple.Create(t.Item1 + v.Total, t.Item2 + v.Done)); 

I res.Item1 to suma kolumny Total i res.Item2 kolumny Done .

Answer 3

Jak o

m.Items.Select(item => new { Total = item.Total, Done = item.Done }) 
      .Aggregate((t1, t2) => new { Total = t1.Total + t2.Total, Done = t1.Done + t2.Done }); 

Answer 4

Podsumowując tabeli grupy przez stałą:

from p in m.Items 
group p by 1 into g 
select new { 
    SumTotal = g.Sum(x => x.Total), 
    SumDone = g.Sum(x => x.Done) 
} 

Answer 5

zastanawianie się, gdzie do wyodrębnienia kwot lub inny agregat w pozostałej części mojego kodu wprawiał mnie w zakłopotanie, dopóki nie przypomniałem sobie, że zmienna, którą skonstruowałem, była powtarzalna. Załóżmy, że mamy tabelę w naszej bazie danych składa się z zakonów, i chcemy produkować podsumowanie dla firmy ABC:

var myResult = from g in dbcontext.Ordertable 
       group p by (p.CUSTNAME == "ABC") into q // i.e., all of ABC company at once 
       select new 
{ 
    tempPrice = q.Sum(x => (x.PRICE ?? 0m)), // (?? makes sure we don't get back a nullable) 
    tempQty = q.Sum(x => (x.QTY ?? 0m)) 
}; 

Teraz część zabawy - tempPrice i tempQty nie są deklarowane wszędzie, ale muszą one być częścią z myResult, nie? Uzyskaj do nich dostęp w następujący sposób:

Console.Writeline(string.Format("You ordered {0} for a total price of {1:C}", 
           myResult.Single().tempQty, 
           myResult.Single().tempPrice)); 

Można również użyć wielu innych metod Queryable.

Answer 6

//Calculate the total in list field values 
//Use the header file: 

Using System.Linq; 
int i = Total.Sum(G => G.First); 

//By using LINQ to calculate the total in a list field, 

var T = (from t in Total group t by Total into g select g.Sum(t => t.First)).ToList(); 

//Here Total is a List and First is the one of the integer field in list(Total) 

Answer 7

Podczas korzystania grupę przez LINQ tworzy nowy zbiór elementów więc masz dwa zbiory przedmiotów.

Oto rozwiązanie obu problemów:

1. zsumowanie dowolną ilość członków w jednej iteracji i
2. uniknąć powielania kolekcja Twojego itemu

Kod:

public static class LinqExtensions 
{ 
    /// <summary> 
    /// Computes the sum of the sequence of System.Double values that are obtained 
    /// by invoking one or more transform functions on each element of the input sequence. 
    /// </summary> 
    /// <param name="source">A sequence of values that are used to calculate a sum.</param> 
    /// <param name="selectors">The transform functions to apply to each element.</param>  
    public static double[] SumMany<TSource>(this IEnumerable<TSource> source, params Func<TSource, double>[] selectors) 
    { 
    if (selectors.Length == 0) 
    { 
     return null; 
    } 
    else 
    { 
     double[] result = new double[selectors.Length]; 

     foreach (var item in source) 
     { 
     for (int i = 0; i < selectors.Length; i++) 
     { 
      result[i] += selectors[i](item); 
     } 
     } 

     return result; 
    } 
    } 

    /// <summary> 
    /// Computes the sum of the sequence of System.Decimal values that are obtained 
    /// by invoking one or more transform functions on each element of the input sequence. 
    /// </summary> 
    /// <param name="source">A sequence of values that are used to calculate a sum.</param> 
    /// <param name="selectors">The transform functions to apply to each element.</param> 
    public static double?[] SumMany<TSource>(this IEnumerable<TSource> source, params Func<TSource, double?>[] selectors) 
    { 
    if (selectors.Length == 0) 
    { 
     return null; 
    } 
    else 
    { 
     double?[] result = new double?[selectors.Length]; 

     for (int i = 0; i < selectors.Length; i++) 
     { 
     result[i] = 0; 
     } 

     foreach (var item in source) 
     { 
     for (int i = 0; i < selectors.Length; i++) 
     { 
      double? value = selectors[i](item); 

      if (value != null) 
      { 
      result[i] += value; 
      } 
     } 
     } 

     return result; 
    } 
    } 
} 

Oto sposób, w jaki musisz dokonać podsumowania:

double[] result = m.Items.SumMany(p => p.Total, q => q.Done); 

Oto ogólny przykład:

struct MyStruct 
{ 
    public double x; 
    public double y; 
} 

MyStruct[] ms = new MyStruct[2]; 

ms[0] = new MyStruct() { x = 3, y = 5 }; 
ms[1] = new MyStruct() { x = 4, y = 6 }; 

// sum both x and y members in one iteration without duplicating the array "ms" by GROUPing it 
double[] result = ms.SumMany(a => a.x, b => b.y); 

jak widać

result[0] = 7 
result[1] = 11 

Answer 8

Zostało już odpowiedział, ale inne odpowiedzi będą jeszcze zrobić wiele iteracji nad kolekcji (kilka połączeń to Sum) lub utworzyć wiele pośrednich obiektów/krotek, które mogą być w porządku, ale jeśli nie, możesz utworzyć metodę rozszerzenia (lub wielokrotność), która robi to w staroświecki sposób, ale dobrze pasuje do wyrażenia LINQ.

Taka metoda rozszerzenie będzie wyglądać następująco:

public static Tuple<int, int> Sum<T>(this IEnumerable<T> collection, Func<T, int> selector1, Func<T, int> selector2) 
{ 
    int a = 0; 
    int b = 0; 

    foreach(var i in collection) 
    { 
     a += selector1(i); 
     b += selector2(i); 
    } 

    return Tuple.Create(a, b); 
} 

I można go używać tak:

public class Stuff 
{ 
    public int X; 
    public int Y; 
} 

//... 

var stuffs = new List<Stuff>() 
{ 
    new Stuff { X = 1, Y = 10 }, 
    new Stuff { X = 1, Y = 10 } 
}; 

var sums = stuffs.Sum(s => s.X, s => s.Y);