//// <summary> Gets the top most accessed property from the expression. For example `(X a) => a.B.C.D` will return descriptor of the property `D`. </summary> public static PropertyReference FromLambda <T>(LE.Expression <Func <T, object> > expr) { var b = expr.Body; while (b is LE.UnaryExpression uExpr && uExpr.NodeType == LE.ExpressionType.Convert) { b = uExpr.Operand; } switch (b) { case LE.MemberExpression memberExpr: if (memberExpr.Member is R.PropertyInfo prop) { return(FromReflection(prop)); } else { throw new NotSupportedException($"Can't get property reference from member {memberExpr.Member}"); } default: throw new NotSupportedException($"Can't get property reference from expression {b}"); } }
/// <summary> /// Execute an aggregation query. /// </summary> /// <typeparam name="K"></typeparam> /// <param name="keySelector">A Lambda expression which represents an accessor property of the field which shoule be aggregated.</param> /// <param name="aggregateType">One of the <see cref="AggregateType">AggregateType</see> enum members.</param> /// <returns>A single value, which represents the aggregate</returns> /// <remarks>Before using this function, make shure, that your database product supports the aggregate function, as defined in aggregateType. /// Polymorphy: StDev and Var only return the aggregate for the given class. All others return the aggregate for all subclasses. /// Transactions: Please note, that the aggregate functions always work against the database. /// Unsaved changes in your objects are not recognized.</remarks> public object ExecuteAggregate <K>(LE.Expression <Func <T, K> > keySelector, AggregateType aggregateType) { ExpressionTreeTransformer transformer = new ExpressionTreeTransformer(keySelector); string field = transformer.Transform(); return(ExecuteAggregate(field, aggregateType)); }
/// <summary> Gets the top most invoked method from the expression. For example `(String a) => a.Trim(anything)` will return descriptor of the Trim method. The function also supports properties (it will return the getter) and constuctors (using the `new XXX()` syntax). </summary> public static MethodReference FromLambda(LE.Expression <Action> expr) => FromLambda(expr.Body);
//--------------------------------------------------------------------- public override void Emit() { LE.Expression expression = this.Tree.Accept(this); this.Result = LE.Expression.Lambda <Func <double[], double> >(expression, _arrayParameter); }
/// <summary> Gets the top most invoked method from the expression. For example `(String a) => a.Trim(anything)` will return descriptor of the Trim method. The function also supports properties (it will return the getter) and constuctors (using the `new XXX()` syntax). </summary> public static MethodReference FromLambda(LE.Expression <Func <object> > expr) => FromLambda(expr.Body);