using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Linq;

using System.Linq.Expressions;

using System.Reflection;

​

public class ConsoleAppForLambdas

{

        private static readonly List<User> userData = UserDataSeed();

​

        public static void Main(string[] args)

        {

            Console.WriteLine("Specify the property to filter");

            string propertyName = Console.ReadLine();

            Console.WriteLine("Value to search against: " + propertyName);

            string value = Console.ReadLine();

​

            //1: With Func delegate

            //var dynamicExpression = GetDynamicQueryWithFunc(propertyName, value);

            //var output = userData.Where(dynamicExpression).ToList();

​

            //2: With Expression trees that generate Func and handles dynamic types with TypeDescriptor

            var dn = GetDynamicQueryWithExpresionTrees(propertyName, value);

            var output = userData.Where(dn).ToList();

​

            foreach (var item in output)

            {

                Console.WriteLine("Filtered result:");

                Console.WriteLine("\t ID: " + item.ID);

                Console.WriteLine("\t First Name: " + item.FirstName);

                Console.WriteLine("\t Last Name: " + item.LastName);

            }

            Console.WriteLine("\n");

            Console.WriteLine("==== DONE =====");

        }

​

        private static List<User> UserDataSeed()

        {

            return new List<User>

            {

                new User{ ID = 1, FirstName = "Kevin", LastName = "Garnett"},

                new User{ ID = 2, FirstName = "Stephen", LastName = "Curry"},

                new User{ ID = 3, FirstName = "Kevin", LastName = "Durant"}

            };

        }

​

        private static Func<User, bool> GetDynamicQueryWithFunc(string propName, object val)

        {

            Func<User, bool> exp = (t) => true;

            switch (propName)

            {

                case "ID":

                    exp = d => d.ID == Convert.ToInt32(val);

                    break;

                case "FirstName":

                    exp = f => f.FirstName == Convert.ToString(val);

                    break;

                case "LastName":

                    exp = l => l.LastName == Convert.ToString(val);

                    break;

                default:

                    break;

            }

            return exp;

        }

​

        private static Func<User, bool> GetDynamicQueryWithExpresionTrees(string propertyName, string val)

        {

            //x =>

            var param = Expression.Parameter(typeof(User), "x");

​

            #region Convert to specific data type

            MemberExpression member = Expression.Property(param, propertyName);

            UnaryExpression valueExpression = GetValueExpression(propertyName, val, param);

            #endregion

            Expression body = Expression.Equal(member, valueExpression);

            var final = Expression.Lambda<Func<User, bool>>(body: body, parameters: param);

            return final.Compile();

        }

​

        private static UnaryExpression GetValueExpression(string propertyName, string val, ParameterExpression param)

        {

            var member = Expression.Property(param, propertyName);

            var propertyType = ((PropertyInfo)member.Member).PropertyType;

            var converter = TypeDescriptor.GetConverter(propertyType);

​

            if (!converter.CanConvertFrom(typeof(string)))

                throw new NotSupportedException();

​

            var propertyValue = converter.ConvertFromInvariantString(val);

            var constant = Expression.Constant(propertyValue);

            return Expression.Convert(constant, propertyType);

        }

}

​

public class User

{

    public int ID { get; set; }

    public string FirstName { get; set; }

    public string LastName { get; set; }

}

​