Create Dynamic LINQ Using Expressions

Note: The article is applied for .Net version > 3.5 and C# > 3.0.

In previous post we learnt basic understanding of Expression and few insights how Expression represents the code as data. Also we learned how to compile and invoke an Expression.

In this post you’ll learn,

• Creating a simple lambda expression.
• Creating a dynamic Linq expression.

Before moving ahead I want to mention the MSDN documentation of Expression class to go through for its methods and properties available to build code.

Creating a simple lambda expression

Let’s take a sample expression which adds up two numbers using a delegate.

Expression<Func<int, int, int>> sumExpr = (a, b) => a + b;

This is how we can write it in the code but it’s possible to build such expressions on the fly. The non-generic Expression class provides a lots of methods and properties.

If we parse this expression, (see previous article) we’ll get something like the following:

So we would need to declare two parameters first. Which we can do like below:
Now let’s build the body, as we can see the body is a binary operation being performed with add operator. So it will be a binary expression, with Add method and pass those parameters expression to it.
So now we have our parameters and body. Node type will stick them together:
We have defined the Lambda type as Func with two argument of int and return type int. Then supply the body and parameters expression. And the expression is complete. Now if you look at the lambda in debug mode it will look like exactly that it supposed to be.

Now to execute it, we have to do the same as declared Expressions.



var result = lambda.Compile()(2, 3);



The method can be generalized with generics and then it can be called with any types:
You can call it like:

var res = BuildIt<int>().Compile()(2, 3);

I hope you must be comfortable building the expressions, so let’s move on and build a little complex and useful expression which would help reducing the duplicate code.

Creating a simple dynamic Linq expression

Now we have a class ‘TestDemo’ and we want to convert the list of objects of `TestDemo` to another list of objects of class ‘SelectListItem’. This is a class in ASP.NET MVC which represents the items source of HTML Dropdownlist and its very common case. So assuming that we have 10-11 types of such classes like `TestDemo` which would get converted to Dropdownlist to show on view. In real scenario, let’s assume these classes are DbContext entities pulling data from DB and converting them to Dropdownlist compatible objects.

For multiple classes the LINQ would go like:
This code is one of the question from SO. Where the person asked to refactor this code. And ofcourse this looks bit awkward to have same LINQ select criteria repeated to all classes. Now assume if you have such 10-12 classes how the method would look.

So the solution was to create a Generic method which can supply the expression and return the list of ‘SelectListItem’.

Let’s define the signature of the generic method,

public static IEnumerable<SelectListItem> GetList<T>(this IQueryable<T> source)

This is a generic Extension method for IQueryables so it can be invoked via any IQueryable type. And T is the Type of entity on which this will be invoked. In our case T will be TestDemo, TestDemo1 etc..

To start building the expression we will again break it down to it’s expression tree.