Exemple #1
0
        public static Expression CovertToExpression(Type type, QueryExpression qExpression)
        {
            if (string.IsNullOrEmpty(qExpression.PropertyName))
            {
                return(null);
            }
            ParameterExpression param     = Expression.Parameter(type, "c");
            Expression          condition = null;
            // Merege Expression
            List <QueryExpression> list = new List <QueryExpression>();

            list.Add(qExpression);
            QueryExpression rE = qExpression.RelatedExpression;

            while (rE != null)
            {
                list.Add(rE);
                rE = rE.RelatedExpression;
            }

            for (int i = list.Count - 1; i >= 0; i--)
            {
                QueryExpression currentExpression = list[i];
                if (string.IsNullOrEmpty(currentExpression.PropertyName))
                {
                    continue;
                }


                Expression left         = GetLeft(param, currentExpression.PropertyName);
                Type       propertyType = left.Type;

                Expression right = null;
                if (list[i].RightPropertyValue != null)
                {
                    right = Expression.Constant(list[i].RightPropertyValue);
                }
                else
                {
                    object cValue = TryConvertValue(propertyType, currentExpression.PropertyValue);
                    right = Expression.Constant(cValue, propertyType);
                }

                Expression filter = QueryExpressionHelper.MergeExpression(currentExpression.Operation, left, right);

                if (condition == null)
                {
                    condition = filter;
                }
                else if (currentExpression.RelatedType == QueryExpression.RelationType.And)
                {
                    condition = Expression.And(condition, filter);
                }
                else
                {
                    condition = Expression.Or(condition, filter);
                }
            }

            if (condition == QueryExpressionHelper.EmptyExpression)
            {
                return(null);
            }

            return(Expression.Lambda(condition, param));
        }