Reuse Logic with Expression Trees

Here the reused logic is in the variable predicateBody:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{


string[] companies = { "Consolidated Messenger", "Alpine Ski House", "Southridge Video", "City Power & Light",
"Coho Winery", "Wide World Importers", "Graphic Design Institute", "Adventure Works",
"Humongous Insurance", "Woodgrove Bank", "Margie's Travel", "Northwind Traders",
"Blue Yonder Airlines", "Trey Research", "The Phone Company",
"Wingtip Toys", "Lucerne Publishing", "Fourth Coffee" };

// The IQueryable data to query.
IQueryable<String> queryableData = companies.AsQueryable<string>();

// Compose the expression tree that represents the parameter to the predicate.
ParameterExpression pe = Expression.Parameter(typeof(string), "company");

// ***** Where(company => (company.ToLower() == "coho winery" || company.Length > 16)) *****
// Create an expression tree that represents the expression 'company.ToLower() == "coho winery"'.
Expression left = Expression.Call(pe, typeof(string).GetMethod("ToLower", System.Type.EmptyTypes));
Expression right = Expression.Constant("coho winery");
Expression e1 = Expression.Equal(left, right);

// Create an expression tree that represents the expression 'company.Length > 16'.
left = Expression.Property(pe, typeof(string).GetProperty("Length"));
right = Expression.Constant(16, typeof(int));
Expression e2 = Expression.GreaterThan(left, right);

// Combine the expression trees to create an expression tree that represents the
// expression '(company.ToLower() == "coho winery" || company.Length > 16)'.
Expression predicateBody = Expression.OrElse(e1, e2);

// Create an expression tree that represents the expression
// 'queryableData.Where(company => (company.ToLower() == "coho winery" || company.Length > 16))'
MethodCallExpression whereCallExpression = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { queryableData.ElementType },
queryableData.Expression,
Expression.Lambda<Func<string, bool>>(predicateBody, new ParameterExpression[] { pe }));
// ***** End Where *****

// ***** OrderBy(company => company) *****
// Create an expression tree that represents the expression
// 'whereCallExpression.OrderBy(company => company)'
MethodCallExpression orderByCallExpression = Expression.Call(
typeof(Queryable),
"OrderBy",
new Type[] { queryableData.ElementType, queryableData.ElementType },
whereCallExpression,
Expression.Lambda<Func<string, string>>(pe, new ParameterExpression[] { pe }));
// ***** End OrderBy *****
Console.WriteLine("orderByCallExpression: " + orderByCallExpression.ToString());
// Create an executable query from the expression tree.
IQueryable<string> results = queryableData.Provider.CreateQuery<string>(whereCallExpression);

// Enumerate the results.
foreach (string company in results)
Console.WriteLine(company);

/* This code produces the following output:

Blue Yonder Airlines
City Power & Light
Coho Winery
Consolidated Messenger
Graphic Design Institute
Humongous Insurance
Lucerne Publishing
Northwind Traders
The Phone Company
Wide World Importers
*/
Console.WriteLine("\n\n");
string[] companies2 = { "Consolidateds Messenger", "Alpines Ski House", "Southridges Video", "City Power & Light",
"Coho Winery", "Wides World Importers", "Graphics Design Institute", "Adventure Works",
"Humongouss Insurance", "Woodgroves Bank", "Margie'ss Travel", "Northwind Traders",
"Blues Yonder Airlines", "Treys Research", "Thes Phone Company",
"Wingtips Toys", "Lucerne Publishing", "Fourth Coffee" };

Console.WriteLine("predicateBody: " + predicateBody.ToString());
IQueryable<string> iqueryable2 = companies2.AsQueryable<string>();
Console.WriteLine("iqueryable2: " + iqueryable2.ToString());

MethodCallExpression whereCallExpression2 = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { iqueryable2.ElementType },
iqueryable2.Expression,
Expression.Lambda<Func<string, bool>>(predicateBody, new ParameterExpression[] { pe }));
Console.WriteLine("whereCallExpression2: " + whereCallExpression2.ToString());
IQueryable<string> results2 = iqueryable2.Provider.CreateQuery<string>(whereCallExpression2);

foreach (string compan in results2)
Console.WriteLine(compan);http://www.blogger.com/img/blank.gif

Console.ReadLine();
}
}
}

ref: http://msdn.microsoft.com/en-us/library/bb882637.aspx