Optimise Linq-to-Sql mapping with one to many lookup - linq-to-sql

Question

I'm having problems optimising data lookup with the following data structure:
Order
-----
Id
Customer
Date
... etc
OrderStatus
------
Id
OrderId
Date
UpdatedBy
StatusTypeId
...etc
This is causing me a headache on the Order List page, which basically shows a list of Orders. Each Order Summary in the list shows a bunch of fields from Order and the current OrderStatus, i.e. the OrderStatus with the latest Date which is linked to the Order.
Order List
-------------------------------------------------------
Order Id | Customer | Order Date | CurrentStatus |
-------------------------------------------------------
1 | Someone | 1.10.2010 | Completed |
-------------------------------------------------------
2 | Someone else | 12.10.2010 | In Progress |
-------------------------------------------------------
3 | Whoever | 17.10.2010 | On Hold |
-------------------------------------------------------
Now, say I want to list all orders from this year. My Repository fetches the Order objects
var orders = _repository.GetAllOrdersSinceDate(dt);
and now I end up with something like
foreach (Order order in orders)
{
OrderSummary summary = new OrderSummary();
summary.Customer = order.Customer;
summary.Date = order.Date;
// ...etc
// problem here!!
summary.OrderStatus = order.OrderStatus
.OrderByDescending(s => status.Date).First();
}
So what I end up with is a SELECT statement on Order and then a further SELECT statement on OrderStatus for each Order returned.
So to show the summary of all records for this year is requiring around 20,000 individual SQL queries and taking many minutes to load.
Is there any neat way to fix this problem?
I'm considering re-writing the database to hold the current OrderStatus in the Order table, so I end up with something like
Order
-----
Id
Customer
Date
CurrentStatusTypeId
CurrentStatusDate
CurrentStatusUpdatedBy
...etc
OrderStatusHistory
------
Id
OrderId
Date
UpdatedBy
StatusTypeId
...etc
which is the only way I can see to solve the problem but seems a pretty nasty solution.
Whats the best way forward here?

Answer 1

Please don't denormalize your database model to solve your problem. This will only make things worse. You can fix this by writing a service method that returns a list of data transfer objects (DTO) instead of the LINQ to SQL entities. For instance, the service method might look like this:
public OrderSummary[] GetOrderSummariesSinceDate(DateTime d)
{
return (
from order in this.context.Orders
where order.Date >= d
let lastStatus = (
from status in order.OrderStatusses
orderby status.Date descending
select status).First()
select new OrderSummary
{
OrderId = order.Id,
CustomerName = order.Customer.Name,
Date = order.Date,
OrderStatus = lastStatus.StatusType.Name
}).ToArray();
}
Note the following:
This code will execute as a single SQL query in the database.
This method will return an object that contains just the data that the client needs, but nothing more. No Customer object, no OrderStatus object.
By calling ToArray we ensure that the database is queried at this point and it is not deferred.
These three points ensure that the performance is maximized and allows the service layer to stay in control over what is executed to the database.
I hope this helps.

Answer 2

You can create a DataLoadOptions object as follows:
DataContext db = new DataContext
DataLoadOptions ds = new DataLoadOptions();
ds.LoadWith<OrderStatus>(c => c.Orders);
db.LoadOptions = ds;
Then when you run your query it should prefetch the OrderStatus table