public LambdaExpressionCacheKey(LambdaExpression obj) { ReturnType = obj.ReturnType.FullName; ExpressionAsString = obj.ToString(); ArgTypes = new HashSet<string>(obj.Parameters.Select(x => x.Type.FullName)); _toString = null; }
public FilterPredicate(LambdaExpression lambda) { Util.Check(lambda.Parameters.Count > 0, "Invalid FilterPredicate lambda - must have at least one Entity parameter."); Util.Check(lambda.Body.Type == typeof(bool), "Invalid FilterPredicate lambda - must have bool return type."); Lambda = lambda; EntityType = Lambda.Parameters[0].Type; _asString = lambda.ToString(); }
static Reflect.MemberInfo MemberFromLambdaExpr(Exprs.LambdaExpression expr) { if (expr.Body is Exprs.MemberExpression) { return(MemberFromExprMemberExpr(expr.Body as Exprs.MemberExpression)); } else if (expr.Body is Exprs.UnaryExpression) { return(MemberFromExprUnaryExpr(expr.Body as Exprs.UnaryExpression)); } throw new NotSupportedException(expr.ToString()); }
static string PropertyNameFromLambdaExpr(Exprs.LambdaExpression expr) { if (expr.Body is Exprs.MemberExpression) { return(PropertyNameFromMemberExpr(expr.Body as Exprs.MemberExpression)); } else if (expr.Body is Exprs.UnaryExpression) { return(PropertyNameFromUnaryExpr(expr.Body as Exprs.UnaryExpression)); } throw new NotSupportedException(expr.ToString()); }
private static void ValidateOpAssignConversionLambda(LambdaExpression conversion, Expression left, MethodInfo method, ExpressionType nodeType) { Type delegateType = conversion.Type; Debug.Assert(typeof(System.MulticastDelegate).IsAssignableFrom(delegateType) && delegateType != typeof(System.MulticastDelegate)); MethodInfo mi = delegateType.GetMethod("Invoke"); ParameterInfo[] pms = mi.GetParametersCached(); Debug.Assert(pms.Length == conversion.Parameters.Count); if (pms.Length != 1) { throw Error.IncorrectNumberOfMethodCallArguments(conversion); } if (!TypeUtils.AreEquivalent(mi.ReturnType, left.Type)) { throw Error.OperandTypesDoNotMatchParameters(nodeType, conversion.ToString()); } if (method != null) { // The parameter type of conversion lambda must be the same as the return type of the overload method if (!TypeUtils.AreEquivalent(pms[0].ParameterType, method.ReturnType)) { throw Error.OverloadOperatorTypeDoesNotMatchConversionType(nodeType, conversion.ToString()); } } }
/// <summary> /// Creates a BinaryExpression that represents a coalescing operation. /// </summary> /// <param name="left">An <see cref="Expression"/> to set the <see cref="P:BinaryExpression.Left"/> property equal to.</param> /// <param name="right">An <see cref="Expression"/> to set the <see cref="P:BinaryExpression.Right"/> property equal to.</param> /// <param name="conversion">A LambdaExpression to set the Conversion property equal to.</param> /// <returns>A BinaryExpression that has the NodeType property equal to Coalesce and the Left, Right and Conversion properties set to the specified values. /// </returns> public static BinaryExpression Coalesce(Expression left, Expression right, LambdaExpression conversion) { RequiresCanRead(left, nameof(left)); RequiresCanRead(right, nameof(right)); if (conversion == null) { Type resultType = ValidateCoalesceArgTypes(left.Type, right.Type); return new SimpleBinaryExpression(ExpressionType.Coalesce, left, right, resultType); } if (left.Type.GetTypeInfo().IsValueType && !TypeUtils.IsNullableType(left.Type)) { throw Error.CoalesceUsedOnNonNullType(); } Type delegateType = conversion.Type; Debug.Assert(typeof(System.MulticastDelegate).IsAssignableFrom(delegateType) && delegateType != typeof(System.MulticastDelegate)); MethodInfo method = delegateType.GetMethod("Invoke"); if (method.ReturnType == typeof(void)) { throw Error.UserDefinedOperatorMustNotBeVoid(conversion, nameof(method)); } ParameterInfo[] pms = method.GetParametersCached(); Debug.Assert(pms.Length == conversion.Parameters.Count); if (pms.Length != 1) { throw Error.IncorrectNumberOfMethodCallArguments(conversion); } // The return type must match exactly. // We could weaken this restriction and // say that the return type must be assignable to from // the return type of the lambda. if (!TypeUtils.AreEquivalent(method.ReturnType, right.Type)) { throw Error.OperandTypesDoNotMatchParameters(ExpressionType.Coalesce, conversion.ToString()); } // The parameter of the conversion lambda must either be assignable // from the erased or unerased type of the left hand side. if (!ParameterIsAssignable(pms[0], TypeUtils.GetNonNullableType(left.Type)) && !ParameterIsAssignable(pms[0], left.Type)) { throw Error.OperandTypesDoNotMatchParameters(ExpressionType.Coalesce, conversion.ToString()); } return new CoalesceConversionBinaryExpression(left, right, conversion); }
public NotSupportedExpressionException(LambdaExpression expression, string message, Exception innerException) : base(message + Environment.NewLine + expression.ToString(), innerException) { Expression = expression; }
private static MemberExpression GetFirstMember(LambdaExpression expression) { if (expression.Body is BinaryExpression) return ((BinaryExpression)expression.Body).Left as MemberExpression; if (expression.Body is MemberExpression) return expression.Body as MemberExpression; if (expression.Body is UnaryExpression && expression.Body.NodeType == ExpressionType.Convert) return ((UnaryExpression)expression.Body).Operand as MemberExpression; throw new UnableToGetTheFirstMember(expression.ToString()); }
protected override Expression VisitMethodCall(MethodCallExpression m) { if (m.Method.DeclaringType == typeof(Queryable) && m.Method.Name == "Where") { this.Visit(m.Arguments[0]); queryTextBuilder.Append(" WHERE "); LambdaExpression lambda = (LambdaExpression)StripQuotes(m.Arguments[1]); this.Visit(lambda.Body); return m; } else if (m.Method.DeclaringType == typeof(Queryable) && m.Method.Name == "Single") { this.Visit(m.Arguments[0]); return m; } else if (m.Method.DeclaringType == typeof(Queryable) && m.Method.Name == "Select") { this.Visit(m.Arguments[0]); queryTextBuilder.Append(" SELECT "); selectMethod = (LambdaExpression)StripQuotes(m.Arguments[1]); queryTextBuilder.Append(selectMethod.ToString()); return m; } throw new NotSupportedException(string.Format("The method '{0}' is not supported", m.Method.Name)); }
private static Type ValidateConversion(CSharpExpressionType nodeType, Type inputType, LambdaExpression conversion) { var invoke = conversion.Type.GetMethod("Invoke"); var invokeParameters = invoke.GetParametersCached(); if (invokeParameters.Length != 1) { throw LinqError.IncorrectNumberOfMethodCallArguments(conversion); } if (!TypeUtils.AreEquivalent(invokeParameters[0].ParameterType, inputType)) { throw LinqError.OperandTypesDoNotMatchParameters(nodeType, conversion.ToString()); } return invoke.ReturnType; }
private void GetLambda(LambdaExpression lambda) { if (lambda.Body.Type != typeof(void)) { terms.Push(Expression.Constant( new BoxedConstant(lambda.ToString())) ); } }