¿Es posible pivotar datos usando LINQ?

Question

Soy nuevo en LINQ, pero me pregunto si es posible utilizar LINQ para girar los datos de la siguiente distribución:

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 algo como esto:

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

Answer 1

Algo como esto?

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 en LINQ no funciona lo mismo que SQL. En SQL, obtienes la clave y los agregados (forma de fila/columna). En Linq, obtienes la clave y cualquier elemento como elementos secundarios de la clave (forma jerárquica). Para pivotar, debe proyectar la jerarquía en una forma de fila/columna de su elección.

Answer 2

agrupar los datos en mes, y luego proyectarlo en una nueva tabla de datos con columnas para cada mes. La nueva tabla sería tu tabla pivote.

Answer 3

me respondió similar question utilizando el método de extensión de 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 

(+) implementación genérica
(-) sin duda más lento que David B de

¿Alguien puede mejorar mi aplicación (es decir, el método hace el pedido de columnas & filas)?

Answer 4

Aquí es un poco de forma más genérica cómo pivotar datos utilizando 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(); 
} 

donde ValueKey es una clase especial que representa clave multidimensional:

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

Este enfoque puede utilizarse para agrupar por N dimensiones (n> 2) y funcionará bien para conjuntos de datos bastante pequeños. Para grandes conjuntos de datos (hasta 1 millones de registros y más) o para casos cuando la configuración de pivote no puede ser codificado He escrito PivotData biblioteca especial (es gratis):

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

El enfoque más bonito de esto, creo , es el uso de una búsqueda:

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