Linq Grouping Question - linq

Question

I'm working on a simple reservation system for meeting room. Each meeting room is assigned a room type depending on it's size etc. I'm looking to shape the count of booked rooms from the following:
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
Into grouped data such as:
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
I've managed to do this previously using Datasets, but I need to be able to do this in Linq for this project using Linq to entites
Can somebody advise the best way to do this?
Thanks

Answer 1

This is what I've done when confronted with this type of problem:
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();
This essentially produces the following arrays:
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 }
},
};
The RoomCounts arrays are all the same length as the rooms array and the value at each index position matches the room in the rooms array.
It's usually fairly workable.
An alternative is to create an array of arrays that represent a grid somewhat like a spreadsheet.
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();
This produces the following:
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 },
};
An alternative to the alternative, in case the query looks a little hairy, is to do this:
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())));
This form of the query still produces the same grid of objects, but it's a little more readable, IMHO, than the first form.
I hope this helps.