/// <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);
