Est-il possible de faire pivoter des données à l'aide de LINQ?

Question

Je suis nouveau à LINQ, mais je me demande s'il est possible d'utiliser LINQ pour faire pivoter les données de la mise en page suivante:

CustID | OrderDate | Qty 
1  | 1/1/2008 | 100 
2  | 1/2/2008 | 200 
1  | 2/2/2008 | 350 
2  | 2/28/2008 | 221 
1  | 3/12/2008 | 250 
2  | 3/15/2008 | 2150 

en quelque chose comme ceci:

CustID | Jan- 2008 | Feb- 2008 | Mar - 2008 | 
1  | 100  | 350  | 250 
2  | 200  | 221  | 2150 

Answer 1

Quelque chose comme ça?

List<CustData> myList = GetCustData(); 

var query = myList 
    .GroupBy(c => c.CustId) 
    .Select(g => new { 
     CustId = g.Key, 
     Jan = g.Where(c => c.OrderDate.Month == 1).Sum(c => c.Qty), 
     Feb = g.Where(c => c.OrderDate.Month == 2).Sum(c => c.Qty), 
     March = g.Where(c => c.OrderDate.Month == 3).Sum(c => c.Qty) 
    }); 

GroupBy dans LINQ ne fonctionne pas la même chose que SQL. En SQL, vous obtenez la clé et les agrégats (forme ligne/colonne). Dans Linq, vous obtenez la clé et tous les éléments en tant qu'enfants de la clé (forme hiérarchique). Pour pivoter, vous devez projeter la hiérarchie dans une forme de ligne/colonne de votre choix.

Answer 2

Regroupez vos données sur mois, puis le projeter dans un nouveau datatable avec des colonnes pour chaque mois. La nouvelle table serait votre table pivotante.

Answer 3

j'ai répondu similar question en utilisant la méthode d'extension LINQ:

// order s(ource) by OrderDate to have proper column ordering 
var r = s.Pivot3(e => e.custID, e => e.OrderDate.ToString("MMM-yyyy") 
    , lst => lst.Sum(e => e.Qty)); 
// order r(esult) by CustID 

(+) mise en œuvre générique
(-) nettement plus lent que David B

Quelqu'un peut-il améliorer ma mise en œuvre (par exemple la méthode fait la commande des colonnes & lignes)?

Answer 4

est ici un peu de manière plus générique comment faire pivoter les données en utilisant LINQ:

IEnumerable<CustData> s; 
var groupedData = s.ToLookup( 
     k => new ValueKey(
      k.CustID, // 1st dimension 
      String.Format("{0}-{1}", k.OrderDate.Month, k.OrderDate.Year // 2nd dimension 
     ))); 
var rowKeys = groupedData.Select(g => (int)g.Key.DimKeys[0]).Distinct().OrderBy(k=>k); 
var columnKeys = groupedData.Select(g => (string)g.Key.DimKeys[1]).Distinct().OrderBy(k=>k); 
foreach (var row in rowKeys) { 
    Console.Write("CustID {0}: ", row); 
    foreach (var column in columnKeys) { 
     Console.Write("{0:####} ", groupedData[new ValueKey(row,column)].Sum(r=>r.Qty)); 
    } 
    Console.WriteLine(); 
} 

où ValueKey est une classe spéciale qui représente la clé multidimensionnelle:

public sealed class ValueKey { 
    public readonly object[] DimKeys; 
    public ValueKey(params object[] dimKeys) { 
     DimKeys = dimKeys; 
    } 
    public override int GetHashCode() { 
     if (DimKeys==null) return 0; 
     int hashCode = DimKeys.Length; 
     for (int i = 0; i < DimKeys.Length; i++) { 
      hashCode ^= DimKeys[i].GetHashCode(); 
     } 
     return hashCode; 
    } 
    public override bool Equals(object obj) { 
     if (obj==null || !(obj is ValueKey)) 
      return false; 
     var x = DimKeys; 
     var y = ((ValueKey)obj).DimKeys; 
     if (ReferenceEquals(x,y)) 
      return true; 
     if (x.Length!=y.Length) 
      return false; 
     for (int i = 0; i < x.Length; i++) { 
      if (!x[i].Equals(y[i])) 
       return false; 
     } 
     return true;    
    } 
} 

Cette approche peut être utilisée pour le regroupement par N-dimensions (n> 2) et fonctionnera correctement pour des ensembles de données relativement petits. Pour les grands ensembles de données (jusqu'à 1 million de dossiers et plus) ou pour les cas où la bibliothèque configuration de pivot ne peut pas être Hardcoded J'ai écrit spécial PivotData (il est gratuit):

var pvtData = new PivotData(new []{"CustID","OrderDate"}, new SumAggregatorFactory("Qty")); 
pvtData.ProcessData(s, (o, f) => { 
    var custData = (TT)o; 
    switch (f) { 
     case "CustID": return custData.CustID; 
     case "OrderDate": 
     return String.Format("{0}-{1}", custData.OrderDate.Month, custData.OrderDate.Year); 
     case "Qty": return custData.Qty; 
    } 
    return null; 
}); 
Console.WriteLine(pvtData[1, "1-2008"].Value); 

Answer 5

L'approche la plus nette pour cela, je pense , est d'utiliser une recherche:

var query = 
    from c in myList 
    group c by c.CustId into gcs 
    let lookup = gcs.ToLookup(y => y.OrderDate.Month, y => y.Qty) 
    select new 
    { 
     CustId = gcs.Key, 
     Jan = lookup[1].Sum(), 
     Feb = lookup[2].Sum(), 
     Mar = lookup[3].Sum(), 
    };