Linq的分組問題

Question

我工作的會議室一個簡單的預約系統上。每間會議室被分配取決於它的大小房型等我期待從以下塑造預訂客房數：

01/01/2011 1 Room A 2 
01/01/2011 2 Room B 5 
01/01/2011 3 Room C 3 
01/01/2011 4 Room D 2 
01/01/2011 5 Room E 1 
01/01/2011 6 Room F 5 
02/01/2011 1 Room A 3 
02/01/2011 2 Room B 5 
02/01/2011 3 Room C 2 
02/01/2011 4 Room D 5 
02/01/2011 5 Room E 2 
02/01/2011 6 Room F 2 
03/01/2011 1 Room A 2 
03/01/2011 2 Room B 5 
03/01/2011 3 Room C 2 

進入諸如分組數據：

Date  Room A Room B Room C Room D Room E Room F 
01/01/2011 2  5  3  2  1  5 
02/01/2011 3  5  2  5  2  2 
03/01/2011 2  5  2  4  5  8 
04/01/2011 4  7  3  5  2  2 

我已經設法利用數據集來做到這一點之前，但我需要能夠爲使用LINQ to entites的

有人可以建議要做到這一點的最好辦法這個項目做到這一點Linq中？

感謝

Answer 1

這是當這種類型的問題，面對我做了什麼：

var rooms = bookings 
    .Select(b => b.Room) 
    .Distinct() 
    .OrderBy(r => r) 
    .ToArray(); 

var query = (
    from b in bookings 
    group b by b.Date into gbs 
    let l = gbs.ToLookup(gb => gb.Room, gb => gb.Count) 
    select new 
    { 
     Date = gbs.Key, 
     RoomCounts = rooms.Select(r => l[r].Sum()).ToArray(), 
    }).ToArray(); 

這實質上產生以下數組：

var rooms = new [] 
{ 
    "Room A", "Room B", "Room C", "Room D", "Room E", "Room F", 
}; 

var query = new [] 
{ 
    new 
    { 
     Date = new DateTime(2011, 01, 01), 
     RoomCounts = new [] { 2, 5, 3, 2, 1, 5 } 
    }, 
    new 
    { 
     Date = new DateTime(2011, 01, 02), 
     RoomCounts = new [] { 3, 5, 2, 5, 2, 2 } 
    }, 
    new 
    { 
     Date = new DateTime(2011, 01, 03), 
     RoomCounts = new [] { 2, 5, 2, 0, 0, 0 } 
    }, 
}; 

的RoomCounts陣列都長度與rooms陣列相同，每個索引位置的值與rooms陣列中的房間相匹配。

它通常是相當可行的。

另一種方法是創建代表網格有點像一個電子表格數組的數組。

var query2 = (new object[] 
    { 
     (new object[] { "Date" }) 
      .Concat(rooms.Cast<object>()) 
      .ToArray() 
    }).Concat(
     from b in bookings 
     group b by b.Date into gbs 
     let l = gbs.ToLookup(gb => gb.Room, gb => gb.Count) 
     select (new object[] { gbs.Key }) 
      .Concat(rooms.Select(r => l[r].Sum()).Cast<object>()) 
      .ToArray()) 
      .ToArray(); 

這將產生以下：

var q2 = new object[] 
    { 
     new object[] { 
      "Date", "Room A", "Room B", "Room C", "Room D", "Room E", "Room F" }, 
     new object[] { new DateTime(2011, 01, 01), 2, 5, 3, 2, 1, 5 }, 
     new object[] { new DateTime(2011, 01, 02), 3, 5, 2, 5, 2, 2 }, 
     new object[] { new DateTime(2011, 01, 03), 2, 5, 2, 0, 0, 0 }, 
    }; 

的替代選擇，在情況下，查詢看起來有點毛茸茸的，是要做到這一點：

Func<object, IEnumerable, object[]> prepend = (o, os) => 
    (new object[] { o }).Concat(os.Cast<object>()).ToArray(); 

Func<object[], IEnumerable<object[]>, object[][]> prepends = (o, os) => 
    (new object[][] { o }).Concat(os).ToArray(); 

var query2 = prepends(prepend("Date", rooms), 
    from b in bookings 
    group b by b.Date into gbs 
    let l = gbs.ToLookup(gb => gb.Room, gb => gb.Count) 
    select prepend(gbs.Key, rooms.Select(r => l[r].Sum()))); 

這種形式的查詢仍然產生相同的對象網格，但它比第一個表單更具可讀性，恕我直言。

我希望這會有所幫助。