public static IQueryable OrderBy(this IQueryable source, string ordering, QueryResolver queryResolver) { if (source == null) throw new ArgumentNullException("source"); if (ordering == null) throw new ArgumentNullException("ordering"); ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(source.ElementType, "") }; ExpressionParser parser = new ExpressionParser(parameters, ordering, queryResolver); IEnumerable<DynamicOrdering> orderings = parser.ParseOrdering(); Expression queryExpr = source.Expression; string methodAsc = "OrderBy"; string methodDesc = "OrderByDescending"; foreach (DynamicOrdering o in orderings) { queryExpr = Expression.Call( typeof(Queryable), o.Ascending ? methodAsc : methodDesc, new Type[] { source.ElementType, o.Selector.Type }, queryExpr, Expression.Quote(DynamicExpression.Lambda(o.Selector, parameters))); methodAsc = "ThenBy"; methodDesc = "ThenByDescending"; } return source.Provider.CreateQuery(queryExpr); }
/// <summary> /// Evaluate a string expression to a boolean "True" or "False" (if possible). /// An alternative to Evaluate that behaves nicely with the TextWindow. /// </summary> /// <param name="expression">The expression to evaluate to a boolean, e.g. "21.3 > 16".</param> /// <returns>The evaluated result ("True" or "False").</returns> public static Primitive Evaluate3(Primitive expression) { try { ParameterExpression pe = Expression.Parameter(typeof(string), "IntegerAsReal"); ExpressionParser parser = new ExpressionParser(new ParameterExpression[] { pe }, expression, null); LambdaExpression expr = Expression.Lambda(parser.Parse(typeof(bool)), null); var del = (Func<bool>)expr.Compile(); return del(); } catch (Exception ex) { Utilities.OnError(Utilities.GetCurrentMethod(), ex); return ""; } }
public static LambdaExpression ParseLambda(IDynamicLinkCustomTypeProvider provider, ParameterExpression[] parameters, Type resultType, string expression, params object[] values) { ExpressionParser parser = new ExpressionParser(provider, parameters, expression, values); return(Expression.Lambda(parser.Parse(resultType), parameters)); }
public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, params object[] values) { ExpressionParser parser = new ExpressionParser(parameters, expression, values); return(Expression.Lambda(parser.Parse(resultType), parameters)); }
public static Expression Parse(Type resultType, string expression, params object[] values) { var parser = new ExpressionParser(null, expression, values); return(parser.Parse(resultType)); }
private void ValidateToken(ExpressionParser.TokenId t) { if (this.token.id != t) { throw this.ParseError("Syntax error", new object[0]); } }
private void ValidateToken(ExpressionParser.TokenId t, string errorMessage) { if (this.token.id != t) { throw this.ParseError(errorMessage, new object[0]); } }
private static bool IsBetterThan(Expression[] args, ExpressionParser.MethodData m1, ExpressionParser.MethodData m2) { bool result = false; for (int i = 0; i < args.Length; i++) { int num = ExpressionParser.CompareConversions(args[i].Type, m1.Parameters[i].ParameterType, m2.Parameters[i].ParameterType); if (num < 0) { return false; } if (num > 0) { result = true; } } return result; }
private bool IsApplicable(ExpressionParser.MethodData method, Expression[] args) { if (method.Parameters.Length != args.Length) { return false; } Expression[] array = new Expression[args.Length]; for (int i = 0; i < args.Length; i++) { ParameterInfo parameterInfo = method.Parameters[i]; if (parameterInfo.IsOut) { return false; } Expression expression = this.PromoteExpression(args[i], parameterInfo.ParameterType, false); if (expression == null) { return false; } array[i] = expression; } method.Args = array; return true; }
public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, params object[] values) { ExpressionParser parser = new ExpressionParser(parameters, expression, values); return Expression.Lambda(parser.Parse(resultType), parameters); }
protected override Expression VisitMember(MemberExpression m) { if (!this.isInProjection) { if (m.Member.MemberType == MemberTypes.Property) { PropertyDescriptor pd = TypeDescriptor.GetProperties(m.Member.DeclaringType)[m.Member.Name]; // Let properties for which no PropertyDescriptors exist go through. This happens when we // deal with structs. bool requiresValidation = !(pd == null && m.Member.DeclaringType.IsValueType); if (requiresValidation && !this.IsVisible(pd)) { if (!PostProcessor.IsProjectionPath(m)) { throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resource.UnknownPropertyOrField, pd.Name, ExpressionParser.GetTypeName(pd.ComponentType))); } else { this.isInProjection = true; Expression expr = base.VisitMember(m); this.isInProjection = false; return(expr); } } } } return(base.VisitMember(m)); }
public static Expression Parse(Type resultType, string expression, ICollection <Type> additionalAllowedTypes = null, params object[] values) { var parser = new ExpressionParser(null, expression, values, additionalAllowedTypes); return(parser.Parse(resultType)); }
public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, ICollection <Type> additionalAllowedTypes = null, params object[] values) { var parser = new ExpressionParser(parameters, expression, values, additionalAllowedTypes); return(Expression.Lambda(parser.Parse(resultType), parameters)); }
public static LambdaExpression ParseLambda(ParameterExpression[] parameters, Type resultType, string expression, QueryResolver queryResolver) { ExpressionParser parser = new ExpressionParser(parameters, expression, queryResolver); return Lambda(parser.Parse(resultType), parameters); }