using System;

using System.Linq;

using System.Linq.Expressions;

using System.Reflection;

using System.Collections;

using System.Collections.Generic;

​

public class Program

{

    public static void Main()

    {

        //---------------------------

        // Test UI Permission parsing

        //---------------------------

        //string permissionStr = "[PM:TestPermission000/TestPermissionOperation]";

        //string type = permissionStr.Substring(4, permissionStr.IndexOf("/") - 4);

        //string operation = permissionStr.Substring(permissionStr.IndexOf("/") + 1, (permissionStr.IndexOf("]") - permissionStr.IndexOf("/")) - 1);

        //Console.WriteLine(type);

        //Console.WriteLine(operation);

        //---------------------------

        // Test Predicate Builder

        //---------------------------

        List<TestEntity> data = new List<TestEntity>();

        data.AddRange(new TestEntity[]

                      {

                          new TestEntity("Ahmed", 22, null),

                          new TestEntity("Ayman", 25, 1500),

                          new TestEntity("Osama", 26, 7014),

                          new TestEntity("Mustapha", 14, 1024),

                          new TestEntity("Mahmoud", 52, 16),

                          new TestEntity("Muhammed", 23, null),

                      });

        TestEntity filter = new TestEntity(null, 25, 1500);

        /* Test predicate with nullable */

        //var filtered = data.Where(e => (e.Balance ?? 0.00m) == 1500);

        //foreach(var e in filtered)

        //  Console.WriteLine(e.Name);

        //return;

        /* Test ExpressionBuilder */

        var filtered = data.AsQueryable().Where(BuildPredicate<TestEntity>(filter));

        foreach(var e in filtered)

            Console.WriteLine(e.Name);

    }

    class TestEntity

    {

        public string Name { get; set; }

        public int Age { get; set; }

        public decimal? Balance { get; set; }

        public TestEntity(string name, int age, decimal? balance)

        {

            Name = name;

            Age = age;

            Balance = balance;

        }

    }

    public static Expression<Func<TSource, bool>> BuildPredicate<TSource>(object source)

        {

            if (source == null)

                return null;

​

            Expression<Func<TSource, bool>> predicateResult = s => true;

            foreach (PropertyInfo property in source.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance))

            {

                if (property.PropertyType.IsArray

                    || property.PropertyType == typeof(CollectionBase)

                    || property.PropertyType == typeof(IQueryable))

                    continue;

​

                object val = property.GetValue(source, null);

                if (val == null)

                    continue;

​

                if (property.PropertyType != typeof(string))

                        predicateResult.And(s => s.GetType().GetProperty(property.Name).GetValue(s, null) == property.GetValue(source, null));

                    else

                        predicateResult.And(s => s.GetType().GetProperty(property.Name).GetValue(s, null).ToString().ToLower().Contains(property.GetValue(source, null).ToString().ToLower()));

            }

​

            return predicateResult;

        }

}

​

public static class PredicateBuilder

    {

        public static Expression<Func<T, bool>> True<T>() { return f => true; }

        public static Expression<Func<T, bool>> False<T>() { return f => false; }

​

        public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1,

                                                            Expression<Func<T, bool>> expr2)

        {

            var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());

            return Expression.Lambda<Func<T, bool>>

                  (Expression.OrElse(expr1.Body, invokedExpr), expr1.Parameters);

        }

​

        public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1,

                                                             Expression<Func<T, bool>> expr2)

        {

            var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());

            return Expression.Lambda<Func<T, bool>>

                  (Expression.AndAlso(expr1.Body, invokedExpr), expr1.Parameters);

        }

    }