using System;

using System.Linq.Expressions;

using System.Linq;

using System.Reflection;

public class Program

{

    public static void Main(string[] args)

    {

        var result = new [] { new Entity{ SearchColumn = "foo", Sub = new Entity { SearchColumn = "bar" } } }.AsQueryable()

            .MatchManyColumns("foo", x => x.SearchColumn, x => x.Sub.SearchColumn);

        Console.WriteLine(result.ToList());

​

    }

​

}

​

public class Entity

{

    public string SearchColumn { get; set; }

​

    public Entity Sub { get; set; }

}

​

    public static class MultiColumnMatch

    {

        static readonly MethodInfo stringContains = typeof(String).GetMethod("Contains", new [] { typeof(String) });

​

        public static IQueryable<T> MatchManyColumns<T>(this IQueryable<T> query, string searchTerm, params Expression<Func<T, string>>[] props) {

            var pe = Expression.Parameter(typeof(T), "__x4326");

            // Builds up this expression body

            // x.SearchColumn1.Contains("match") || x.Searchcolumn2.Contains("match")) || ... || false

            var orClause = props.Aggregate( (Expression) Expression.Constant(false), (leftClause, prop) => 

                Expression.OrElse(leftClause, 

                    Expression.Call(

                        prop.Body,

                        stringContains,

                        Expression.Constant(searchTerm)

                    )

                )

            );

            return query.Where(Expression.Lambda<Func<T, bool>>(orClause, pe));

        }

​

        // We have an expression that looks like this:

        // y => y.SearchColumn or y => y.SubItem.SubColumn

        // We need to curry it to use our ParameterExpression

        // parameter => parameter.SearchColumn or parameter => parameter.SubItem.SubColumn

        static Expression curryExpression(Expression from, ParameterExpression parameter) {

            // parameter => parameter.WhateverPropertyNameWasUsedInFrom

            return Expression.Property(parameter, ((MemberExpression) from).Member.Name);

            //var newExpressionUsingParameter = Expression. Expression.Lambda<Func<T,string>>(from, pe).Body;

        }

    }