/// <summary>
        /// Returns compiled lambda expression for given expression
        /// </summary>
        /// <typeparam name="T1">Input type on which to apply expression</typeparam>
        /// <typeparam name="T2">Return type for the expression</typeparam>
        /// <param name="exString">expression formula</param>
        /// <returns>Compiled lambda expression</returns>
        public static Func <T1, T2> CompileExpression <T1, T2>(ExpressionString exString)
        {
            var param = Expression.Parameter(typeof(T1));
            var expr  = BuildExpression <T1>(exString, param);

            return(Expression.Lambda <Func <T1, T2> >(expr, param).Compile());
        }
        /// <summary>
        /// Build and returns binary expression based on given expression formula
        /// </summary>
        /// <typeparam name="T">Type of expression to return</typeparam>
        /// <param name="exString">expression formula</param>
        /// <param name="param">Type used to identify operand in the expression</param>
        /// <returns>Returns binary expression based on given formula</returns>
        public static Expression BuildExpression <T>(ExpressionString exString, ParameterExpression param)
        {
            var            left         = MemberExpression.Property(param, exString.LeftSide);
            var            leftPropType = typeof(T).GetProperty(exString.LeftSide).PropertyType;
            ExpressionType exprBinary;

            if (ExpressionType.TryParse(exString.Operator, out exprBinary))
            {
                var right = Expression.Constant(Convert.ChangeType(exString.RightSide, leftPropType));
                return(Expression.MakeBinary(exprBinary, left, right));
            }
            else
            {
                throw new Exception("Invalid Expression");
            }
        }