public static MemberInfo ToProperty(this LambdaExpression expr) { var expression = expr.Body; var unaryExpression = expression as UnaryExpression; if (unaryExpression != null) { switch (unaryExpression.NodeType) { case ExpressionType.Convert: case ExpressionType.ConvertChecked: expression = unaryExpression.Operand; break; } } var me = expression as MemberExpression; if (me == null) { throw new InvalidOperationException("No idea how to convert " + expr.Body.NodeType + ", " + expr.Body + " to a member expression"); } return(me.Member); }
/// <summary> /// Analyzes a lambda expression to check whether it can be satisfied with /// $select and client-side materialization. /// </summary> /// <param name="le">Lambda expression.</param> /// <param name="re">Resource expression in scope.</param> /// <param name="matchMembers">Whether member accesses are matched as top-level projections.</param> /// <returns>true if the lambda is a client-side projection; false otherwise.</returns> internal static bool Analyze(LambdaExpression le, ResourceExpression re, bool matchMembers) { Debug.Assert(le != null, "le != null"); if (le.Body.NodeType == ExpressionType.Constant) { if (ClientType.CheckElementTypeIsEntity(le.Body.Type)) { throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity); } re.Projection = new ProjectionQueryOptionExpression(le.Body.Type, le, new List<string>()); return true; } if (le.Body.NodeType == ExpressionType.MemberInit || le.Body.NodeType == ExpressionType.New) { AnalyzeResourceExpression(le, re); return true; } if (matchMembers) { // Members can be projected standalone or type-casted. Expression withoutConverts = SkipConverts(le.Body); if (withoutConverts.NodeType == ExpressionType.MemberAccess) { AnalyzeResourceExpression(le, re); return true; } } return false; }
public GroupJoinExpressionNode ( MethodCallExpressionParseInfo parseInfo, Expression innerSequence, LambdaExpression outerKeySelector, LambdaExpression innerKeySelector, LambdaExpression resultSelector) : base(parseInfo) { ArgumentUtility.CheckNotNull ("innerSequence", innerSequence); ArgumentUtility.CheckNotNull ("outerKeySelector", outerKeySelector); ArgumentUtility.CheckNotNull ("innerKeySelector", innerKeySelector); ArgumentUtility.CheckNotNull ("resultSelector", resultSelector); if (outerKeySelector.Parameters.Count != 1) throw new ArgumentException ("Outer key selector must have exactly one parameter.", "outerKeySelector"); if (innerKeySelector.Parameters.Count != 1) throw new ArgumentException ("Inner key selector must have exactly one parameter.", "innerKeySelector"); if (resultSelector.Parameters.Count != 2) throw new ArgumentException ("Result selector must have exactly two parameters.", "resultSelector"); var joinResultSelector = Expression.Lambda (Expression.Constant (null), outerKeySelector.Parameters[0], innerKeySelector.Parameters[0]); JoinExpressionNode = new JoinExpressionNode (parseInfo, innerSequence, outerKeySelector, innerKeySelector, joinResultSelector); ResultSelector = resultSelector; _cachedResultSelector = new ResolvedExpressionCache<Expression> (this); }
public ThenIncludeExpressionNode( MethodCallExpressionParseInfo parseInfo, [NotNull] LambdaExpression navigationPropertyPathLambda) : base(parseInfo, null, null) { _navigationPropertyPathLambda = navigationPropertyPathLambda; }
/** * приводит лямбду (x, y, ...) => ... к виду: (x, y, ...) => fn(p, q, ...) * где fn - оптимизированная лямбда, p, q - предварительно вычисленные выражения * * пример: * Func<int, int, Func<int, int, int, int>, int> fn = (int x, int y, Func<int, int, int, int> Foo) => Foo(F(x), F(y), F(2 * y)); * Func<int, int, int> optimizedLambda = (int x, int y) => fn(1, 2, (int p, int q, int l) => p > q ? p : (p < l ? l : q)); */ public Expression Optimize(LambdaExpression lambda, string functionName) { if (_methodCalls != null) _methodCalls.Clear(); else _methodCalls = new Dictionary<string, MethodCall>(); _innerLambdaParams = new List<Expression>(); _functionName = functionName; // получаем оптимизированную лямбду Expression fn = BuildInnerLambda(lambda); // копируем параметры для новой лямбды ParameterExpression[] parameters = new ParameterExpression[lambda.Parameters.Count]; lambda.Parameters.CopyTo(parameters, 0); // собираем новую лямбду Expression optimizedLambda = Expression.Lambda( Expression.Invoke(fn, _innerLambdaParams), parameters ); return optimizedLambda; }
public override Expression GetUpdateExpression(IMappedEntity entity, Expression instance, LambdaExpression updateCheck, LambdaExpression selector) { var IdentifiableAlias = new IdentifiableAlias(); var table = new IdentifiableExpression(IdentifiableAlias, entity, ((OTypeMapping)this.Mapping).GetTableName(entity)); var where = this.GetIdentityCheck(table, entity, instance); if (updateCheck != null) { Expression typeProjector = this.GetEntityExpression(table, entity); Expression pred = DbExpressionReplacer.Replace(updateCheck.Body, updateCheck.Parameters[0], typeProjector); where = where.And(pred); } var assignments = this.GetFieldAssignments(table, instance, entity, (e, m) => ((OTypeMapping)this.Mapping).IsUpdatable(e, m)); Expression update = new UpdateCommandExpression(table, where, assignments); if (selector != null) { return CreateUpdateCommand(entity, instance, selector, where, assignments); } else { return update; } }
public static PropertyInfo FindProperty(LambdaExpression lambdaExpression) { Expression expressionToCheck = lambdaExpression; bool done = false; while (!done) { switch (expressionToCheck.NodeType) { case ExpressionType.Convert: expressionToCheck = ((UnaryExpression) expressionToCheck).Operand; break; case ExpressionType.Lambda: expressionToCheck = lambdaExpression.Body; break; case ExpressionType.MemberAccess: var propertyInfo = ((MemberExpression) expressionToCheck).Member as PropertyInfo; return propertyInfo; default: done = true; break; } } return null; }
public static Expression ReplaceParameters(LambdaExpression @in, IEnumerable<Expression> with) { Expression e = @in.Body; var withList = with.ToList(); if (withList.Count() == @in.Parameters.Count) { e = @in.Parameters.Zip(withList, (parameter, replace) => new {parameter, replace}) .Aggregate(e, (current, expression) => Rewrite(current, expression.parameter, expression.replace)); } else { foreach (var parameter in @in.Parameters) { ParameterExpression parameter1 = parameter; foreach (var withParameter in withList.Where(withParameter => parameter1.Type == withParameter.Type)) { e = Rewrite(e, parameter, withParameter); break; } } } return e; }
public void Inspect(LambdaExpression keysExpression, bool direction) { foreach (var columnMap in MapTransformer.Transform(keysExpression, queryBlock.QueryMap)) { keyMap.Add(new ColumnMapAndDesc(columnMap, direction)); } }
private static Func<ExpressionIterationNode, bool> ParsePattern(LambdaExpression pattern) { //foreach (var node in pattern.Iterate()) //{ //} }
public override bool IsValid(LambdaExpression expr) { // expression should be binary expresion if (!(expr.Body is BinaryExpression)) { return false; } var body = expr.Body as BinaryExpression; // // left operand should be binary expression // if (!(body.Left is BinaryExpression)) // { // return false; // } // // // right operand should be binary expression // if (!(body.Right is BinaryExpression)) // { // return false; // } var lambdaParam = expr.Parameters[0]; // check left operand if (!this.isExpressionValid(body.Left, lambdaParam)) { return false; } // check right operand if (!this.isExpressionValid(body.Right, lambdaParam)) { return false; } return true; }
public SelectManyExpressionNode ( MethodCallExpressionParseInfo parseInfo, LambdaExpression collectionSelector, LambdaExpression resultSelector) : base (parseInfo) { ArgumentUtility.CheckNotNull ("collectionSelector", collectionSelector); if (collectionSelector.Parameters.Count != 1) throw new ArgumentException ("Collection selector must have exactly one parameter.", "collectionSelector"); CollectionSelector = collectionSelector; if (resultSelector != null) { if (resultSelector.Parameters.Count != 2) throw new ArgumentException ("Result selector must have exactly two parameters.", "resultSelector"); ResultSelector = resultSelector; } else { var parameter1 = Expression.Parameter (collectionSelector.Parameters[0].Type, collectionSelector.Parameters[0].Name); var itemType = ReflectionUtility.GetItemTypeOfClosedGenericIEnumerable (CollectionSelector.Body.Type, "collectionSelector"); var parameter2 = Expression.Parameter (itemType, parseInfo.AssociatedIdentifier); ResultSelector = Expression.Lambda (parameter2, parameter1, parameter2); } _cachedCollectionSelector = new ResolvedExpressionCache<Expression> (this); _cachedResultSelector = new ResolvedExpressionCache<Expression> (this); }
internal DynamicFilterDefinition(string filterName, LambdaExpression predicate, string columnName, Type clrType) { FilterName = filterName; Predicate = predicate; ColumnName = columnName; _CLRType = clrType; }
/// <summary> /// Transforms a LambdaExpression to a debuggable LambdaExpression /// </summary> public MSAst.LambdaExpression TransformLambda(MSAst.LambdaExpression lambda, DebugLambdaInfo lambdaInfo) { ContractUtils.RequiresNotNull(lambda, "lambda"); ContractUtils.RequiresNotNull(lambdaInfo, "lambdaInfo"); return(new DebuggableLambdaBuilder(this, lambdaInfo).Transform(lambda)); }
/// <summary> /// Gets the name of the member used in the <paramref name="expression"/>. /// </summary> /// <param name="expression"> /// The <see cref="T:LambdaExpression"/> that calls the class member /// whose name should be returned. /// </param> /// <returns> /// The name of the member used in the <paramref name="expression"/>. /// </returns> public virtual string GetMemberName(LambdaExpression expression) { if (null == expression) throw new ArgumentNullException("expression"); var body = expression.Body; if (body != null) { var try1 = body as UnaryExpression; if (try1 != null) { var try11 = try1.Operand as MemberExpression; if (try11 != null) { return GetMemberName(try11); } var try12 = try1.Operand as MethodCallExpression; if (try12 != null) { return GetMemberName(try12); } } var try2 = body as MemberExpression; if (try2 != null) { return GetMemberName(try2); } var try3 = body as MethodCallExpression; if (try3 != null) { return GetMemberName(try3); } } throw new InvalidTargetMemberException(expression); }
public override IQueryBuilderRecord Process(LambdaExpression expression) { if (!StartsWithParameterReference(expression.Body)) CannotOptimize(expression.Body); return ApplyDirection(base.Process(expression)); }
// Terminology used in this file: // // - a "statement" is something like "x.Foo? AS Bar" // - "text" is a collection of statements, like "x.Foo? AS Bar, y.Baz as Qak" public static ReturnExpression BuildText(LambdaExpression expression, bool camelCaseProperties) { var body = expression.Body; if (body.NodeType == ExpressionType.Convert && body is UnaryExpression) { body = ((UnaryExpression)expression.Body).Operand; } string text; switch (body.NodeType) { case ExpressionType.MemberInit: var memberInitExpression = (MemberInitExpression) body; text = BuildText(memberInitExpression, camelCaseProperties); return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Projection}; case ExpressionType.New: var newExpression = (NewExpression) body; text = BuildText(newExpression,camelCaseProperties); return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Projection}; case ExpressionType.Call: var methodCallExpression = (MethodCallExpression) body; text = BuildText(methodCallExpression); return new ReturnExpression {Text = text, ResultMode = CypherResultMode.Set}; case ExpressionType.MemberAccess: var memberExpression = (MemberExpression) body; text = BuildText(memberExpression, camelCaseProperties); return new ReturnExpression { Text = text, ResultMode = CypherResultMode.Set }; default: throw new ArgumentException(WithExpressionShouldBeOneOfExceptionMessage, "expression"); } }
protected FetchExpressionNodeBase (MethodCallExpressionParseInfo parseInfo, LambdaExpression relatedObjectSelector) : base (parseInfo, null, null) { ArgumentUtility.CheckNotNull ("relatedObjectSelector", relatedObjectSelector); var memberExpression = relatedObjectSelector.Body as MemberExpression; if (memberExpression == null) { var message = string.Format ( "A fetch request must be a simple member access expression; '{0}' is a {1} instead.", relatedObjectSelector.Body, relatedObjectSelector.Body.GetType ().Name); throw new ArgumentException (message, "relatedObjectSelector"); } var owner = StripConverts (memberExpression.Expression); if (owner.NodeType != ExpressionType.Parameter) { var message = string.Format ( "A fetch request must be a simple member access expression of the kind o => o.Related; '{0}' is too complex.", relatedObjectSelector.Body); throw new ArgumentException (message, "relatedObjectSelector"); } RelationMember = memberExpression.Member; }
public override Expression GetDeleteExpression(MappingEntity entity, Expression instance, LambdaExpression deleteCheck) { var tables = this.mapping.GetTables(entity); if (tables.Count < 2) { return base.GetDeleteExpression(entity, instance, deleteCheck); } var commands = new List<Expression>(); foreach (var table in this.GetDependencyOrderedTables(entity).Reverse()) { TableExpression tex = new TableExpression(new TableAlias(), entity, this.mapping.GetTableName(table)); var where = this.GetIdentityCheck(tex, entity, instance); commands.Add(new DeleteCommand(tex, where)); } Expression block = new BlockCommand(commands); if (deleteCheck != null) { var test = this.GetEntityStateTest(entity, instance, deleteCheck); return new IFCommand(test, block, null); } return block; }
public ExpressionsPrinter(LambdaExpression expression) { Contract.Requires(expression != null, "expression should not be null."); _stringParameters = EvaluateParameters(expression.Parameters); _stringBody = EvaluateBody(expression.Body); }
private Expression ConvertLambda(LinqExp.LambdaExpression linqLambda) { return(Expression.Lambda( linqLambda.Type, ConvertExp(linqLambda.Body), linqLambda.Parameters.Project(Convert))); }
public static IEnumerable<Expression> Match(this LambdaExpression expression, LambdaExpression pattern) { //var patternSequence = pattern.Body.Iterate().ToList(); //if (patternSequence.Count == 0) //{ // throw new ArgumentException("Invalid pattern", "pattern"); //} //var rootNode = patternSequence[0]; //var partialMatches = new List<PartialMatch>(); //foreach (var node in expression.Iterate()) //{ // partialMatches.Add(new PartialMatch { Root = node }); // for (var i = partialMatches.Count - 1; i >= 0; --i) // { // var partialMatch = partialMatches[i]; // if (Matches(node, patternSequence[partialMatch.Position])) // { // partialMatch.Position++; // if (partialMatch.Position < patternSequence.Count) // { // continue; // } // yield return (Expression)partialMatch.Root.Element; // } // partialMatches.RemoveAt(i); // } //} }
internal MSAst.LambdaExpression Transform(MSAst.LambdaExpression lambda) { if (_alias == null) { _alias = lambda.Name; if (_alias == null) { _alias = "$lambda" + ++_lambdaId; } } // Create lambda builders _lambdaVars = new List <MSAst.ParameterExpression>(); _lambdaParams = new List <MSAst.ParameterExpression>(); _generatorVars = new List <MSAst.ParameterExpression>(); _generatorParams = new List <MSAst.ParameterExpression>(); if (lambda.Body is GeneratorExpression) { return(TransformGenerator(lambda)); } else { return(TransformLambda(lambda)); } }
public JoinExpressionNode( MethodCallExpressionParseInfo parseInfo, Expression innerSequence, LambdaExpression outerKeySelector, LambdaExpression innerKeySelector, LambdaExpression resultSelector) : base(parseInfo) { ArgumentUtility.CheckNotNull ("innerSequence", innerSequence); ArgumentUtility.CheckNotNull ("outerKeySelector", outerKeySelector); ArgumentUtility.CheckNotNull ("innerKeySelector", innerKeySelector); ArgumentUtility.CheckNotNull ("resultSelector", resultSelector); if (outerKeySelector.Parameters.Count != 1) throw new ArgumentException ("Outer key selector must have exactly one parameter.", "outerKeySelector"); if (innerKeySelector.Parameters.Count != 1) throw new ArgumentException ("Inner key selector must have exactly one parameter.", "innerKeySelector"); if (resultSelector.Parameters.Count != 2) throw new ArgumentException ("Result selector must have exactly two parameters.", "resultSelector"); InnerSequence = innerSequence; OuterKeySelector = outerKeySelector; InnerKeySelector = innerKeySelector; ResultSelector = resultSelector; _cachedOuterKeySelector = new ResolvedExpressionCache<Expression> (this); _cachedInnerKeySelector = new ResolvedExpressionCache<Expression> (this); _cachedResultSelector = new ResolvedExpressionCache<Expression> (this); }
private void CreateFunctionInfo(MSAst.LambdaExpression generatorFactoryLambda) { if (_lambdaInfo.CompilerSupport != null && _lambdaInfo.CompilerSupport.DoesExpressionNeedReduction(generatorFactoryLambda)) { _functionInfo = _lambdaInfo.CompilerSupport.QueueExpressionForReduction( Ast.Call( typeof(RuntimeOps).GetMethod("CreateFunctionInfo"), generatorFactoryLambda, AstUtils.Constant(_alias), AstUtils.Constant(_debugMarkerLocationMap, typeof(object)), AstUtils.Constant(_variableScopeMap, typeof(object)), AstUtils.Constant(_variableInfos, typeof(object)), Ast.Constant(_lambdaInfo.CustomPayload, typeof(object)) ) ); } else { _functionInfo = Ast.Constant( DebugContext.CreateFunctionInfo( generatorFactoryLambda.Compile(), _alias, _debugMarkerLocationMap, _variableScopeMap, _variableInfos, _lambdaInfo.CustomPayload), typeof(FunctionInfo)); } }
private static string ExtractMemberName(LambdaExpression expr) { var body = expr.Body; var parts = new List<string>(); for(;;) { switch(body.NodeType) { case ExpressionType.Convert: case ExpressionType.ConvertChecked: body = ((UnaryExpression)body).Operand; break; case ExpressionType.MemberAccess: var member = ((MemberExpression)body).Member; if(!member.DeclaringType.IsDefined(typeof(CompilerGeneratedAttribute), true)) // Don't add access to compiler-generated classes to our path because an expression such as () => command.Member.SubMember will contain an access to the "command" member of an anonymous type. { parts.Add(member.Name); } body = ((MemberExpression)body).Expression; break; case ExpressionType.Constant: case ExpressionType.Parameter: goto breakOuter; default: throw new ArgumentException("Expression must be a member expression, eg () => command.InvalidMember", "expr"); } } breakOuter: return ((IEnumerable<string>)parts).Reverse().Join("."); }
public static QualifiedMember ToTargetMember( this LinqExp.LambdaExpression memberAccess, MapperContext mapperContext, Action <ExpressionType> nonMemberAction) { return(memberAccess.ToDlrExpression().ToTargetMember(mapperContext, nonMemberAction)); }
private static string OutputFunctionBody(LambdaExpression function) { string body = function.Body.ToString(); body = MemberPattern.Replace(body, string.Empty); body = BoxingPattern.Replace(body, "$1"); return EscapeForTemplate(body); }
public static string GetPropertyName <TModel, TResult>(System.Linq.Expressions.Expression <Func <TModel, TResult> > property) { System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property; System.Linq.Expressions.MemberExpression memberExpression; if (lambda.Body is System.Linq.Expressions.UnaryExpression) { System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body); memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand); } else { memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body); } string parent = ""; if (typeof(TModel) != memberExpression.Expression.Type) /// sub property // to do hierahly cycle { var submemember = memberExpression.Expression as System.Linq.Expressions.MemberExpression; if (submemember != null) { parent = submemember.Member.Name + "."; } } return(parent + ((PropertyInfo)memberExpression.Member).Name); }
/// <summary>Creates a projection plan from the specified <paramref name="projection"/>.</summary> /// <param name="projection">Projection expression.</param> /// <param name="normalizerRewrites">Tracks rewrite-to-source rewrites introduced by expression normalizer.</param> /// <returns>A new <see cref="ProjectionPlan"/> instance.</returns> internal static ProjectionPlan CompilePlan(LambdaExpression projection, Dictionary<Expression, Expression> normalizerRewrites) { Debug.Assert(projection != null, "projection != null"); Debug.Assert(projection.Parameters.Count == 1, "projection.Parameters.Count == 1"); Debug.Assert( projection.Body.NodeType == ExpressionType.Constant || projection.Body.NodeType == ExpressionType.MemberInit || projection.Body.NodeType == ExpressionType.MemberAccess || projection.Body.NodeType == ExpressionType.Convert || projection.Body.NodeType == ExpressionType.ConvertChecked || projection.Body.NodeType == ExpressionType.New, "projection.Body.NodeType == Constant, MemberInit, MemberAccess, Convert(Checked) New"); ProjectionPlanCompiler rewriter = new ProjectionPlanCompiler(normalizerRewrites); #if TRACE_CLIENT_PROJECTIONS Trace.WriteLine("Projection: " + projection); #endif Expression plan = rewriter.Visit(projection); #if TRACE_CLIENT_PROJECTIONS Trace.WriteLine("Becomes: " + plan); #endif ProjectionPlan result = new ProjectionPlan(); result.Plan = (Func<object, object, Type, object>)((LambdaExpression)plan).Compile(); result.ProjectedType = projection.Body.Type; #if DEBUG result.SourceProjection = projection; result.TargetProjection = plan; #endif return result; }
public override void SetUp () { base.SetUp(); _keySelector = ExpressionHelper.CreateLambdaExpression<int, short> (i => (short) i); _elementSelector = ExpressionHelper.CreateLambdaExpression<int, string> (i => i.ToString()); _resultSelectorWithElementSelector = ExpressionHelper.CreateLambdaExpression<short, IEnumerable<string>, Tuple<short, int>> ((key, group) => Tuple.Create (key, group.Count())); _sourceEnumerable = ExpressionHelper.CreateIntQueryable(); var methodCallExpressionWithElementSelector = (MethodCallExpression) ExpressionHelper.MakeExpression ( () => _sourceEnumerable.GroupBy ( i => (short) i, i => i.ToString(), (key, group) => Tuple.Create (key, group.Count()))); _parseInfoWithElementSelector = new MethodCallExpressionParseInfo ("g", SourceNode, methodCallExpressionWithElementSelector); _nodeWithElementSelector = new GroupByWithResultSelectorExpressionNode ( _parseInfoWithElementSelector, _keySelector, _elementSelector, _resultSelectorWithElementSelector); var methodCallExpressionWithoutElementSelector = (MethodCallExpression) ExpressionHelper.MakeExpression ( () => _sourceEnumerable.GroupBy ( i => (short) i, (key, group) => Tuple.Create (key, group.Count()))); _resultSelectorWithoutElementSelector = ExpressionHelper.CreateLambdaExpression<short, IEnumerable<int>, Tuple<short, int>> ((key, group) => Tuple.Create (key, group.Count())); _nodeWithoutElementSelector = new GroupByWithResultSelectorExpressionNode ( new MethodCallExpressionParseInfo ("g", SourceNode, methodCallExpressionWithoutElementSelector), _keySelector, _resultSelectorWithoutElementSelector, null); }
internal Interpreter(LambdaExpression lambda, bool[] localIsBoxed, int maxStackDepth, InstructionArray instructions, ExceptionHandler[] handlers, DebugInfo[] debugInfos, int compilationThreshold) { _lambda = lambda; _numberOfLocals = localIsBoxed.Length; if (Array.IndexOf(localIsBoxed, true) != -1) { _localIsBoxed = localIsBoxed; } else { _localIsBoxed = null; } _maxStackDepth = maxStackDepth; _instructions = instructions; _objects = instructions.Objects; _handlers = handlers; _debugInfos = debugInfos; _onlyFaultHandlers = true; foreach (var handler in handlers) { if (!handler.IsFinallyOrFault) { _onlyFaultHandlers = false; break; } } _compilationThreshold = compilationThreshold; }
protected LambdaExpression UpdateLambda(LambdaExpression lambda, Type delegateType, Expression body, IEnumerable<ParameterExpression> parameters) { if (body != lambda.Body || parameters != lambda.Parameters || delegateType != lambda.Type) { return Expression.Lambda(delegateType, body, parameters); } return lambda; }
private void AddInclude(SimpleType source, MemberExpression memberSelector, LambdaExpression collectionInclude) { var members = source.GetAllMembers(); if (members.Count > 0 && memberSelector.GetDepth() > 1) { var innermostMember = ExpressionUtil.GetInnermostMemberExpression(memberSelector); foreach (var kvp in members) { if (kvp.Key == innermostMember.Member) { AddInclude(kvp.Value, ExpressionUtil.ReplaceInnermostMemberExpressionWithParameter(memberSelector) as MemberExpression, collectionInclude); return; } } } else { var parameter = ExpressionUtil.GetParameterExpression(memberSelector); if (collectionInclude != null) { source.Includes.Add(IncludeDirectiveUtil.GetIncludeInCollectionDirective(memberSelector, collectionInclude)); } else { source.Includes.Add(IncludeDirectiveUtil.GetIncludeDirective(memberSelector)); } } }
internal static void Analyze(LambdaExpression e, PathBox pb) { bool knownEntityType = CommonUtil.IsClientType(e.Body.Type); pb.PushParamExpression(e.Parameters.Last()); if (!knownEntityType) { NonEntityProjectionAnalyzer.Analyze(e.Body, pb); } else { switch (e.Body.NodeType) { case ExpressionType.MemberInit: EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb); break; case ExpressionType.New: throw new NotSupportedException(SR.ALinqCannotConstructKnownEntityTypes); case ExpressionType.Constant: throw new NotSupportedException(SR.ALinqCannotCreateConstantEntity); default: NonEntityProjectionAnalyzer.Analyze(e.Body, pb); break; } } pb.PopParamExpression(); }
public static LambdaExpression Combine(this LambdaExpression outer, LambdaExpression inner) { var invoke = Expression.Invoke(inner, outer.Body); var body = new ExpressionRewriter().AutoInline(invoke); return Expression.Lambda(body, outer.Parameters.ToArray()); }
internal static void Analyze(LambdaExpression e, PathBox pb) { bool knownEntityType = ClientType.CheckElementTypeIsEntity(e.Body.Type); pb.PushParamExpression(e.Parameters.Last()); if (!knownEntityType) { NonEntityProjectionAnalyzer.Analyze(e.Body, pb); } else { switch (e.Body.NodeType) { case ExpressionType.MemberInit: EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb); break; case ExpressionType.New: throw new NotSupportedException(Strings.ALinq_CannotConstructKnownEntityTypes); case ExpressionType.Constant: throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity); default: // ExpressionType.MemberAccess as a top-level expression is correctly // processed here, as the lambda isn't being member-initialized. NonEntityProjectionAnalyzer.Analyze(e.Body, pb); break; } } pb.PopParamExpression(); }
///<summary> /// Turn an expression like x=< x.User.Name to "User.Name" ///</summary> public static string ToPropertyPath(this LambdaExpression expr, char propertySeparator = '.', char collectionSeparator = ',') { var expression = expr.Body; return(expression.ToPropertyPath(propertySeparator, collectionSeparator)); }
public static string GetExpressionText(System.Linq.Expressions.LambdaExpression expression) { if (expression.Body != null && expression.Body.NodeType == System.Linq.Expressions.ExpressionType.Convert) { System.Linq.Expressions.UnaryExpression exp = expression.Body as System.Linq.Expressions.UnaryExpression; expression = System.Linq.Expressions.Expression.Lambda(exp.Operand, expression.Parameters.ToArray <System.Linq.Expressions.ParameterExpression>()); } return(ExpressionHelper.GetExpressionText(expression)); }
internal override void RewriteBody(PythonAst.LookupVisitor visitor) { _dlrBody = null; // clear the cached body if we've been reduced MSAst.Expression funcCode = GlobalParent.Constant(GetOrMakeFunctionCode()); FuncCodeExpr = funcCode; Body = new PythonAst.RewrittenBodyStatement(Body, visitor.Visit(Body)); }
/// <summary> /// /// </summary> /// <param name="entity"></param> /// <param name="type"></param> /// <param name="bDataBase"></param> /// <returns></returns> internal static DMS Create(object entity, Type type, string bDataBase) { DMS instance = new DMS(type, bDataBase, ConstExpression.WithLock, ConstExpression.NeedParams, ConstExpression.NeedQueryProvider); var param = System.Linq.Expressions.Expression.Parameter(type); System.Linq.Expressions.LambdaExpression lambdaExpr = System.Linq.Expressions.LambdaExpression.Lambda(param, param); instance.TableExpressioin.Append(lambdaExpr); return(instance); }
/// <summary> /// Creates the LambdaExpression which is the actual function body. /// </summary> private MSAst.LambdaExpression EnsureFunctionLambda() { if (_dlrBody == null) { PerfTrack.NoteEvent(PerfTrack.Categories.Compiler, "Creating FunctionBody"); _dlrBody = CreateFunctionLambda(); } return(_dlrBody); }
internal override MSAst.LambdaExpression GetLambda() { if (_dlrBody == null) { PerfTrack.NoteEvent(PerfTrack.Categories.Compiler, "Creating FunctionBody"); _dlrBody = MakeClassBody(); } return(_dlrBody); }
private void TraceWriteExpression(string title, System.Linq.Expressions.LambdaExpression expression) { Trace.WriteLine("--------------------------> " + title); Trace.WriteLine(String.Format("Body = {0}", expression.Body)); Trace.WriteLine(String.Format("Name = {0}", expression.Name)); Trace.WriteLine(String.Format("NodeType = {0}", expression.NodeType)); Trace.WriteLine(String.Format("Parameters = {0}", expression.Parameters)); Trace.WriteLine(String.Format("ReturnType = {0}", expression.ReturnType)); Trace.WriteLine(String.Format("Type = {0}", expression.Type)); }
private static IOrderedQueryable<T> Sort<T>(this IQueryable<T> queryable, SystemLinq.LambdaExpression lambdaExpression, MethodInfo methodInfo) { queryable.AssertNotNull(nameof(queryable)); var exp = lambdaExpression.CheckNotNull(nameof(lambdaExpression)).Body; var resultType = exp.Type; var funcType = typeof(Func<,>).MakeGenericType(typeof(T), resultType); var lambdaExpressionMethodInfo = MethodInfos.Expression.Lambda.MakeGenericMethod(funcType); var funcExpression = lambdaExpressionMethodInfo.Invoke(null, new object[] { exp, lambdaExpression.Parameters.ToArray() }); var method = methodInfo.MakeGenericMethod(typeof(T), resultType); var result = method.Invoke(null, new object[] { queryable, funcExpression! });
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()); }
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()); }
/// <summary> /// Returns an expression which creates the function object. /// </summary> internal MSAst.Expression MakeFunctionExpression() { List <MSAst.Expression> defaults = new List <MSAst.Expression>(0); foreach (var param in _parameters) { if (param.DefaultValue != null) { defaults.Add(AstUtils.Convert(param.DefaultValue, typeof(object))); } } MSAst.Expression funcCode = GlobalParent.Constant(GetOrMakeFunctionCode()); FuncCodeExpr = funcCode; MSAst.Expression ret; if (EmitDebugFunction()) { MSAst.LambdaExpression code = EnsureFunctionLambda(); // we need to compile all of the debuggable code together at once otherwise mdbg gets confused. If we're // in tracing mode we'll still compile things one off though just to keep things simple. The code will still // be debuggable but naive debuggers like mdbg will have more issues. ret = Ast.Call( AstMethods.MakeFunctionDebug, // method Parent.LocalContext, // 1. Emit CodeContext FuncCodeExpr, // 2. FunctionCode ((IPythonGlobalExpression)GetVariableExpression(_nameVariable)).RawValue(), // 3. module name defaults.Count == 0 ? // 4. default values AstUtils.Constant(null, typeof(object[])) : (MSAst.Expression)Ast.NewArrayInit(typeof(object), defaults), IsGenerator ? (MSAst.Expression) new PythonGeneratorExpression(code, GlobalParent.PyContext.Options.CompilationThreshold) : (MSAst.Expression)code ); } else { ret = Ast.Call( AstMethods.MakeFunction, // method Parent.LocalContext, // 1. Emit CodeContext FuncCodeExpr, // 2. FunctionCode ((IPythonGlobalExpression)GetVariableExpression(_nameVariable)).RawValue(), // 3. module name defaults.Count == 0 ? // 4. default values AstUtils.Constant(null, typeof(object[])) : (MSAst.Expression)Ast.NewArrayInit(typeof(object), defaults) ); } return(AddDecorators(ret, _decorators)); }
public static T CreateSetupNode <T>(IFluentNode node, System.Linq.Expressions.LambdaExpression expression) { var scope = node.FluentScope.CreateChild(); scope.Set(RegistryKeys.SetupExpression, expression); //TODO: Get rid of FluentNodeParent (If I can - I think it is only used by EndSetup now. EndSetup should use the same principle as IfScope). scope.Set(RegistryKeys.FluentNodeParent, node); //Clear all unwanted inherited values. scope.Delete(RegistryKeys.Rule); scope.Delete(RegistryKeys.IsCrossField); scope.Delete(RegistryKeys.CulpritResolver); return((T)CreateFluentNode(typeof(T), scope)); }
public static PropertyInfo GetPropertyName <T>(System.Linq.Expressions.Expression <Func <T, object> > property) { System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property; System.Linq.Expressions.MemberExpression memberExpression; if (lambda.Body is System.Linq.Expressions.UnaryExpression) { System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body); memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand); } else { memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body); } return((PropertyInfo)memberExpression.Member); }
private MSAst.LambdaExpression TransformGenerator(MSAst.LambdaExpression lambda) { GeneratorExpression generator = (GeneratorExpression)lambda.Body; MSAst.Expression body = generator.Body; _generatorLabelTarget = generator.Target; // $TODO: Detect if the label's type is not typeof(object), and create a new label Debug.Assert(_generatorLabelTarget.Type == typeof(object)); _generatorParams.Add(_frame); Dictionary <MSAst.ParameterExpression, object> parameters = new Dictionary <MSAst.ParameterExpression, object>(); foreach (MSAst.ParameterExpression parameter in lambda.Parameters) { parameters.Add(parameter, null); } // Add parameters to the pending list _pendingLocals.AddRange(lambda.Parameters); // Run 1st tree walk to identify all locals LambdaWalker lambdaWalker = new LambdaWalker(); lambdaWalker.Visit(body); // Add all locals to pending list _pendingLocals.AddRange(lambdaWalker.Locals); // Prepare variables LayoutVariablesForGenerator(parameters); // Rewrite for generator MSAst.Expression generatorBody = TransformToGeneratorBody(body); // Get the generator factory lambda MSAst.LambdaExpression generatorFactoryLambda = CreateGeneratorFactoryLambda(generatorBody); // Create FunctionInfo object CreateFunctionInfo(generatorFactoryLambda); // Create our own outer generator lambda return(CreateOuterGeneratorFactory(lambda.Type)); }
/// <summary> /// Tell bound controls (via WPF binding) to refresh their display. /// /// Sample call: this.NotifyPropertyChanged(() => this.IsSelected); /// where 'this' is derived from <seealso cref="BaseViewModel"/> /// and IsSelected is a property. /// </summary> /// <typeparam name="TProperty"></typeparam> /// <param name="property"></param> public void RaisePropertyChanged <TProperty>(Expression <Func <TProperty> > property) { System.Linq.Expressions.LambdaExpression lambda = (LambdaExpression)property; MemberExpression memberExpression; if (lambda.Body is UnaryExpression) { UnaryExpression unaryExpression = (UnaryExpression)lambda.Body; memberExpression = (MemberExpression)unaryExpression.Operand; } else { memberExpression = (MemberExpression)lambda.Body; } this.RaisePropertyChanged(memberExpression.Member.Name); }
internal Delegate GetDelegate(RubyScope /*!*/ declaringScope, RubyModule /*!*/ declaringModule) { if (_delegate == null) { lock (this) { if (_delegate == null) { // TODO: remove options AstGenerator gen = new AstGenerator(declaringScope.RubyContext, new RubyCompilerOptions(), _document, _encoding, false); MSA.LambdaExpression lambda = _ast.TransformBody(gen, declaringScope, declaringModule); _delegate = RubyScriptCode.CompileLambda(lambda, declaringScope.RubyContext); } } } return(_delegate); }
public static string GetPropertyName <TModel, TProperty>(System.Linq.Expressions.Expression <Func <TModel, TProperty> > property) { System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property; System.Linq.Expressions.MemberExpression memberExpression; if (lambda.Body is System.Linq.Expressions.UnaryExpression) { System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body); memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand); } else { memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body); } var xx = (PropertyInfo)memberExpression.Member; return(((PropertyInfo)memberExpression.Member).Name); }
/// <summary> /// Handle a project /// </summary> /// <param name="m"></param> /// <param name="createProjection"></param> private LE.Expression HandleProjectionOfSingleElement( System.Linq.Expressions.MethodCallExpression m, Func <String, NHEX.IProjection> createProjection) { if (m.Arguments.Count == 2) { LE.LambdaExpression l = (LE.LambdaExpression)Linq.Utils.Expression.StripQuotes(m.Arguments[1]); LE.MemberExpression me = (LE.MemberExpression)l.Body; String memberName = me.Member.Name; ProjectionsPropertyNames.Add(memberName); projections.Add(createProjection(memberName)); return(LE.Expression.Convert( //Call the GetValue on row passing currentcolumnindex as argument. LE.Expression.Call( row, miGetValue, LE.Expression.Constant(currentColumnIndex++)), me.Type)); } return(m); }
public static string GetDisplayName <TModel, TResult>(System.Linq.Expressions.Expression <Func <TModel, TResult> > property) { System.Linq.Expressions.LambdaExpression lambda = (System.Linq.Expressions.LambdaExpression)property; System.Linq.Expressions.MemberExpression memberExpression; if (lambda.Body is System.Linq.Expressions.UnaryExpression) { System.Linq.Expressions.UnaryExpression unaryExpression = (System.Linq.Expressions.UnaryExpression)(lambda.Body); memberExpression = (System.Linq.Expressions.MemberExpression)(unaryExpression.Operand); } else { memberExpression = (System.Linq.Expressions.MemberExpression)(lambda.Body); } var dispnameattr = memberExpression.Member.CustomAttributes.SingleOrDefault(at => at.AttributeType == typeof(DisplayNameAttribute)); if (dispnameattr != null && dispnameattr.ConstructorArguments.Count > 0) { return(dispnameattr.ConstructorArguments[0].Value.ToString()); } return(((PropertyInfo)memberExpression.Member).Name); }
public static QualifiedMember ToTargetMember(this LinqExp.LambdaExpression memberAccess, MapperContext mapperContext) => memberAccess.ToDlrExpression().ToTargetMember(mapperContext);
private MSAst.LambdaExpression TransformLambda(MSAst.LambdaExpression lambda) { MSAst.Expression body = lambda.Body; _lambdaVars.AddRange(new[] { _thread, _framePushed, _funcInfo, _traceLocations, _debugMarker, _frameExitException }); _generatorParams.Add(_frame); Type returnType = lambda.Type.GetMethod("Invoke").ReturnType; // Create $retVal variable only if the return type isn't void if (returnType == typeof(object)) { _retVal = _retValAsObject; } else if (returnType != typeof(void)) { _retVal = Ast.Variable(returnType, "$retVal"); } if (_retVal != null) { _lambdaVars.Add(_retVal); _generatorVars.Add(_retVal); } _lambdaVars.Add(_retValFromGeneratorLoop); Dictionary <MSAst.ParameterExpression, object> parameters = new Dictionary <MSAst.ParameterExpression, object>(); foreach (MSAst.ParameterExpression parameter in lambda.Parameters) { parameters.Add(parameter, null); } // Add parameters to the pending list _pendingLocals.AddRange(lambda.Parameters); // Run 1st tree walk to identify all locals LambdaWalker lambdaWalker = new LambdaWalker(); body = lambdaWalker.Visit(body); // Add all locals to pending list _pendingLocals.AddRange(lambdaWalker.Locals); // Process the variables LayOutVariables(lambdaWalker.StrongBoxedLocals, parameters); // Rewrite for generator MSAst.Expression generatorBody = TransformToGeneratorBody(body); // Add source file variables _lambdaVars.AddRange(_sourceFilesMap.Values); // Create the expression for pushing the frame CreatePushFrameExpression(); // Rewrite for debuggable body MSAst.Expression debuggableBody = TransformToDebuggableBody(body); // Get the generator factory lambda MSAst.LambdaExpression generatorFactoryLambda = CreateGeneratorFactoryLambda(generatorBody); // Create FunctionInfo object CreateFunctionInfo(generatorFactoryLambda); // Create the outer lambda return(CreateOuterLambda(lambda.Type, debuggableBody)); }
public void AddConditionOrThrow(LinqExp.LambdaExpression conditionLambda) => AddConditionOrThrow(conditionLambda.ToDlrExpression());
/// <summary> /// Transforms a LambdaExpression to a debuggable LambdaExpression /// </summary> public MSAst.LambdaExpression TransformLambda(MSAst.LambdaExpression lambda) { ContractUtils.RequiresNotNull(lambda, "lambda"); return(new DebuggableLambdaBuilder(this, new DebugLambdaInfo(null, null, false, null, null, null)).Transform(lambda)); }