/// <summary>
/// 动态建立Between表达式
/// </summary>
/// <param name="propertyName">属性名</param>
/// <param name="values">查询值，只取第1项作为from，第2项作为to。</param>
private static Expression <Func <T, bool> > BuildBetweenExpression(ParameterExpression param, string propertyName, object[] values)
{
if (values == null || values.Length != 2)
{
throw new Exception("Between操作必须指定2个参数。");
}
object from = values[0];
object to = values[1];
//c.<propertyName>
Expression p = OrderBuilder.GetPropertyByName <T>(propertyName, param);
//from, to
Expression cstFrom = Expression.Constant(from);
Expression cstTo = Expression.Constant(to);
if (cstFrom.Type.Equals(p.Type) == false)
{
cstFrom = ConstantExpression.Convert(cstFrom, p.Type);
}
if (cstTo.Type.Equals(p.Type) == false)
{
cstTo = ConstantExpression.Convert(cstTo, p.Type);
}
Expression <Func <T, bool> > lambda;
if (p.Type == typeof(string))
{
MethodCallExpression methodExpFrom = Expression.Call(null, typeof(string).GetMethod("Compare",
new Type[] { typeof(string), typeof(string) }), p, cstFrom);
MethodCallExpression methodExpTo = Expression.Call(null, typeof(string).GetMethod("Compare",
new Type[] { typeof(string), typeof(string) }), p, cstTo);
Expression cstZero = Expression.Constant(0, typeof(int));
//c.<propertyName>>=from
var c1 = Expression.GreaterThanOrEqual(methodExpFrom, cstZero);
//c.<propertyName><=to
var c2 = Expression.LessThanOrEqual(methodExpTo, cstZero);
//between = c1 and c2
var c = Expression.AndAlso(c1, c2);
lambda = Expression.Lambda <Func <T, bool> >(c, param);
}
else
{
//c.<propertyName>>=from
var c1 = Expression.GreaterThanOrEqual(p, cstFrom);
//c.<propertyName><=to
var c2 = Expression.LessThanOrEqual(p, cstTo);
//between = c1 and c2
var c = Expression.AndAlso(c1, c2);
lambda = Expression.Lambda <Func <T, bool> >(c, param);
}
return(lambda);
}
/// <summary>
/// 动态建立GreaterThanOrEqual表达式
/// </summary>
/// <param name="propertyName">属性名</param>
/// <param name="values">查询值，只取第1项作为from。</param>
private static Expression <Func <T, bool> > BuildGreaterThanOrEqualExpression(ParameterExpression param, string propertyName, object[] values)
{
if (values == null || values.Length != 1)
{
throw new Exception("GreaterThanOrEqual操作必须指定1个参数。");
}
object from = values[0];
//c.<propertyName>
Expression p = OrderBuilder.GetPropertyByName <T>(propertyName, param);
//from
Expression cstFrom = Expression.Constant(from);
if (cstFrom.Type.Equals(p.Type) == false)
{
cstFrom = ConstantExpression.Convert(cstFrom, p.Type);
}
Expression <Func <T, bool> > lambda;
if (p.Type == typeof(string))
{
MethodCallExpression methodExpFrom = Expression.Call(null, typeof(string).GetMethod("Compare",
new Type[] { typeof(string), typeof(string) }), p, cstFrom);
Expression cstZero = Expression.Constant(0, typeof(int));
//c.<propertyName>>=from
var c = Expression.GreaterThanOrEqual(methodExpFrom, cstZero);
lambda = Expression.Lambda <Func <T, bool> >(c, param);
}
else
{
//c.<propertyName>>=from
var c = Expression.GreaterThanOrEqual(p, cstFrom);
lambda = Expression.Lambda <Func <T, bool> >(c, param);
}
return(lambda);
}
/// <summary>
/// 动态建立Equal表达式
/// </summary>
/// <param name="propertyName">属性名</param>
/// <param name="values">查询值，只取第1项。</param>
/// <param name="isNotEq">是否是不相等。</param>
private static Expression <Func <T, bool> > BuildEqualExpression(ParameterExpression param, string propertyName, object[] values)
{
if (values == null || values.Length != 1)
{
throw new Exception("Equal操作必须指定1个参数。");
}
object value = values[0];
//c.<propertyName>
Expression p = OrderBuilder.GetPropertyByName <T>(propertyName, param);
//value
Expression cst = Expression.Constant(value);
if (cst.Type.Equals(p.Type) == false)
{
cst = ConstantExpression.Convert(cst, p.Type);
}
//c.<propertyName> = value
var c = Expression.Equal(p, cst);
var lambda = Expression.Lambda <Func <T, bool> >(c, param);
return(lambda);
}
