Use delegate for Projection in Linq to SQL

Question

I have code something like this in an IRepository implementation in Linq to Sql:

var newlist = from h in list where h.StringProp1 == "1"
                      select new MyBusinessBO{
                          firstProp = h.StringProp1,
                          secondProp = h.StringProp2
                      };

The projection into MyBusinessBO is not difificult but when the Business Object has many properties the projection code becomes very lengthy. Also, as the projection can occur in several places in the Repository we break the DRY principle.

Is there any way to abstract out the projection or replace it with a delegate?

I.e. replace the code

                          firstProp = h.StringProp1,
                          secondProp = h.StringProp2

with something reusable?

Answer 1

Take a look at AutoMapper and similar tools

Answer 2

Perhaps use regular non-default constructors, rather than object initializers. Or, if you can start using C# 4.0, try to add optional/default parameters to the mix.

Answer 3

You can put that code in a method:

public static IEnumerable<MyBusinessBO> ConvertToMyBusinessBO(
        IEnumerable<Original> collection)
{
    return
        from item in collection
        select new MyBusinessBO{
            firstProp = h.StringProp1,
            secondProp = h.StringProp2
        };
}

And call it like this:

var q = from h in list where h.StringProp1 == "1" select h;
var list = ConvertToMyBusinessBO(q);

And you can do the same when using IQueryable<T>:

public static IQueryable<MyBusinessBO> ConvertToMyBusinessBO(
        IQueryable<Original> collection)
{
    return
        from item in collection
        select new MyBusinessBO{
            firstProp = h.StringProp1,
            secondProp = h.StringProp2
        };
}

This way you can still use the power of a LINQ provider that will execute your code against the database.

Answer 4

You could solve this by using the dot syntax rather than the LINQ-style syntax.

Your current:

list
    .Where(h => h.StringProp1 == "1")
    .Select(h => new MyBusinessBO
    {
        firstProp = h.StringProp1,
        secondProp = h.StringProp2
    });

Potential solution:

Func<MyType, MyBusinessBO> selector = h => new MyBusinessBO
{
    firstProp = h.StringProp1,
    secondProp = h.StringProp2
};
list
    .Where(h => h.StringProp1 == "1")
    .Select(selector);

And you could pass in the selector somewhere or generate it on-the-fly or something along those lines.

Answer 5

I'd create an extension method on the type itself, that performed the projection for you. i.e.

static MyBusinessBO AsBusinessBO(this MyObject obj)
{
    return new MyBusinessBO()
    {
        firstProp = obj.StringProp1,
        secondProp = obj.StringProp2
    }
}

Then you can write your original query as:

var newlist = from h in list where h.StringProp1 == "1"
              select h.AsBusinessBO()

Answer 6

Queryable.Select requires an Expression<Func<T, U>>. You can write a method that returns this and use that method everywhere you do the transformation.

public Expression<Func<DataObj, BusiObj>> GetExpr()
{
  return h => new BusiObj()
  {
    firstProp = h.StringProp1,
    secondProp = h.StringProp2
  };
}


 //get a local variable holding the expression.
Expression<Func<DataObj, BusiObj>> toBusiObj = GetExpr();

//use it thusly
var newList = (from h in list where h.StringProp1 == "1" select h)
  .Select(toBusiObj)
  .ToList();

//or
List<BusiObj> newList = list
  .Where(h => h.StringProp1 == "1")
  .Select(toBusiObj)
  .ToList();