first commit
This commit is contained in:
@@ -0,0 +1,79 @@
|
||||
using System;
|
||||
using System.Linq.Expressions;
|
||||
|
||||
namespace JSMachine.WMS.Infrastructure.LambdaHelp
|
||||
{
|
||||
public static class ExpressionExtension
|
||||
{
|
||||
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
|
||||
{
|
||||
if (expr1 == null)
|
||||
return expr2;
|
||||
else if (expr2 == null)
|
||||
return expr1;
|
||||
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.AndAlso(expr1.Body, expr2.Body), expr1.Parameters);
|
||||
ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
|
||||
NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);
|
||||
|
||||
var left = visitor.Replace(expr1.Body);
|
||||
var right = visitor.Replace(expr2.Body);
|
||||
var body = Expression.And(left, right);
|
||||
return Expression.Lambda<Func<T, bool>>(body, newParameter);
|
||||
}
|
||||
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
|
||||
{
|
||||
if (expr1 == null)
|
||||
return expr2;
|
||||
else if (expr2 == null)
|
||||
return expr1;
|
||||
|
||||
ParameterExpression newParameter = Expression.Parameter(typeof(T), "c");
|
||||
NewExpressionVisitor visitor = new NewExpressionVisitor(newParameter);
|
||||
|
||||
var left = visitor.Replace(expr1.Body);
|
||||
var right = visitor.Replace(expr2.Body);
|
||||
var body = Expression.Or(left, right);
|
||||
return Expression.Lambda<Func<T, bool>>(body, newParameter);
|
||||
}
|
||||
|
||||
//与拼接
|
||||
public static Expression<Func<T, bool>> AndAlso<T>(this Expression<Func<T, bool>> a, Expression<Func<T, bool>> b)
|
||||
{
|
||||
var p = Expression.Parameter(typeof(T), "p");
|
||||
var bd = Expression.AndAlso(
|
||||
Expression.Invoke(a, p),
|
||||
Expression.Invoke(b, p));
|
||||
var ld = Expression.Lambda<Func<T, bool>>(bd, p);
|
||||
return ld;
|
||||
}
|
||||
|
||||
//或拼接
|
||||
public static Expression<Func<T, bool>> Orelse<T>(this Expression<Func<T, bool>> a, Expression<Func<T, bool>> b)
|
||||
{
|
||||
var p = Expression.Parameter(typeof(T), "p");
|
||||
var bd = Expression.OrElse(
|
||||
Expression.Invoke(a, p),
|
||||
Expression.Invoke(b, p));
|
||||
var ld = Expression.Lambda<Func<T, bool>>(bd, p);
|
||||
return ld;
|
||||
}
|
||||
}
|
||||
|
||||
internal class NewExpressionVisitor : ExpressionVisitor
|
||||
{
|
||||
public ParameterExpression _NewParameter { get; private set; }
|
||||
public NewExpressionVisitor(ParameterExpression param)
|
||||
{
|
||||
this._NewParameter = param;
|
||||
}
|
||||
public Expression Replace(Expression exp)
|
||||
{
|
||||
return this.Visit(exp);
|
||||
}
|
||||
protected override Expression VisitParameter(ParameterExpression node)
|
||||
{
|
||||
return this._NewParameter;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,438 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
|
||||
namespace JSMachine.WMS.Infrastructure.LambdaHelp
|
||||
{
|
||||
public static class ExpressionTreeHelper<T>
|
||||
{
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p == null
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> Null(string propertyName)
|
||||
{
|
||||
return p => p.GetType().GetProperty(propertyName).GetValue(p) == null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>true
|
||||
/// </summary>p != null
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <returns></returns>zhangsansss
|
||||
public static Expression<Func<T, bool>> NotNull(string propertyName)
|
||||
{
|
||||
return p => p.GetType().GetProperty(propertyName).GetValue(p) != null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>true
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> True()
|
||||
{
|
||||
return p => true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>false
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> False()
|
||||
{
|
||||
return p => false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <typeparam name="TKey"></typeparam>
|
||||
/// <param name="sort"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, TKey>> GetOrderExpression<TKey>(string propertyName)
|
||||
{
|
||||
ParameterExpression param = Expression.Parameter(typeof(T), "t");
|
||||
|
||||
return Expression.Lambda<Func<T, TKey>>
|
||||
(
|
||||
Expression.Convert(Expression.Property(param, propertyName),
|
||||
typeof(object)),
|
||||
param
|
||||
);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName == propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateEqual(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
Type type = typeof(T).GetProperty(propertyName).PropertyType;
|
||||
|
||||
if (!UnifyParamType(type, ref propertyValue))
|
||||
{
|
||||
return False();
|
||||
}
|
||||
|
||||
////Type type = typeof(T).GetProperty(propertyName).PropertyType;
|
||||
////propertyValue = propertyValue.ToString();
|
||||
////propertyValue = Convert.ChangeType(propertyValue, type);
|
||||
|
||||
//ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
//MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
//ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
//return MyEqual(member, constant, parameter);
|
||||
|
||||
//propertyValue = propertyValue.ToString();
|
||||
//propertyValue = Convert.ChangeType(propertyValue, type);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.Equal(member, constant), parameter);
|
||||
|
||||
return MyEqual(member,constant,parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName != propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="propertyName"></param>
|
||||
/// <param name="propertyValue"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateNotEqual(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
Type type = typeof(T).GetProperty(propertyName).PropertyType;
|
||||
propertyValue = Convert.ChangeType(propertyValue, type);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.NotEqual(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式: p=>propertyValue.Contains(p.propertyName) 目前仅支持 List<string>类型，后期完善
|
||||
/// </summary>
|
||||
/// <param name="propertyName"></param>
|
||||
/// <param name="propertyValue"></param>
|
||||
/// <returns></returns>
|
||||
internal static Expression<Func<T, bool>> GetIn(string propertyName, object propertyValue)
|
||||
{
|
||||
//目前仅支持 List<string>类型，后期完善
|
||||
try
|
||||
{
|
||||
//使用Newtonsoft的ToObject方法将JArray转换成List<string>类型
|
||||
List<string> lst = ((dynamic)propertyValue).ToObject<List<string>>();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
|
||||
MethodInfo method = typeof(List<string>).GetMethod("Contains", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(lst, typeof(List<string>));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Call(constant, method, member), parameter);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("查询的参数不合法，无法解析成表达式目录树");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName > propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateGreaterThan(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
UnifyParamType(typeof(T).GetProperty(propertyName).PropertyType, ref propertyValue);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
return MyGreaterThan(member, constant, parameter);
|
||||
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.GreaterThan(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName < propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateLessThan(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
UnifyParamType(typeof(T).GetProperty(propertyName).PropertyType, ref propertyValue);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
return MyLessThan(member, constant, parameter);
|
||||
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.LessThan(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName >= propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateGreaterThanOrEqual(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
UnifyParamType(typeof(T).GetProperty(propertyName).PropertyType, ref propertyValue);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
return MyGreaterThanOrEqual(member, constant, parameter);
|
||||
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.GreaterThanOrEqual(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName <= propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateLessThanOrEqual(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
UnifyParamType(typeof(T).GetProperty(propertyName).PropertyType, ref propertyValue);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
return MyLessThanOrEqual(member, constant, parameter);
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.LessThanOrEqual(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName.Contains(propertyValue)
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> GetContains(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
Type type = typeof(T).GetProperty(propertyName).PropertyType;
|
||||
|
||||
if (!UnifyParamType(type, ref propertyValue))
|
||||
{
|
||||
return False();
|
||||
}
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Call(member, method, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：!(p=>p.propertyName.Contains(propertyValue))
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> GetNotContains(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Not(Expression.Call(member, method, constant)), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：!(p=>p.propertyName.StartsWith(propertyValue))
|
||||
/// </summary>
|
||||
/// <param name="propertyName"></param>
|
||||
/// <param name="propertyValue"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> GetStartsWith(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
MethodInfo method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Not(Expression.Call(member, method, constant)), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：!(p=>p.propertyName.EndsWith(propertyValue))
|
||||
/// </summary>
|
||||
/// <param name="propertyName"></param>
|
||||
/// <param name="propertyValue"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> GetEndsWith(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
MethodInfo method = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Not(Expression.Call(member, method, constant)), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 统一参数类型（值大小比较方法中只支持int和DateTime类型，但上端传递过来的参数有可能为string类型，故需要使用反射的方式统一参数类型）
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
private static bool UnifyParamType(Type type, ref object param)
|
||||
{
|
||||
//如果类型转换失败，说明无法转换，比如将字符串 aaa转换为 int类型等
|
||||
try
|
||||
{
|
||||
if (IsNullableType(type))
|
||||
{
|
||||
NullableConverter nullableConverter = new(type);
|
||||
param = nullableConverter.ConvertFromString(param.ToString());
|
||||
}
|
||||
else
|
||||
{
|
||||
//if (type != param.GetType())
|
||||
param = Convert.ChangeType(param, type);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
return false;
|
||||
throw ex;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 判断可空类型
|
||||
/// </summary>
|
||||
/// <param name="theType"></param>
|
||||
/// <returns></returns>
|
||||
private static bool IsNullableType(Type theType)
|
||||
{
|
||||
return (theType.IsGenericType && theType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 自定义小于比较
|
||||
/// </summary>
|
||||
/// <param name="e1"></param>
|
||||
/// <param name="e2"></param>
|
||||
/// <param name="parameter"></param>
|
||||
/// <returns></returns>
|
||||
private static Expression<Func<T, bool>> MyGreaterThan(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.GreaterThan(e1, e2), parameter);
|
||||
}
|
||||
|
||||
private static Expression<Func<T,bool>> MyEqual(Expression e1,Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Equal(e1, e2), parameter);
|
||||
}
|
||||
|
||||
private static Expression<Func<T, bool>> MyContains(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Equal(e1, e2), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 自定义大于比较
|
||||
/// </summary>
|
||||
/// <param name="e1"></param>
|
||||
/// <param name="e2"></param>
|
||||
/// <param name="parameter"></param>
|
||||
/// <returns></returns>
|
||||
private static Expression<Func<T, bool>> MyLessThan(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.LessThan(e1, e2), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 自定义大于等于比较
|
||||
/// </summary>
|
||||
/// <param name="e1"></param>
|
||||
/// <param name="e2"></param>
|
||||
/// <param name="parameter"></param>
|
||||
/// <returns></returns>
|
||||
private static Expression<Func<T, bool>> MyGreaterThanOrEqual(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.GreaterThanOrEqual(e1, e2), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 自定义小于等于比较
|
||||
/// </summary>
|
||||
/// <param name="e1"></param>
|
||||
/// <param name="e2"></param>
|
||||
/// <param name="parameter"></param>
|
||||
/// <returns></returns>
|
||||
private static Expression<Func<T, bool>> MyLessThanOrEqual(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.LessThanOrEqual(e1, e2), parameter);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
using System.Collections.Generic;
|
||||
using System.Collections.ObjectModel;
|
||||
|
||||
namespace JSMachine.WMS.Infrastructure.LambdaHelp
|
||||
{
|
||||
public class FilterCollection : Collection<IList<Filter>>
|
||||
{
|
||||
public FilterCollection() : base()
|
||||
{ }
|
||||
|
||||
public FilterCollection(IList<IList<Filter>> lst) : base(lst)
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
public class Filter
|
||||
{
|
||||
public string PropertyName { get; set; }
|
||||
public Op Operation { get; set; }
|
||||
public object Value { get; set; }
|
||||
}
|
||||
|
||||
public enum Op
|
||||
{
|
||||
NULL = 0,
|
||||
NOTNUL = 1,
|
||||
//查询List<string>类型的，当Count=0的时候选中(仅在MongoDB中有效)
|
||||
Empty = 2,
|
||||
//查询List<string>类型的，当Count>0的时候选中(仅在MongoDB中有效)
|
||||
NotEmpty = 3,
|
||||
Equals = 4,
|
||||
NotEquals = 5,
|
||||
GreaterThan = 6,
|
||||
LessThan = 7,
|
||||
GreaterThanOrEqual = 8,
|
||||
LessThanOrEqual = 9,
|
||||
Contains = 10,
|
||||
NotContains = 11,
|
||||
StartsWith = 12,
|
||||
EndsWith = 13,
|
||||
//包含查询，目前仅支持List<string>
|
||||
In = 14
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq.Expressions;
|
||||
|
||||
namespace JSMachine.WMS.Infrastructure.LambdaHelp
|
||||
{
|
||||
public static class LambdaBuider<T>
|
||||
{
|
||||
public static Expression<Func<T, bool>> BuildExpreesion(FilterCollection filters)
|
||||
{
|
||||
Expression<Func<T, bool>> baseExpression = t => false;
|
||||
|
||||
|
||||
|
||||
if (filters == null || filters.Count == 0)
|
||||
return t => true;
|
||||
|
||||
List<Expression<Func<T, bool>>> orExpressions = new List<Expression<Func<T, bool>>>();
|
||||
|
||||
for (int i = 0; i < filters.Count; i++)
|
||||
{
|
||||
for (int j = 0; j < filters[i].Count; j++)
|
||||
{
|
||||
string propName = filters[i][j].PropertyName;
|
||||
object value = filters[i][j].Value;
|
||||
|
||||
switch (filters[i][j].Operation)
|
||||
{
|
||||
case Op.NULL:
|
||||
{
|
||||
if (typeof(T).GetProperty(propName).PropertyType == typeof(int) || typeof(T).GetProperty(propName) == typeof(long))
|
||||
{
|
||||
baseExpression = baseExpression.Or(LambdaHelper<T>.CreateEqual(propName, 0));
|
||||
}
|
||||
else
|
||||
{
|
||||
baseExpression = baseExpression.Or(LambdaHelper<T>.Null(propName));
|
||||
}
|
||||
}; break;
|
||||
case Op.NOTNUL:
|
||||
{
|
||||
if (typeof(T).GetProperty(propName).PropertyType == typeof(int) || typeof(T).GetProperty(propName) == typeof(long))
|
||||
{
|
||||
baseExpression = baseExpression.Or(LambdaHelper<T>.CreateNotEqual(propName, 0));
|
||||
}
|
||||
else
|
||||
{
|
||||
baseExpression = baseExpression.Or(LambdaHelper<T>.NotNull(propName));
|
||||
}
|
||||
}; break;
|
||||
case Op.Equals: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateEqual(propName, value)); break;
|
||||
case Op.NotEquals: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateNotEqual(propName, value)); break;
|
||||
case Op.GreaterThan: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateGreaterThan(propName, value)); break;
|
||||
case Op.LessThan: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateLessThan(propName, value)); break;
|
||||
case Op.GreaterThanOrEqual: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateGreaterThanOrEqual(propName, value)); break;
|
||||
case Op.LessThanOrEqual: baseExpression = baseExpression.Or(LambdaHelper<T>.CreateLessThanOrEqual(propName, value)); break;
|
||||
case Op.Contains: baseExpression = baseExpression.Or(LambdaHelper<T>.GetContains(propName, value)); break;
|
||||
case Op.NotContains: baseExpression = baseExpression.Or(LambdaHelper<T>.GetNotContains(propName, value)); break;
|
||||
case Op.StartsWith: baseExpression = baseExpression.Or(LambdaHelper<T>.GetStartsWith(propName, value)); break;
|
||||
case Op.EndsWith: baseExpression = baseExpression.Or(LambdaHelper<T>.GetEndsWith(propName, value)); break;
|
||||
case Op.In: baseExpression = baseExpression.Or(LambdaHelper<T>.GetIn(propName, value)); break;
|
||||
}
|
||||
}
|
||||
|
||||
orExpressions.Add(baseExpression);
|
||||
baseExpression = p => false;
|
||||
}
|
||||
|
||||
Expression<Func<T, bool>> resultExpression = p => true;
|
||||
orExpressions.ForEach(x =>
|
||||
{
|
||||
resultExpression = resultExpression.And(x);
|
||||
});
|
||||
|
||||
return resultExpression;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,388 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.ComponentModel;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
|
||||
namespace JSMachine.WMS.Infrastructure.LambdaHelp
|
||||
{
|
||||
public static class LambdaHelper<T>
|
||||
{
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p == null
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> Null(string propertyName)
|
||||
{
|
||||
return p => p.GetType().GetProperty(propertyName).GetValue(p) == null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>true
|
||||
/// </summary>p != null
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <returns></returns>zhangsansss
|
||||
public static Expression<Func<T, bool>> NotNull(string propertyName)
|
||||
{
|
||||
return p => p.GetType().GetProperty(propertyName).GetValue(p) != null;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>true
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> True()
|
||||
{
|
||||
return p => true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>false
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> False()
|
||||
{
|
||||
return p => false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <typeparam name="TKey"></typeparam>
|
||||
/// <param name="sort"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, TKey>> GetOrderExpression<TKey>(string propertyName)
|
||||
{
|
||||
ParameterExpression param = Expression.Parameter(typeof(T), "t");
|
||||
//MemberExpression body = Expression.Property(param, propertyName);
|
||||
//return Expression.Lambda<Func<T, TKey>>(Expression.Convert(body, typeof(T).GetProperty(propertyName).PropertyType));
|
||||
|
||||
return
|
||||
Expression.Lambda<Func<T, TKey>>(
|
||||
Expression.Convert(
|
||||
Expression.Property(param, propertyName),
|
||||
typeof(object)),
|
||||
param);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName == propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateEqual(string propertyName, object propertyValue)
|
||||
{
|
||||
var type = typeof(T).GetProperty(propertyName).PropertyType;
|
||||
propertyValue = propertyValue.ToString();
|
||||
propertyValue = Convert.ChangeType(propertyValue, type);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Equal(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName != propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="propertyName"></param>
|
||||
/// <param name="propertyValue"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateNotEqual(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
var type = typeof(T).GetProperty(propertyName).PropertyType;
|
||||
propertyValue = Convert.ChangeType(propertyValue, type);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.NotEqual(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式: p=>propertyValue.Contains(p.propertyName) 目前仅支持 List<string>类型，后期完善
|
||||
/// </summary>
|
||||
/// <param name="propertyName"></param>
|
||||
/// <param name="propertyValue"></param>
|
||||
/// <returns></returns>
|
||||
internal static Expression<Func<T, bool>> GetIn(string propertyName, object propertyValue)
|
||||
{
|
||||
//目前仅支持 List<string>类型，后期完善
|
||||
try
|
||||
{
|
||||
//使用Newtonsoft的ToObject方法将JArray转换成List<string>类型
|
||||
List<string> lst = ((dynamic)propertyValue).ToObject<List<string>>();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
|
||||
MethodInfo method = typeof(List<string>).GetMethod("Contains", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(lst, typeof(List<string>));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Call(constant, method, member), parameter);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new Exception("查询的参数不合法，无法解析成表达式目录树");
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName > propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateGreaterThan(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
UnifyParamType(typeof(T).GetProperty(propertyName).PropertyType, ref propertyValue);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
return MyGreaterThan(member, constant, parameter);
|
||||
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.GreaterThan(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName < propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateLessThan(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
UnifyParamType(typeof(T).GetProperty(propertyName).PropertyType, ref propertyValue);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
return MyLessThan(member, constant, parameter);
|
||||
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.LessThan(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName >= propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateGreaterThanOrEqual(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
UnifyParamType(typeof(T).GetProperty(propertyName).PropertyType, ref propertyValue);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
return MyGreaterThanOrEqual(member, constant, parameter);
|
||||
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.GreaterThanOrEqual(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName <= propertyValue
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> CreateLessThanOrEqual(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
UnifyParamType(typeof(T).GetProperty(propertyName).PropertyType, ref propertyValue);
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");//创建参数p
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
ConstantExpression constant = Expression.Constant(propertyValue);//创建常数
|
||||
|
||||
return MyLessThanOrEqual(member, constant, parameter);
|
||||
//return Expression.Lambda<Func<T, bool>>(Expression.LessThanOrEqual(member, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：p=>p.propertyName.Contains(propertyValue)
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> GetContains(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Call(member, method, constant), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：!(p=>p.propertyName.Contains(propertyValue))
|
||||
/// </summary>
|
||||
/// <typeparam name="T"></typeparam>
|
||||
/// <param name="column"></param>
|
||||
/// <param name="value"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> GetNotContains(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Not(Expression.Call(member, method, constant)), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：!(p=>p.propertyName.StartsWith(propertyValue))
|
||||
/// </summary>
|
||||
/// <param name="propertyName"></param>
|
||||
/// <param name="propertyValue"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> GetStartsWith(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
MethodInfo method = typeof(string).GetMethod("StartsWith", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Not(Expression.Call(member, method, constant)), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 创建lambda表达式：!(p=>p.propertyName.EndsWith(propertyValue))
|
||||
/// </summary>
|
||||
/// <param name="propertyName"></param>
|
||||
/// <param name="propertyValue"></param>
|
||||
/// <returns></returns>
|
||||
public static Expression<Func<T, bool>> GetEndsWith(string propertyName, object propertyValue)
|
||||
{
|
||||
propertyValue = propertyValue.ToString();
|
||||
|
||||
ParameterExpression parameter = Expression.Parameter(typeof(T), "t");
|
||||
MemberExpression member = Expression.PropertyOrField(parameter, propertyName);
|
||||
MethodInfo method = typeof(string).GetMethod("EndsWith", new[] { typeof(string) });
|
||||
ConstantExpression constant = Expression.Constant(propertyValue, typeof(string));
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.Not(Expression.Call(member, method, constant)), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 统一参数类型（值大小比较方法中只支持int和DateTime类型，但上端传递过来的参数有可能为string类型，故需要使用反射的方式统一参数类型）
|
||||
/// </summary>
|
||||
/// <returns></returns>
|
||||
private static void UnifyParamType(Type type, ref object param)
|
||||
{
|
||||
//param = type.GetMethod("Parse", new Type[] { typeof(string) }).Invoke(param, new object[] { param.ToString() });
|
||||
if (IsNullableType(type))
|
||||
{
|
||||
NullableConverter nullableConverter = new(type);
|
||||
param = nullableConverter.ConvertFromString(param.ToString());
|
||||
}
|
||||
else
|
||||
{
|
||||
|
||||
param = Convert.ChangeType(param, type);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 判断可空类型
|
||||
/// </summary>
|
||||
/// <param name="theType"></param>
|
||||
/// <returns></returns>
|
||||
private static bool IsNullableType(Type theType)
|
||||
{
|
||||
return (theType.IsGenericType && theType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 自定义小于比较
|
||||
/// </summary>
|
||||
/// <param name="e1"></param>
|
||||
/// <param name="e2"></param>
|
||||
/// <param name="parameter"></param>
|
||||
/// <returns></returns>
|
||||
private static Expression<Func<T, bool>> MyGreaterThan(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.GreaterThan(e1, e2), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 自定义大于比较
|
||||
/// </summary>
|
||||
/// <param name="e1"></param>
|
||||
/// <param name="e2"></param>
|
||||
/// <param name="parameter"></param>
|
||||
/// <returns></returns>
|
||||
private static Expression<Func<T, bool>> MyLessThan(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.LessThan(e1, e2), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 自定义大于等于比较
|
||||
/// </summary>
|
||||
/// <param name="e1"></param>
|
||||
/// <param name="e2"></param>
|
||||
/// <param name="parameter"></param>
|
||||
/// <returns></returns>
|
||||
private static Expression<Func<T, bool>> MyGreaterThanOrEqual(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.GreaterThanOrEqual(e1, e2), parameter);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// 自定义小于等于比较
|
||||
/// </summary>
|
||||
/// <param name="e1"></param>
|
||||
/// <param name="e2"></param>
|
||||
/// <param name="parameter"></param>
|
||||
/// <returns></returns>
|
||||
private static Expression<Func<T, bool>> MyLessThanOrEqual(Expression e1, Expression e2, ParameterExpression parameter)
|
||||
{
|
||||
if (IsNullableType(e1.Type) && !IsNullableType(e2.Type))
|
||||
e2 = Expression.Convert(e2, e1.Type);
|
||||
else if (!IsNullableType(e1.Type) && IsNullableType(e2.Type))
|
||||
e1 = Expression.Convert(e1, e2.Type);
|
||||
return Expression.Lambda<Func<T, bool>>(Expression.LessThanOrEqual(e1, e2), parameter);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
using System;
|
||||
using System.Linq;
|
||||
using System.Linq.Expressions;
|
||||
using System.Reflection;
|
||||
using SqlSugar;
|
||||
|
||||
namespace JSMachine.WMS.Infrastructure.LambdaHelp
|
||||
{
|
||||
public static class OrderExpression
|
||||
{
|
||||
public static ISugarQueryable<T> OrderByLambda<T>(this ISugarQueryable<T> source, string property, OrderByType orderByType)
|
||||
{
|
||||
return ApplyOrder<T>(source, property, orderByType.ToString());
|
||||
}
|
||||
|
||||
static ISugarQueryable<T> ApplyOrder<T>(ISugarQueryable<T> source, string property, string methodName)
|
||||
{
|
||||
string[] props = property.Split('.');
|
||||
Type type = typeof(T);
|
||||
ParameterExpression arg = Expression.Parameter(type, "x");
|
||||
Expression expr = arg;
|
||||
foreach (string prop in props)
|
||||
{
|
||||
// use reflection (not ComponentModel) to mirror LINQ
|
||||
PropertyInfo pi = type.GetProperty(prop);
|
||||
expr = Expression.Property(expr, pi);
|
||||
type = pi.PropertyType;
|
||||
}
|
||||
Type delegateType = typeof(Func<,>).MakeGenericType(typeof(T), type);
|
||||
LambdaExpression lambda = Expression.Lambda(delegateType, expr, arg);
|
||||
|
||||
object result = typeof(Queryable).GetMethods().Single(
|
||||
method => method.Name == methodName
|
||||
&& method.IsGenericMethodDefinition
|
||||
&& method.GetGenericArguments().Length == 2
|
||||
&& method.GetParameters().Length == 2)
|
||||
.MakeGenericMethod(typeof(T), type)
|
||||
.Invoke(null, new object[] { source, lambda });
|
||||
return (ISugarQueryable<T>)result;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user