Obtenir la somme d'une valeur dans Linq

Question

Compte tenu de la structure suivante ...

class Foo { 

    public string Category { get; set; } 
    public string Code { get; set; } 
    public int Quantity { get; set; } 

} 

Je suis en train d'utiliser LINQ pour résumer une liste de ces objets par catégorie et par code, de sorte que si je fournir les renseignements suivants source ...

List<Foo> foos = new List<Foo>() { 
    new Foo {Category = @"A", Code = @"B", Quantity = 1}, 
    new Foo {Category = @"A", Code = @"B", Quantity = 2}, 
    new Foo {Category = @"C", Code = @"D", Quantity = 3}, 
    new Foo {Category = @"C", Code = @"D", Quantity = 4} 
}; 

je me retrouve avec une liste contenant ...

Foo {Category = @"A", Code = @"B", Quantity = 3}, 
    Foo {Category = @"C", Code = @"D", Quantity = 7} 

(où la quantité est la somme des q d'origine uantités des objets correspondants).

Je sais que j'ai besoin d'utiliser une combinaison de la clause group by et les méthodes d'extension Sum(), je ne semble pas être en mesure de trouver cette combinaison correcte.

S'il vous plaît noter, il n'y a pas de base de données derrière cette liste, je le fais purement avec des objets afin d'extraire la liste d'origine, y compris la somme n'est pas une option.

Merci.

Answer 1

var query = foos 
      .GroupBy(x => new { x.Category, x.Code }) 
      .Select(g => new Foo 
       { 
        Category = g.Key.Category, 
        Code = g.Key.Code, 
        Quantity = g.Sum(x => x.Quantity) 
       }); 

Answer 2

LINQ Merging results in rows est très similaire: -

 var result = foos 
      .GroupBy(foo => new 
      { 
       foo.Category, 
       foo.Code 
      }) 
      .Select(fooGroup => new Foo 
      { 
       Category = fooGroup.Key.Category, 
       Code = fooGroup.Key.Code, 
       Quantity = fooGroup.Sum(foo => foo.Quantity) 
      }); 

Answer 3

Vous voulez regrouper à la fois par la catégorie et le code, donc vous voulez un type anonyme pour que - alors que la somme des quantités. Vous pouvez le faire dans un seul appel à GroupBy si vous utilisez le right overload:

var query = list.GroupBy(
    item => new { item.Category, item.Code }, 
    (key, group) => new Foo { Category = key.Category, 
           Code = key.Code, 
           Quantity = group.Sum(x => x.Quantity) }); 

Si vous voulez faire cela avec une expression de requête, vous pouvez utiliser:

var query = from item in list 
      group item by new { item.Category. item.Code } into items 
      select new Foo { Category = items.Key.Category, 
          Code = items.Key.Code, 
          Quantity = items.Sum(x => x.Quantity) });