Question

I don’t know Linq2Sql so well yet and I was wondering if there is a trick for this probably common MVVM scenario. I have Linq2Sql data context containing Domain models, but I am fetching data for my customized ViewModel object from it.

var query = from ord in ctx.Table_Orders
        select new OrderViewModel()
        {
            OrderId = ord.OrderId,
            OrderSum = ord.OrderSum,
            OrderCurrencyId = ord.OrderCurrencyId,
            OrderCurrencyView = ord.Currency.CurrencyText
        };

So i want my ViewModel to inculde both CurrencyId from domain object and the CurrencyText from related table to show it nicely in the View.

This code works great. It generates one DB call with join to fetch the CurrencyText. But the model is simplified, real one has many more fields. I want to make the code reusable because I have many different queries, that returns the same ViewModel. Now every minor change to OrderViewModel requires lots of maintainance.

So I moved the code to OrderViewModel itself as a constructor.

public OrderViewModel(Table_Order ord)
{
    OrderId = ord.OrderId,
    OrderSum = ord.OrderSum,
    OrderCurrencyId = ord.OrderCurrencyId,
    OrderCurrencyView = ord.Currency.CurrencyText
}

And call it like this.

var query = from ord in ctx.Table_Orders
        select new OrderViewModel(ord);

The Problem: The join is gone DB query is no more optimised. Now I get 1+N calls to database to fetch CurrencyText for every line.

Any comments are welcome. Maybe I have missed different great approach.

This is how far i could get on my own, to get the code reusability. I created a function that does the job and has multiple parameters. Then I need to explicitly pass it everything that has crossed the line of entity.

var query = ctx.Table_Orders.Select(m =>
       newOrderViewModel(m, m.Currency.CurrencyText));

The DB call is again optimized. But it still does not feel like I am there yet! What tricks do You know for this case?

---

EDIT : The final solution
Thanks to a hint by @Muhammad Adeel Zahid I arrived at this solution.
I created an extension for IQueryable

public static class Mappers
{
    public static IEnumerable<OrderViewModel> OrderViewModels(this IQueryable<Table_Order> q)
    {
        return from ord in q
                select new OrderViewModel()
                {
                    OrderId = ord.OrderId,
                    OrderSum = ord.OrderSum,
                    OrderCurrencyId = ord.OrderCurrencyId,
                    OrderCurrencyView = ord.Currency.CurrencyText
                };
    }
}

Now i can do this to get all list

var orders = ctx.Table_Order.OrderViewModels().ToList();

or this to get a single item, or anything in between with Where(x => ..)

var order = ctx.Table_Order
   .Where(x => x.OrderId == id).OrderViewModels().SingleOrDefault();

And that completely solves this question. The SQL generated is perfect and the code to translate objects is reusable. Approach like this should work with both LINQ to SQL and LINQ to Entities. (Not tested with the latter) Thank You again @Muhammad Adeel Zahid

Answer 1

Whenever we query the database, we mostly require either enumeration of objects (more than one records in db) or we want a single entity (one record in db). you can write your mapping code in method that returns enumeration for whole table like

public IEnumerable<OrderViewModel> GetAllOrders()
{
    return from ord in ctx.Table_Orders
        select new OrderViewModel()
        {
            OrderId = ord.OrderId,
            OrderSum = ord.OrderSum,
            OrderCurrencyId = ord.OrderCurrencyId,
            OrderCurrencyView = ord.Currency.CurrencyText
        };

} 

Now you may want to filter these records and return another enumeration for example on currencyID

public IEnumerable<OrderViewModel> GetOrdersByCurrency(int CurrencyID)
{
      return GetAllOrders().Where(x=>x.CurrencyId == CurrencyID);
}

Now you may also want to find single record out of all these view models

public OrderViewModel GetOrder(int OrderID)
{
      return GetAllOrders().SingleOrDefault(x=>x.OrderId == OrderID);
}

The beauty of IEnumerable is that it keeps adding conditions to query and does not execute it until it is needed. so your whole table will not be loaded unless you really want it and you have kept your code in single place. Now if there are any changes in ViewModel Mapping or in query itself, it has to be done in GetAllOrders() method, rest of code will stay unchanged