using Microsoft.EntityFrameworkCore.Query;
using Microsoft.EntityFrameworkCore.Query.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using WalkingTec.Mvvm.Core.Extensions;
namespace WalkingTec.Mvvm.Core
{
///
/// 分析x==y这种类型的表达式,并储存在Dictionary中
///
public class SetValuesParser : ExpressionVisitor
{
private Dictionary _rv = new Dictionary();
///
/// 开始分析表达式
///
/// 源表达式
/// 将x==y这种表达式变为Dictionary并返回
public Dictionary Parse(Expression expression)
{
Visit(expression);
return _rv;
}
///
/// 处理所有二进制类型的表达式
///
/// 当前表达式节点
/// 修改后的表达式
protected override Expression VisitBinary(BinaryExpression node)
{
//如果表达式是x==y的类型,则获取y的值,并使用x最为key,y的值作为value添加到Dictionary中保存
if (node.NodeType == ExpressionType.Equal)
{
var pi = PropertyHelper.GetPropertyName(node.Left.NodeType == ExpressionType.Convert ? ((UnaryExpression)node.Left).Operand : node.Left);
if (!_rv.ContainsKey(pi))
{
_rv.Add(pi, Expression.Lambda(node.Right).Compile().DynamicInvoke());
}
}
return base.VisitBinary(node);
}
}
///
/// 替换表达式中的OrderBy语句
///
public class OrderReplaceModifier : ExpressionVisitor
{
private bool _addMode = false;
private SortInfo _sortinfo;
///
/// 构造函数
///
/// sortinfo
public OrderReplaceModifier(SortInfo sortinfo)
{
_sortinfo = sortinfo;
}
///
/// 修改where
///
/// 表达式
/// 修改后的表达式
public Expression Modify(Expression expression)
{
//先调用一次Visit,删除所有的where表达式
var rv = Visit(expression);
if ((rv is QueryRootExpression) || rv.Type.IsGeneric(typeof(EnumerableQuery<>)))
{
var modelType = rv.Type.GenericTypeArguments[0];
ParameterExpression pe = Expression.Parameter(modelType, "x");
Expression left1 = Expression.Constant(1);
Expression right1 = Expression.Constant(1);
Expression trueExp = Expression.Equal(left1, right1);
rv = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { modelType },
rv,
Expression.Lambda(trueExp, new ParameterExpression[] { pe }));
}
//将模式设为addMode,再调用一次Visit来添加新的表达式
_addMode = true;
rv = Visit(rv);
return rv;
}
///
/// 向表达式树上层寻找不是where的节点
///
/// 表达式
/// 返回表达式上层第一个不是where的节点
private Expression GetParentExpNotOrder(MethodCallExpression exp)
{
var parentNode = exp.Arguments[0] as MethodCallExpression;
if (parentNode == null || (parentNode.Method.Name.ToLower() != "orderby" && parentNode.Method.Name.ToLower() != "orderbydescending"))
{
if (parentNode == null)
{
return exp.Arguments[0];
}
return parentNode;
}
else
{
return GetParentExpNotOrder(parentNode);
}
}
///
/// 检查方法调用类型的表达式
///
/// 表达式节点
/// 修改后的表达式
protected override Expression VisitMethodCall(MethodCallExpression node)
{
//如果不是添加模式,那么删除所有的order
if (_addMode == false)
{
var aType = node.Arguments[0].Type;
//如果节点是order
if (node != null && (node.Method.Name.ToLower() == "orderby" || node.Method.Name.ToLower() == "orderbydescending" || node.Method.Name.ToLower() == "thenby" || node.Method.Name.ToLower() == "thenbydescending") && aType.GetTypeInfo().IsGenericType)
{
//继续往上找到不是where的节点
return GetParentExpNotOrder(node);
}
}
//如果是添加模式
else
{
var modelType = node.Type.GenericTypeArguments[0];
List info = new List() { _sortinfo };
Expression rv = null;
foreach (var item in info)
{
var idproperty = modelType.GetSingleProperty(item.Property);
if (idproperty == null)
{
return node;
}
var reftype = idproperty.DeclaringType;
ParameterExpression pe = Expression.Parameter(modelType, "x");
Expression pro = Expression.Property(pe, reftype.GetSingleProperty(item.Property));
Type proType = idproperty.PropertyType;
if (item.Direction == SortDir.Asc)
{
if (rv == null)
{
rv = Expression.Call(
typeof(Queryable),
"OrderBy",
new Type[] { modelType, proType },
node,
Expression.Lambda(pro, new ParameterExpression[] { pe }));
}
else
{
rv = Expression.Call(
typeof(Queryable),
"ThenBy",
new Type[] { modelType, proType },
rv,
Expression.Lambda(pro, new ParameterExpression[] { pe }));
}
}
if (item.Direction == SortDir.Desc)
{
if (rv == null)
{
rv = Expression.Call(
typeof(Queryable),
"OrderByDescending",
new Type[] { modelType, proType },
node,
Expression.Lambda(pro, new ParameterExpression[] { pe }));
}
else
{
rv = Expression.Call(
typeof(Queryable),
"ThenByDescending",
new Type[] { modelType, proType },
rv,
Expression.Lambda(pro, new ParameterExpression[] { pe }));
}
}
}
return rv;
}
return base.VisitMethodCall(node);
}
}
///
/// 替换表达式中的Where语句
///
public class WhereReplaceModifier : ExpressionVisitor where T : TopBasePoco
{
private Type _modelType;
private bool _addMode = false;
private Expression> _where;
///
/// 构造函数
///
/// 需要替换的新where语句
public WhereReplaceModifier(Expression> where)
{
_where = where;
}
///
/// 获取表达式的源数据类
///
/// 表达式
/// 表达式的源数据类型
private Type GetDCModel(Expression expression)
{
//如果表达式是方法调用的类型,则一直向上寻找,知道找到参数为ObjectQuery<>的表达式,它的类型就是整个表达式的源数据类型
if (expression.NodeType == ExpressionType.Call)
{
var exp = (expression as MethodCallExpression).Arguments[0];
if (exp is QueryRootExpression)
{
return exp.Type.GenericTypeArguments[0];
}
else
{
return GetDCModel(exp);
}
}
else if (expression.NodeType == ExpressionType.Constant)
{
if (expression is QueryRootExpression || expression.Type.IsGeneric(typeof(EnumerableQuery<>)))
{
return expression.Type.GenericTypeArguments[0];
}
else
{
return null;
}
}
else
{
return null;
}
}
///
/// 修改where
///
/// 表达式
/// 修改后的表达式
public Expression Modify(Expression expression)
{
//获取源类型
var checkType = GetDCModel(expression);
if (checkType != null)
{
_modelType = checkType;
//先调用一次Visit,删除所有的where表达式
var rv = Visit(expression);
//将模式设为addMode,再调用一次Visit来添加新的表达式
_addMode = true;
rv = Visit(rv);
return rv;
}
else
{
return expression;
}
}
///
/// 向表达式树上层寻找不是where的节点
///
/// 表达式
/// 返回表达式上层第一个不是where的节点
private Expression GetParentExpNotWhere(MethodCallExpression exp)
{
if (!(exp.Arguments[0] is MethodCallExpression parentNode))
{
return exp.Arguments[0];
}
else if (parentNode.Method.Name.ToLower() != "where")
{
return parentNode;
}
else
{
return GetParentExpNotWhere(parentNode);
}
}
protected override Expression VisitExtension(Expression node)
{
if (_addMode == true && node is QueryRootExpression)
{
if (node.Type.GenericTypeArguments[0] == _modelType)
{
ParameterExpression pe = Expression.Parameter(_modelType);
ChangePara cp = new ChangePara();
//传递过来的where条件,其源类型不一定和表达式中原有的相符,所以先将新where条件的源类型修改成和query一样的
//也就是说新的where条件可能是 x=>x.id==1, 而在表达式中不一定有x,所以要先统一
var modifiedWhere = cp.Change(_where.Body, pe);
var rv = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { _modelType },
node,
Expression.Lambda(modifiedWhere, new ParameterExpression[] { pe }));
return rv;
}
}
return base.VisitExtension(node);
}
///
/// 检查方法调用类型的表达式
///
/// 表达式节点
/// 修改后的表达式
protected override Expression VisitMethodCall(MethodCallExpression node)
{
//如果不是添加模式,那么删除所有的where条件
if (_addMode == false)
{
if (node.Arguments.Count == 0)
{
return base.VisitMethodCall(node);
}
var aType = node.Arguments[0].Type;
//如果节点的上一个节点是where
if (node.Arguments[0] is MethodCallExpression parentNode && parentNode.Method.Name.ToLower() == "where" && aType.GetTypeInfo().IsGenericType)
{
//继续往上找到不是where的节点
var nowhereNode = GetParentExpNotWhere(parentNode);
Type gType = aType.GetGenericTypeDefinition();
Type argType = aType.GenericTypeArguments[0];
//使用上面不是where的节点直接拼接本节点,从而删除了中间的where
if ((gType == typeof(IQueryable<>) || gType == typeof(QueryRootExpression)) && argType == _modelType)
{
var paras = new List
{
nowhereNode
};
paras.AddRange(node.Arguments.Skip(1).ToList());
var rv = Expression.Call(
node.Method,
paras);
return rv;
}
}
}
return base.VisitMethodCall(node);
}
}
///
/// 用于PersistPoco的搜索,检查查询语句中是否有IsValid的搜索条件,如果没有,默认加上IsValid=true
///
public class IsValidModifier : ExpressionVisitor
{
private Type _modelType;
private bool _needAdd = true;
private int _mode = 0; //0是搜素模式,1是添加模式
private Expression> _where;
///
/// 构造函数
///
public IsValidModifier()
{
_where = x => x.IsValid == true;
}
///
/// 获取表达式的源数据类
///
/// 表达式
/// 表达式的源数据类型
private Type GetDCModel(Expression expression)
{
//如果表达式是方法调用的类型,则一直向上寻找,知道找到参数为ObjectQuery<>的表达式,它的类型就是整个表达式的源数据类型
if (expression.NodeType == ExpressionType.Call)
{
var exp = (expression as MethodCallExpression).Arguments[0];
if (exp is QueryRootExpression)
{
return exp.Type.GenericTypeArguments[0];
}
else
{
return GetDCModel(exp);
}
}
else if (expression.NodeType == ExpressionType.Constant)
{
if (expression is QueryRootExpression || expression.Type.IsGeneric(typeof(EnumerableQuery<>)))
{
return expression.Type.GenericTypeArguments[0];
}
else
{
return null;
}
}
else
{
return null;
}
}
///
/// 修改where
///
/// 表达式
/// 修改后的表达式
public Expression Modify(Expression expression)
{
//获取源类型
var checkType = GetDCModel(expression);
if (checkType != null && typeof(IPersistPoco).IsAssignableFrom( checkType))
{
_modelType = checkType;
//先调用一次Visit,删除所有的where表达式
var rv = Visit(expression);
//将模式设为addMode,再调用一次Visit来添加新的表达式
if (_needAdd == true)
{
_mode = 1;
rv = Visit(rv);
}
return rv;
}
else
{
return expression;
}
}
///
/// 向表达式树上层寻找不是where的节点
///
/// 表达式
/// 返回表达式上层第一个不是where的节点
private Expression GetParentExpNotWhere(MethodCallExpression exp)
{
if (!(exp.Arguments[0] is MethodCallExpression parentNode))
{
return exp.Arguments[0];
}
else if (parentNode.Method.Name.ToLower() != "where")
{
return parentNode;
}
else
{
return GetParentExpNotWhere(parentNode);
}
}
protected override Expression VisitExtension(Expression node)
{
if (_mode == 1 && node is QueryRootExpression)
{
if (node.Type.GenericTypeArguments[0] == _modelType)
{
ParameterExpression pe = Expression.Parameter(_modelType);
ChangePara cp = new ChangePara();
//传递过来的where条件,其源类型不一定和表达式中原有的相符,所以先将新where条件的源类型修改成和query一样的
//也就是说新的where条件可能是 x=>x.id==1, 而在表达式中不一定有x,所以要先统一
var modifiedWhere = cp.Change(_where.Body, pe);
var rv = Expression.Call(
typeof(Queryable),
"Where",
new Type[] { _modelType },
node,
Expression.Lambda(modifiedWhere, new ParameterExpression[] { pe }));
return rv;
}
}
return base.VisitExtension(node);
}
///
/// 查找where中是否出现过对于IsValid的判断
///
///
///
protected override Expression VisitBinary(BinaryExpression node)
{
//如果表达式是x==y的类型,则获取y的值,并使用x最为key,y的值作为value添加到Dictionary中保存
if (_mode == 0)
{
if (node.NodeType == ExpressionType.Equal)
{
var pi = PropertyHelper.GetPropertyName(node.Left);
if (pi.ToLower() == "isvalid")
{
_needAdd = false;
}
}
}
return base.VisitBinary(node);
}
}
///
/// 修改表达式参数
///
public class ChangePara : ExpressionVisitor
{
ParameterExpression _pe;
///
/// 修改参数
///
/// 要修改的表达式
/// 新的参数
/// 修改后的表达式
public Expression Change(Expression expression, ParameterExpression pe)
{
_pe = pe;
return Visit(expression);
}
///
/// 检查所有参数类型的表达式
///
/// 表达式节点
/// 新的参数类型
protected override Expression VisitParameter(ParameterExpression node)
{
return _pe;
}
///
/// 检查所有成员访问类型的表达式
///
/// 表达式节点
/// 修改后的表达式
protected override Expression VisitMember(MemberExpression node)
{
if (node.Expression.NodeType == ExpressionType.Parameter)
{
var rv = Expression.MakeMemberAccess(_pe, _pe.Type.GetSingleProperty(node.Member.Name));
return rv;
}
else
{
return base.VisitMember(node);
}
}
}
///
/// 获取Select语句中选择的列的信息
///
public class SelectInfo : ExpressionVisitor
{
private List _columns;
private bool _found;
///
/// 构造函数
///
public SelectInfo()
{
}
///
/// 获取Select语句中选择的列的名字
///
/// 表达式
/// 列的名字
public List GetColumns(Expression expression)
{
Visit(expression);
return _columns;
}
///
/// 检查方法调用类型的表达式
///
/// 表达式节点
/// 修改后的表达式
protected override Expression VisitMethodCall(MethodCallExpression node)
{
if (_found == false)
{
if (node.Method.Name.ToLower() == "select")
{
if (node.Arguments[1] is UnaryExpression ue)
{
var inner = ue.Operand as LambdaExpression;
if (inner.Body is MemberInitExpression memberinit)
{
_columns = new List();
foreach (var m in memberinit.Bindings)
{
_columns.Add(m.Member.Name);
}
_found = true;
}
}
}
}
return base.VisitMethodCall(node);
}
}
public class ClearSelectMany : ExpressionVisitor
{
///
/// 构造函数
///
public ClearSelectMany()
{
}
///
/// 获取Select语句中选择的列的名字
///
/// 表达式
/// 列的名字
public Expression Clear(Expression expression)
{
return Visit(expression);
}
protected override Expression VisitMemberInit(MemberInitExpression node)
{
List newbinding = new List();
for (int i = 0; i < node.Bindings.Count; i++)
{
bool islist = false;
if (node.Bindings[i] is MemberAssignment ma && ma.Expression.Type.GetTypeInfo().IsGenericType == true)
{
if (ma.Expression.Type.GetGenericTypeDefinition() != typeof(Nullable<>))
{
islist = true;
}
}
if (islist == false)
{
newbinding.Add(node.Bindings[i]);
}
}
if (newbinding.Count < node.Bindings.Count)
{
return node.Update(node.NewExpression, newbinding);
}
else
{
return base.VisitMemberInit(node);
}
}
}
}