Agrupar por várias colunas

Como posso fazer GroupBy várias colunas no LINQ

Algo semelhante a isso no SQL:

SELECT * FROM <TableName> GROUP BY <Column1>,<Column2>

Como posso converter isso para LINQ:

QuantityBreakdown
(
    MaterialID int,
    ProductID int,
    Quantity float
)

INSERT INTO @QuantityBreakdown (MaterialID, ProductID, Quantity)
SELECT MaterialID, ProductID, SUM(Quantity)
FROM @Transactions
GROUP BY MaterialID, ProductID

Use um tipo anônimo.

Por exemplo

group x by new { x.Column1, x.Column2 }

Amostra processual

.GroupBy(x => new { x.Column1, x.Column2 })

Ok, entendi como:

var query = (from t in Transactions
             group t by new {t.MaterialID, t.ProductID}
             into grp
                    select new
                    {
                        grp.Key.MaterialID,
                        grp.Key.ProductID,
                        Quantity = grp.Sum(t => t.Quantity)
                    }).ToList();

Para Agrupar por várias colunas, tente fazer isso ...

GroupBy(x=> new { x.Column1, x.Column2 }, (key, group) => new 
{ 
  Key1 = key.Column1,
  Key2 = key.Column2,
  Result = group.ToList() 
});

Da mesma maneira que você pode adicionar Coluna3, Coluna4 etc.

Desde o C # 7, você também pode usar tuplas de valor:

group x by (x.Column1, x.Column2)

ou

.GroupBy(x => (x.Column1, x.Column2))

C # 7.1 ou superior usando Tuplesand Inferred tuple element names(atualmente funciona apenas com linq to objectse não é suportado quando árvores de expressão são necessárias, por exemplo someIQueryable.GroupBy(...). Problema no Github ):

// declarative query syntax
var result = 
    from x in inMemoryTable
    group x by (x.Column1, x.Column2) into g
    select (g.Key.Column1, g.Key.Column2, QuantitySum: g.Sum(x => x.Quantity));

// or method syntax
var result2 = inMemoryTable.GroupBy(x => (x.Column1, x.Column2))
    .Select(g => (g.Key.Column1, g.Key.Column2, QuantitySum: g.Sum(x => x.Quantity)));

C # 3 ou superior usando anonymous types:

// declarative query syntax
var result3 = 
    from x in table
    group x by new { x.Column1, x.Column2 } into g
    select new { g.Key.Column1, g.Key.Column2, QuantitySum = g.Sum(x => x.Quantity) };

// or method syntax
var result4 = table.GroupBy(x => new { x.Column1, x.Column2 })
    .Select(g => 
      new { g.Key.Column1, g.Key.Column2 , QuantitySum= g.Sum(x => x.Quantity) });

Você também pode usar uma Tupla <> para um agrupamento fortemente tipado.

from grouping in list.GroupBy(x => new Tuple<string,string,string>(x.Person.LastName,x.Person.FirstName,x.Person.MiddleName))
select new SummaryItem
{
    LastName = grouping.Key.Item1,
    FirstName = grouping.Key.Item2,
    MiddleName = grouping.Key.Item3,
    DayCount = grouping.Count(), 
    AmountBilled = grouping.Sum(x => x.Rate),
}

Embora esta pergunta esteja perguntando sobre agrupar por propriedades de classe, se você deseja agrupar por várias colunas em um objeto ADO (como uma DataTable), você deve atribuir seus "novos" itens a variáveis:

EnumerableRowCollection<DataRow> ClientProfiles = CurrentProfiles.AsEnumerable()
                        .Where(x => CheckProfileTypes.Contains(x.Field<object>(ProfileTypeField).ToString()));
// do other stuff, then check for dups...
                    var Dups = ClientProfiles.AsParallel()
                        .GroupBy(x => new { InterfaceID = x.Field<object>(InterfaceField).ToString(), ProfileType = x.Field<object>(ProfileTypeField).ToString() })
                        .Where(z => z.Count() > 1)
                        .Select(z => z);

var Results= query.GroupBy(f => new { /* add members here */  });

.GroupBy(x => x.Column1 + " " + x.Column2)

.GroupBy(x => (x.MaterialID, x.ProductID))

agrupar x por novos {x.Col, x.Col}

Um ponto a ser observado é que você precisa enviar um objeto para expressões Lambda e não pode usar uma instância para uma classe.

Exemplo:

public class Key
{
    public string Prop1 { get; set; }

    public string Prop2 { get; set; }
}

Isso será compilado, mas gerará uma chave por ciclo .

var groupedCycles = cycles.GroupBy(x => new Key
{ 
  Prop1 = x.Column1, 
  Prop2 = x.Column2 
})

Se você não quiser nomear as propriedades-chave e depois recuperá-las, poderá fazê-lo assim. Isso funcionará GroupBycorretamente e fornecerá as principais propriedades.

var groupedCycles = cycles.GroupBy(x => new 
{ 
  Prop1 = x.Column1, 
  Prop2= x.Column2 
})

foreach (var groupedCycle in groupedCycles)
{
    var key = new Key();
    key.Prop1 = groupedCycle.Key.Prop1;
    key.Prop2 = groupedCycle.Key.Prop2;
}

Para VB e anônimo / lambda :

query.GroupBy(Function(x) New With {Key x.Field1, Key x.Field2, Key x.FieldN })