È ansible ruotare i dati usando LINQ?

Sono nuovo di LINQ, ma mi chiedo se è ansible utilizzare LINQ per ruotare i dati dal seguente layout:

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 

in qualcosa di simile:

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

Qualcosa come questo?

 List 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 in Linq non funziona come SQL. In SQL, ottieni la chiave e gli aggregati (forma di riga / colonna). In Linq, ottieni la chiave e tutti gli elementi come figli della chiave (forma gerarchica). Per ruotare, è necessario proiettare la gerarchia in una forma riga / colonna di propria scelta.

Ho risposto a una domanda simile usando il metodo di estensione 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 

(+) implementazione generica
(-) decisamente più lento di David B’s

Qualcuno può migliorare la mia implementazione (cioè il metodo fa l’ordine di colonne e righe)?

L’approccio migliore per questo, penso, è di usare una ricerca:

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

Ecco un modo un po ‘più generico su come ruotare i dati usando LINQ:

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

dove ValueKey è una class speciale che rappresenta la chiave multidimensionale:

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

Questo approccio può essere utilizzato per il raggruppamento per N-dimensioni (n> 2) e funzionerà bene per dataset piuttosto piccoli. Per dataset di grandi dimensioni (fino a 1 mln di record e altro) o per casi in cui la configurazione pivot non può essere codificata, ho scritto una libreria PivotData speciale (è gratuita):

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

Raggruppa i tuoi dati in un mese e poi proiettali in un nuovo datatable con colonne per ogni mese. Il nuovo tavolo sarebbe il tuo tavolo pivot.