Regrouper par plusieurs colonnes

Comment puis-je faire plusieurs colonnes GroupBy dans LINQ

Quelque chose de similaire à cela dans SQL:

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

Comment puis-je le convertir en 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

Utilisez un type anonyme.

Par exemple

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

Échantillon procédural

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

Ok j'ai compris ceci:

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();

Pour Grouper par plusieurs colonnes, essayez ceci à la place ...

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

De la même manière, vous pouvez ajouter Colonne3, Colonne4, etc.

Depuis C # 7, vous pouvez également utiliser des tuples de valeur:

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

ou

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

C # 7.1 ou supérieur en utilisant Tupleset Inferred tuple element names(actuellement , il fonctionne uniquement avec linq to objectset il est pas pris en charge lorsque les arbres d'expression sont nécessaires , par exemple someIQueryable.GroupBy(...). Question 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 supérieur en utilisant 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) });

Vous pouvez également utiliser un Tuple <> pour un regroupement fortement typé.

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),
}

Bien que cette question concerne les propriétés de regroupement par classe, si vous souhaitez regrouper par plusieurs colonnes un objet ADO (comme un DataTable), vous devez affecter vos "nouveaux" éléments aux variables:

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))

groupe x par nouveau {x.Col, x.Col}

Une chose à noter est que vous devez envoyer un objet pour les expressions Lambda et ne pouvez pas utiliser une instance pour une classe.

Exemple:

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

    public string Prop2 { get; set; }
}

Cela compilera mais générera une clé par cycle .

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

Si vous ne voulez pas nommer les propriétés des clés puis les récupérer, vous pouvez le faire comme ceci à la place. Ce sera GroupBycorrectement et vous donnera les propriétés clés.

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;
}

Pour VB et anonyme / lambda :

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