Linq to SQL DTOs and composite objects

Question

I am using a similar approach to others in keeping my LINQ objects in my LINQ data provider and returning an IQueryable to allow filtering etc. This works fine for filtering a simple object by it's ID or other property, but I am having a problem with a join table object that is composed of other child objects

    //CoreDBDataContext db = coreDB;
public IQueryable<DTO.Position> GetPositions()    {
     return from p in coreDB.Positions
         select new DTO.Position
       {
       DTO.User = new DTO.User(p.User.id,p.User.username, p.User.firstName,p.User.lastName,p.User.email,p.User.isActive),
       DTO.Role = new DTO.Role(p.Role.id, p.Role.name, p.Role.isActive),
       DTO.OrgUnit = new DTO.OrgUnit(p.OrgUnit.id,p.OrgUnit.name,p.OrgUnit.isActive)
       };

The coreDB.Positions is my Linq Position Object and I am returning a DTO Position which is composed of a User, OrgUnit and Role (the underlying table is a join table with UserID, RoleID, and OrgUnitID)

The problem I am having is that when I try to add a filter on the Iqueryable I get a SQL Error saying that there is no translation available for my DTO.User object

public static IQueryable<Position> WithUserID(this IQueryable<Position> query, int userID)
 {
  return query.Where(p => p.User.ID == userID);
 }

I am at a complete loss as to how to go about resolving this, as all of my Google results seem to be with people working directly with the generated LINQ objects

Any thought as to how to make this work, or am I doing something completely wrong here?

Thanks

Answer 1

Linq2SQL does only understand the designer-generated objects. Well, that's not entirely true, but close enough.

So when you write Linq queries agains Linq2SQL objects, the query will be converted to valid SQL when the query is actually executed, not when it's written. Since your DTO objects are not Linq2SQL objects, Linq2SQL will not know how to create the proper SQL.

If you want to keep your separation this way, you have to find a way to execute your queries with only Linq2SQL objects involved and only map the result to your DTOs.

Maybe you could rewrite your query method to:

Update: Parameter must be of type Expression<>, and there's no need to return an IQueryable<>. Thanks to Freddy for pointing out.

public IEnumerable<DTO.Position> FindPositions(Expression<Func<Position, bool>> criteria)
{
    return from p in coreDB.Positions
           where criteria.Invoke(p)
           select new DTO.Position
                      {
                          User = new DTO.User(p.User.id, p.User.username, p.User.firstName, p.User.lastName,
                                       p.User.email, p.User.isActive),
                          Role = new DTO.Role(p.Role.id, p.Role.name, p.Role.isActive),
                          OrgUnit = new DTO.OrgUnit(p.OrgUnit.id, p.OrgUnit.name, p.OrgUnit.isActive)
                      };
}

Answer 2

I have been able to work successfully with a similar approach:

var courses = from c in Map(origCourses)
where !expiredStatuses.Contains(c.Status)
select c;

Where Map has:

    select new UserCourseListItem
    {
        CourseID = c.CourseID,
        CourseName = cm.CourseName,
        CourseType = c.CourseType.Value
        ...

How about trying it with that type of initialization (instead of constructors).

Ps. this is part of a working application, and the expiredStatuses is even related to a complex expression.

Update 1: This is similar compared to the mentioned scenario, because:

• Map is returning an IQueryable, which is a POCO object.
• After calling the Map method that returns an IQueryable with the POCO object I am applying a filter against it.

Answer 3

I ended up not using filters for my complex queries. Instead, I added methods to the repository for the more complex query requirements. I feel this will make the system easier to understand and hence maintain.