Generic Queries with variables vs Linq

Recently, I needed to develop a method that would take two parameters: one for the name of the Entity to query ("entityType") and one for the name of the column to return ("nameField").

I ended up writing something like this:

public IList<LookupItem> GetLookupItems(Type entityType, string nameField)
{
    var query = new Query(entityType);
    query.Projection.Add("Id");
    query.Projection.Add(nameField);
    using (var dataReader = _unitOfWork.Project(query))
    {

        ... some more code here

    }

}

Note that due to the structure of the application I can not use generics here to pass in the type of the Entity.

While this works fine, it did make me wonder if there would be some way of writing this using Linq. Does anybody know of any way to use variables in Linq queries?

Also - vaguely related to this - is there a way to pass a Type object into a gereric parameter? E.g. something like:

var myType = myObject.GetType();

var result = myMethod<myType>(string myString);

                                        ^^^  = variable Type?

Thanks in advance for any assistance,

Lucien.

The short answer is that no, this can't be done using LINQ, because the LINQ operators are strongly-typed and enforce compile-time checking on the kind of entity being queried.  (This is a general feature of LINQ, and is not peculiar to LightSpeed's implementation.  You'd run into the same issue using LINQ to Objects.)

The long answer is that it can be done with LINQ, but involves such gargantuan contortions that it's only useful if you have no other way of composing the query you want -- and since you have the LightSpeed Find method, you do have another way.  (See below if you want to see just how gargantuan the contortions are.)  There is also a sample called Dynamic LINQ which allows you to write your LINQ queries and projections as strings (which you can build up at runtime) and it will translate them into expressions for you: see http://weblogs.asp.net/scottgu/archive/2008/01/07/dynamic-linq-part-1-using-the-linq-dynamic-query-library.aspx, but I think this will still run into the problem of needing a compile-time-typed IQueryable to get started from.

Regarding passing a variable type as a generic parameter, this isn't possible in the way you'd like it to be.  You can use reflection to parameterise a generic method at runtime (MethodInfo.MakeGenericMethod) but because this parameterisation happens at runtime you can't interact with the method in a strongly-typed way.

-----

Okay, as promised, here is how to perform a run-time projection using LINQ if you ever really really need to (cover your eyes if you are of a nervous disposition):

private static IEnumerable<LookupItem> GetLookupItems(IUnitOfWork unitOfWork, Type t, string nameField)
{
  ParameterExpression rangeVariable = Expression.Parameter(t, "o");
  LambdaExpression projection =
    Expression.Lambda(
      Expression.MemberInit(
        Expression.New(typeof(LookupItem).GetConstructor(Type.EmptyTypes)),
        Expression.Bind(
          typeof(LookupItem).GetProperty("Id"),
          Expression.MakeMemberAccess(rangeVariable, t.GetProperty("Id"))),
        Expression.Bind(
          typeof(LookupItem).GetProperty("Name"),
          Expression.MakeMemberAccess(rangeVariable, t.GetProperty(nameField)))
        ),
      rangeVariable);

  MethodInfo select1 = typeof(Queryable).GetMethods(BindingFlags.Public | BindingFlags.Static)
                                        .Where(m => m.Name == "Select")
                                        .First(m => m.GetParameters().Length == 2);

  MethodInfo select2 = select1.MakeGenericMethod(typeof(Member), typeof(LookupItem));

  MethodInfo queryMethod = typeof(UnitOfWorkExtensions).GetMethods()
                                                       .Where(m => m.Name == "Query" && m.IsGenericMethodDefinition && m.GetGenericArguments().Length == 1)
                                                       .First()
                                                       .MakeGenericMethod(t);

  IQueryable query = (IQueryable)(queryMethod.Invoke(null, new object[] { unitOfWork }));
  Expression queryable = Expression.Constant(query);

  MethodCallExpression mce = Expression.Call(
    select2,
    queryable,
    projection);

  IEnumerable<LookupItem> results = ((IEnumerable)(query.Provider.Execute(mce))).Cast<LookupItem>();
  return results;
}

Usage:

public void Test()
{
  Type t = typeof(Member);
  string nameField = "UserName";

  IEnumerable<LookupItem> results = GetLookupItems(_unitOfWork, t, nameField);
  foreach (var v in results)
    Console.WriteLine(v);
}

public class LookupItem
{
  public int Id { get; set; }
  public string Name { get; set; }
}

As you can see, much easier to use IUnitOfWork.Project instead!

Hi Ivan,

Good to "meet" you again!

Wow - I'm impressed with your "long" solution and you taking the time to come up with that!

I have to agree though, using Project is a lot easier - and it works. It was the conclusion I came to as well, after trying different scenarios, but it's good to have it confirmed by an expert. :-)

Thanks again,

Lucien