/// <summary> /// 表达式路由 /// </summary> /// <param name="exp"></param> /// <returns></returns> string ExpressionRouter(System.Linq.Expressions.Expression exp) { //获取实体列的特性 List <EntityPropColumnAttributes> columnAttrList = AttributeHelper.GetEntityColumnAtrributes <TEntity>(); string sb = string.Empty; if (exp is System.Linq.Expressions.BinaryExpression)//二元运算符 { System.Linq.Expressions.BinaryExpression be = ((System.Linq.Expressions.BinaryExpression)exp); return(BinarExpressionProvider(be.Left, be.Right, be.NodeType)); } else if (exp is System.Linq.Expressions.MemberExpression)//成员 { System.Linq.Expressions.MemberExpression me = ((System.Linq.Expressions.MemberExpression)exp); return(me.Member.Name); } else if (exp is System.Linq.Expressions.NewArrayExpression)//数组 { System.Linq.Expressions.NewArrayExpression ae = ((System.Linq.Expressions.NewArrayExpression)exp); StringBuilder tmpstr = new StringBuilder(); foreach (System.Linq.Expressions.Expression ex in ae.Expressions) { tmpstr.Append(ExpressionRouter(ex)); tmpstr.Append(","); } return(tmpstr.ToString(0, tmpstr.Length - 1)); } else if (exp is System.Linq.Expressions.MethodCallExpression)//方法 { return(MethodExpression(exp)); } else if (exp is System.Linq.Expressions.ConstantExpression) { System.Linq.Expressions.ConstantExpression ce = ((System.Linq.Expressions.ConstantExpression)exp); if (ce.Value == null) { return("null"); } else if (ce.Value is ValueType) { return(ce.Value.ToString()); } else if (ce.Value is string || ce.Value is DateTime || ce.Value is char) { //return string.Format("'{0}'", ce.Value.ToString()); return(string.Format("{0}", ce.Value.ToString())); } } else if (exp is System.Linq.Expressions.UnaryExpression) { System.Linq.Expressions.UnaryExpression ue = ((System.Linq.Expressions.UnaryExpression)exp); return(ExpressionRouter(ue.Operand)); } return(null); }
internal static NewArrayInit NewArrayInit(NewArrayExpression expression) { return new NewArrayInit() { Type = TypeRef.Serialize(expression.Type.GetElementType()), Expressions = expression.Expressions.Any() ? expression.Expressions.Select(Serialize).ToArray() : null, }.Apply(n => n.Type = TypeRef.Serialize(expression.Type)); }
private IArgumentConstraint CreateParamArrayConstraint(NewArrayExpression expression) { var result = new List<IArgumentConstraint>(); foreach (var argumentExpression in expression.Expressions) { result.Add(this.GetArgumentConstraintFromExpression(argumentExpression)); } return new AggregateArgumentConstraint(result); }
protected override Expression VisitNewArray(NewArrayExpression node) { List<Visitor> elementVisitors = node.Expressions.Select(_ => new Visitor()).ToList(); List<Expression> elementExpressions = elementVisitors.Zip(node.Expressions, (v, e) => v.Visit(e)).ToList(); NewArrayExpression arrayExpression = Expression.NewArrayInit(elementExpressions.First().Type, elementExpressions); foreach (Visitor visitor in elementVisitors) _captureNode.AddChild(visitor.CaptureNode); return arrayExpression; }
protected virtual Expression ProcessNewArrayExpression(NewArrayExpression expression) { var notFirst = false; foreach (var member in expression.Expressions) { if (notFirst) CommandTextBuilder.Append(","); ProcessExpression(member); notFirst = true; } return expression; }
static Node ParseExpression(NewArrayExpression e) { switch (e.NodeType) { case ExpressionType.NewArrayInit: Type t = e.Type.GetElementType(); return new NewArrayNode { Items = e.Expressions.Select(Parse).ToList(), Type = NameOfType(t) }; case ExpressionType.NewArrayBounds: //todo: default: throw new ArgumentOutOfRangeException(); } }
protected override Expression VisitNewArray(NewArrayExpression node) { if (node.Type != typeof(Byte[])) { String message = String.Format("Resources.ExpressionEvaluatorTypeNotSupported {0}", node.Type); throw new NotSupportedException(message); } var array = new Byte[node.Expressions.Count]; for (int i = 0; i < node.Expressions.Count; i++) { ConstantExpression result = TryToEvaluate(node.Expressions[i]); array[i] = (Byte)result.Value; } return Expression.Constant(array, node.Type); }
protected override Expression VisitNewArray(NewArrayExpression expression) { if (expression.Type.GetArrayRank() == 1 && !expression.Type.GetElementType().IsDataAccessObjectType()) { if (expression.Expressions.All(c => c.Type.IsDataAccessObjectType())) { if (expression.NodeType == ExpressionType.NewArrayInit) { return Expression.NewArrayInit(typeof(DataAccessObject), this.VisitExpressionList(expression.Expressions)); } else { return Expression.NewArrayBounds(typeof(DataAccessObject), this.VisitExpressionList(expression.Expressions)); } } } return base.VisitNewArray(expression); }
/// <summary> /// Maps the specified type. /// </summary> /// <param name="type">The type.</param> /// <param name="value">The value.</param> /// <returns>Mapped <see cref="object" />.</returns> public override object Map(Type type, object value) { Type elementType = type.GetElementType(); List <System.Linq.Expressions.Expression> values = new List <System.Linq.Expressions.Expression>(); if (value.GetType() == typeof(JArray)) { JArray jsonArray = (JArray)value; foreach (JValue item in jsonArray.AsJEnumerable()) { UnaryExpression valueCast = (!elementType.IsValueType) ? Expression.TypeAs(Expression.Constant(item.ToString(CultureInfo.CurrentCulture)), elementType) : Expression.Convert(Expression.Constant(item.ToString(CultureInfo.CurrentCulture)), elementType); values.Add(valueCast); } } else if (value.GetType() == typeof(IEnumerable)) { IEnumerable enumerable = (IEnumerable)value; foreach (var item in enumerable) { UnaryExpression valueCast = (!elementType.IsValueType) ? Expression.TypeAs(Expression.Constant(item.ToString()), elementType) : Expression.Convert(Expression.Constant(item.ToString()), elementType); values.Add(valueCast); } } System.Linq.Expressions.NewArrayExpression newArrayExpression = System.Linq.Expressions.Expression.NewArrayInit(elementType, values); var func = Expression.Lambda <Func <object> >(newArrayExpression).Compile(); return(func()); }
static IEnumerable<Expression> CreateArrayInitExpressions(NewArrayExpression newArray, Expression valueExpression, Expression indexExpression) { if (newArray.NodeType == ExpressionType.NewArrayInit) { var indexGetter = (Func<int>) Expression.Lambda(indexExpression).Compile(); var index = indexGetter(); var expressions = newArray.Expressions.ToArray(); if (index >= newArray.Expressions.Count) { Array.Resize(ref expressions, index + 1); } expressions[index] = valueExpression; return expressions; } return new[] {valueExpression}; }
protected virtual Expression VisitNewArray(NewArrayExpression na) { IEnumerable<Expression> exprs = this.VisitExpressionList(na.Expressions); return this.UpdateNewArray(na, na.Type, exprs); }
/// <summary> /// NewArrayExpression visit method /// </summary> /// <param name="na">The NewArrayExpression to visit</param> /// <returns>The visited NewArrayExpression</returns> internal override Expression VisitNewArray(NewArrayExpression na) { this.cantTranslateExpression = true; return na; }
protected virtual bool CompareNewArray(NewArrayExpression a, NewArrayExpression b) { return this.CompareExpressionList(a.Expressions, b.Expressions); }
protected virtual object CompileNewArray(NewArrayExpression na) { var exprs = CompileExpressionList(na.Expressions); var sb = new StringBuilder(); foreach (var e in exprs) { sb.Append(sb.Length > 0 ? "," + e : e); } return sb.ToString(); }
/// <summary> /// NewArrayExpression visit method /// </summary> /// <param name="na">The NewArrayExpression to visit</param> /// <returns>The visited NewArrayExpression</returns> internal override Expression VisitNewArray(NewArrayExpression na) { throw new NotImplementedException(); }
/// <summary> /// Visits a NewArrayExpression. /// </summary> /// <param name="node">The NewArrayExpression.</param> /// <returns>The NewArrayExpression.</returns> protected override Expression VisitNewArray(NewArrayExpression node) { var elementType = node.Type.GetElementType(); _sb.AppendFormat("new {0}[] {{ ", FriendlyTypeName(elementType)); var separator = ""; foreach (var item in node.Expressions) { _sb.Append(separator); Visit(item); separator = ", "; } _sb.Append(" }"); return node; }
protected virtual Expression VisitNewArray(NewArrayExpression node) { var expressions = this.Visit(node.Expressions); return(UpdateNewArray(node, node.Type, expressions)); }
/// <summary> /// Visits the children of the <see cref="NewArrayExpression"/>. /// </summary> /// <param name="node">The expression to visit.</param> /// <returns>The modified expression, if it or any subexpression was modified; /// otherwise, returns the original expression.</returns> protected internal virtual Expression VisitNewArray(NewArrayExpression node) { return(node.Update(Visit(node.Expressions))); }
protected virtual bool VisitNewArray(NewArrayExpression na, NewArrayExpression na2) { return(na.Type == na2.Type && VisitExpressionList(na.Expressions, na2.Expressions)); }
protected override Expression VisitNewArray(NewArrayExpression node) { var exprs = Visit(nameof(node.Expressions), node.Expressions); return(Push(node, exprs)); }
protected override string VisitNewArray(NewArrayExpression node) => GetType(node.Type);
private static string VisitNewArray(NewArrayExpression node) { throw new NotImplementedException(); }
protected internal virtual new Expression VisitNewArray(NewArrayExpression node) { Contract.Requires(node != null); return(default(Expression)); }
protected internal virtual new Expression VisitNewArray(NewArrayExpression node) { return(default(Expression)); }
protected HqlTreeNode VisitNewArrayExpression(NewArrayExpression expression) { var visitor = new HqlGeneratorExpressionTreeVisitor(_parameters); var expressionSubTree = expression.Expressions.Select(exp => visitor.Visit(exp)); return _hqlTreeBuilder.ExpressionSubTreeHolder(expressionSubTree); }
protected virtual void VisitNewArray(NewArrayExpression newArray) { VisitExpressionList(newArray.Expressions); }
private Expression CreateInRangeExpression(Expression leftExpression, NewArrayExpression asRightRange) { var lower = (asRightRange.Expressions[0] as ConstantExpression).Value; var upper = (asRightRange.Expressions[1] as ConstantExpression).Value; lower = ChangeType(lower, leftExpression.Type); upper = ChangeType(upper, leftExpression.Type); if (Modifier == ModifierTypes.LessThan) { return Expression.LessThan(leftExpression, Expression.Constant(lower)); } if (Modifier == ModifierTypes.GreaterThan) { return Expression.GreaterThan(leftExpression, Expression.Constant(upper)); } else { if (lower.Equals(upper)) { return Expression.Equal(leftExpression, Expression.Constant(lower)); } else { return Expression.AndAlso ( Expression.LessThanOrEqual(leftExpression, Expression.Constant(upper)), Expression.GreaterThanOrEqual(leftExpression, Expression.Constant(lower)) ); } } }
public NewArrayExpressionProxy(NewArrayExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
protected virtual IList<object> CompileNewArrayFromExpressionList(NewArrayExpression na) { return CompileExpressionList(na.Expressions); }
private Expression Convert(LinqExp.NewArrayExpression linqNewArray, Func <Type, IEnumerable <Expression>, Expression> factory) { return(factory.Invoke( linqNewArray.Type.GetElementType(), Convert(linqNewArray.Expressions))); }
protected virtual Expression VisitNewArray (NewArrayExpression newArray) { Expression[] args; if (VisitExpressionList (newArray.Expressions, out args)) return Expression.NewArrayInit (newArray.Type, args); return newArray; }
public void 添加数据复杂语句测试lt() { string colm1 = "remake", val1 = " (select 666) "; System.Linq.Expressions.Expression <Func <LockPers, bool[]> > fiesExps = p => new bool[] { p.Content == "aa", p.IsDel == true, SM.Sql(colm1, val1), SM.Sql(p.Name, " (select 1) ") }; // System.Linq.Expressions.LambdaExpression colmvalambda = fiesExps as System.Linq.Expressions.LambdaExpression; System.Linq.Expressions.NewArrayExpression arryexps = colmvalambda.Body as System.Linq.Expressions.NewArrayExpression; StringBuilder sb = new StringBuilder(); Dapper.DynamicParameters spars = new Dapper.DynamicParameters(); int num = 1; string exgl = "="; sb.Append(" ( "); List <string[]> customColmval = new List <string[]>(); var lmbdParmName = colmvalambda.Parameters[0].Name; foreach (var p in arryexps.Expressions) { if (p.NodeType == System.Linq.Expressions.ExpressionType.Equal) { AnalysisExpression.BinaryExprssRowSqlParms(p, sb, spars, num++, exgl, (name, parmasName, exglstr) => string.Format("{0},", name)); //" {0} {2} @{0}{1} " } else if (p.NodeType == System.Linq.Expressions.ExpressionType.Call) { string[] arrColmval = new string[2]; // 0 column 1 value System.Linq.Expressions.MethodCallExpression method = p as System.Linq.Expressions.MethodCallExpression; int i = 0; tempstart: //meb = method.Arguments[0] as System.Linq.Expressions.MemberExpression; if (method.Arguments[i] is System.Linq.Expressions.ConstantExpression) { // 参数名/插入值 直接赋值 arrColmval[i] = (method.Arguments[i] as System.Linq.Expressions.ConstantExpression).Value.ToString(); } else if (method.Arguments[i] is System.Linq.Expressions.MemberExpression) {// 参数名/插入值 传入的时 变量 var meb = method.Arguments[i] as System.Linq.Expressions.MemberExpression; if (meb.Expression is System.Linq.Expressions.ParameterExpression && (meb.Expression as System.Linq.Expressions.ParameterExpression).Name == lmbdParmName) { // lambda表达式的参数成员 表示字段参数名 只取成员名称不取值 arrColmval[i] = (method.Arguments[i] as System.Linq.Expressions.MemberExpression).Member.Name; } else {// 外部传入的变量 arrColmval[i] = AnalysisExpression.GetMemberValue(method.Arguments[i] as System.Linq.Expressions.MemberExpression).ToString(); } } //(method.Arguments[i] as System.Linq.Expressions.MemberExpression).Member.Name; else { throw new Exception(p.ToString() + " 插入语句未能解析"); } if (++i < 2) { goto tempstart; } customColmval.Add(arrColmval); } else { throw new Exception(p.ToString() + " 插入语句未能解析"); } } sb.Remove(sb.Length - 1, 1); // 拼接子查询插入的 参数名 sb.Append((spars.ParameterNames.Count() > 0 && customColmval.Count > 0 ? ", " : string.Empty) + string.Join(",", customColmval.Select(p => p[0]).ToList <string>())); sb.AppendFormat(") values ({0}{1}) " , string.Join(",", spars.ParameterNames.ToList <string>().Select(p => "@" + p).ToList <string>()) , (spars.ParameterNames.Count() > 0 && customColmval.Count > 0 ? ", " : string.Empty) + string.Join(",", customColmval.Select(p => p[1]).ToList <string>()) ); Console.WriteLine(sb); return; // ############################################################ }
protected virtual Expression VisitNewArray(NewArrayExpression na) { IEnumerable<Expression> exprs = this.VisitExpressionList (na.Expressions); return exprs != na.Expressions ? (na.NodeType == ExpressionType.NewArrayInit ? Expression.NewArrayInit(na.Type.GetElementType(), exprs) : Expression.NewArrayBounds(na.Type.GetElementType(), exprs)) : na; }
/// <summary> /// Visit a new array expression. /// </summary> /// <param name="newArrayExp"></param> /// <returns></returns> protected virtual Expression VisitNewArray(NewArrayExpression newArrayExp) { IEnumerable<Expression> exprs = VisitList(newArrayExp.Expressions); if (exprs != newArrayExp.Expressions) { return newArrayExp.NodeType == ExpressionType.NewArrayInit ? Expression.NewArrayInit(newArrayExp.Type.GetElementType(), exprs) : Expression.NewArrayBounds(newArrayExp.Type.GetElementType(), exprs); } return newArrayExp; }
protected NewArrayExpression UpdateNewArray(NewArrayExpression na, Type arrayType, IEnumerable<Expression> expressions) { if (expressions != na.Expressions || na.Type != arrayType) { if (na.NodeType == ExpressionType.NewArrayInit) { return Expression.NewArrayInit(arrayType.GetElementType(), expressions); } else { return Expression.NewArrayBounds(arrayType.GetElementType(), expressions); } } return na; }
protected virtual System.Linq.Expressions.Expression VisitNewArray(NewArrayExpression na) { IEnumerable<System.Linq.Expressions.Expression> exprs = VisitExpressionList(na.Expressions); // ReSharper disable once PossibleUnintendedReferenceComparison if(exprs != na.Expressions) { if(na.NodeType == ExpressionType.NewArrayInit) { return System.Linq.Expressions.Expression.NewArrayInit(na.Type.GetElementType(), exprs); } return System.Linq.Expressions.Expression.NewArrayBounds(na.Type.GetElementType(), exprs); } return na; }
protected override Expression VisitNewArray(NewArrayExpression na) { this.Write("new "); this.Write(this.GetTypeName(TypeHelper.GetElementType(na.Type))); this.Write("[] {"); if (na.Expressions.Count > 1) this.WriteLine(Indentation.Inner); this.VisitExpressionList(na.Expressions); if (na.Expressions.Count > 1) this.WriteLine(Indentation.Outer); this.Write("}"); return na; }
internal virtual void VisitNewArray(NewArrayExpression newArray) { VisitExpressionList(newArray.Expressions); }
public NewArrayExpressionMutator(NewArrayExpression expression) { NewArrayExpression = expression; }
protected virtual Expression VisitNewArray(NewArrayExpression node) { throw new NotImplementedException(); }
/// <summary> /// Visits a NewArrayExpression. /// </summary> /// <param name="node">The NewArrayExpression.</param> /// <returns>The NewArrayExpression.</returns> protected override Expression VisitNewArray(NewArrayExpression node) { throw new NotImplementedException(); }
internal override Expression VisitNewArray(NewArrayExpression na) { throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(this.type, na.ToString())); }
EvaluationResult NewArrayInit(NewArrayExpression expression) { return GuardedInvocation(expression, () => { var result = Array.CreateInstance(expression.Type.GetElementType(), expression.Expressions.Count); for(var i = 0; i != result.Length; ++i) result.SetValue(Evaluate(expression.Expressions[i]).Result, i); return Success(expression.Type, result); }); }
internal override Expression VisitNewArray(NewArrayExpression na) { throw new NotSupportedException(Strings.ALinq_NewArrayNotSupported); }
/// <summary> /// Visits a NewArrayExpression. /// </summary> /// <param name="na">The NewArrayExpression.</param> /// <returns>The NewArrayExpression (possibly modified).</returns> protected virtual Expression VisitNewArray(NewArrayExpression na) { IEnumerable<Expression> exprs = this.VisitExpressionList(na.Expressions); if (exprs != na.Expressions) { if (na.NodeType == ExpressionType.NewArrayInit) { return Expression.NewArrayInit(na.Type.GetElementType(), exprs); } else { return Expression.NewArrayBounds(na.Type.GetElementType(), exprs); } } return na; }
protected override Expression VisitNewArray(NewArrayExpression na) => InvokeEvent(NewArrayVisited, na, base.VisitNewArray);