using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Linq.Expressions;
|
using System.Text;
|
using System.Threading.Tasks;
|
|
using HH.WCS.Mobox3.DSZSH.AppStart;
|
using HH.WCS.Mobox3.DSZSH.Consts;
|
using HH.WCS.Mobox3.DSZSH.Models;
|
|
namespace HH.WCS.Mobox3.DSZSH.Helpers {
|
/// <summary>
|
/// ExpressionHelper：表达式工具
|
/// </summary>
|
/// <remarks>
|
/// 定义了 扩展方法，必须声明为 静态类
|
/// </remarks>
|
public static class ExprHelper {
|
/// <summary>
|
/// 筛选可用货位：未上锁（无任务锁定）、已启用
|
/// </summary>
|
public static Expression<Func<TN_Location, bool>> LocIsFree =
|
l => l.N_LOCK_STATE == LockStateCode.无
|
&& l.S_LOCK_STATE == LockStateName.无
|
&& l.C_ENABLE == "Y"; // 默认都是启用
|
|
/// <summary>
|
/// 筛选空货位：货位当前容器数量为 0
|
/// </summary>
|
public static Expression<Func<TN_Location, bool>> LocIsEmpty =
|
l => l.N_CURRENT_NUM == 0;
|
|
/// <summary>
|
/// 筛选满货位：货位当前容器数量 = 货位容器容量
|
/// </summary>
|
public static Expression<Func<TN_Location, bool>> LocIsFull =
|
l => l.N_CURRENT_NUM == l.N_CAPACITY;
|
|
public static Expression<Func<TN_Location, bool>> LocCode(string locCode) =>
|
l => l.S_CODE == locCode;
|
|
/// <summary>
|
/// 通过货位所属区域筛选货位
|
/// </summary>
|
/// <remarks>
|
/// 参数 areaName 请使用 AreaName 中的常量
|
/// </remarks>
|
/// <param name="areaName">区域名称（不是具体的区域号）</param>
|
/// <returns></returns>
|
public static Expression<Func<TN_Location, bool>> LocBelongsToArea(string areaName) =>
|
l => AppStart.Settings.AreaMap[areaName].Contains(l.S_AREA_CODE); // SqlSugar 可以解析系统方法 Contains 为 IN 表达式
|
|
/// <summary>
|
/// 筛选货位容器关系：查询某个 货位-容器 关系是否存在
|
/// </summary>
|
/// <param name="loc"></param>
|
/// <param name="cntr"></param>
|
/// <returns></returns>
|
public static Expression<Func<TN_Loc_Container, bool>> LocCntrIsBind(string loc, string cntr) =>
|
lc => lc.S_LOC_CODE == loc && lc.S_CNTR_CODE == cntr;
|
|
#region 拓展方法
|
|
/// <summary>
|
/// 拓展方法：合并两个表达式
|
/// </summary>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="expr1"></param>
|
/// <param name="expr2"></param>
|
/// <returns></returns>
|
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> expr1,
|
Expression<Func<T, bool>> expr2) {
|
var parameter = expr1.Parameters[0]; // 重用第一个表达式的参数
|
|
var visitor = new ReplaceExpressionVisitor(expr2.Parameters[0], parameter);
|
var left = expr1.Body;
|
var right = visitor.Visit(expr2.Body);
|
|
return Expression.Lambda<Func<T, bool>>(
|
Expression.AndAlso(left, right),
|
parameter);
|
}
|
|
/// <summary>
|
/// 辅助类：替换表达式参数
|
/// </summary>
|
class ReplaceExpressionVisitor : ExpressionVisitor {
|
private readonly Expression _oldValue;
|
private readonly Expression _newValue;
|
|
public ReplaceExpressionVisitor(Expression oldValue, Expression newValue) {
|
_oldValue = oldValue;
|
_newValue = newValue;
|
}
|
|
public override Expression Visit(Expression node) {
|
if (node == _oldValue)
|
return _newValue;
|
return base.Visit(node);
|
}
|
}
|
|
/// <summary>
|
/// 拓展方法：反转表达式（直接取反）
|
/// </summary>
|
/// <remarks>
|
/// 不推荐使用 | 对返回结果整体取反，简单场景下可以使用
|
/// </remarks>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="expr"></param>
|
/// <returns></returns>
|
static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expr) {
|
var parameter = expr.Parameters[0];
|
var body = Expression.Not(expr.Body);
|
|
return Expression.Lambda<Func<T, bool>>(body, parameter);
|
}
|
|
/// <summary>
|
/// 拓展方法：反转表达式（针对特定运算符进行反转）
|
/// </summary>
|
/// <remarks>
|
/// 推荐使用 | 对表达式中的每个逻辑运算符取反，复杂场景下更合适，能生成更优化的 SQL
|
/// </remarks>
|
/// <typeparam name="T"></typeparam>
|
/// <param name="expr"></param>
|
/// <returns></returns>
|
public static Expression<Func<T, bool>> Negate<T>(this Expression<Func<T, bool>> expr) {
|
var visitor = new NegateExpressionVisitor();
|
var negatedExpr = (Expression<Func<T, bool>>)visitor.Visit(expr);
|
return negatedExpr;
|
}
|
|
/// <summary>
|
/// 辅助类：反转表达式逻辑运算符
|
/// </summary>
|
class NegateExpressionVisitor : ExpressionVisitor {
|
protected override Expression VisitBinary(BinaryExpression node) {
|
// 反转比较运算符
|
if (node.NodeType == ExpressionType.Equal)
|
return Expression.NotEqual(node.Left, node.Right);
|
if (node.NodeType == ExpressionType.NotEqual)
|
return Expression.Equal(node.Left, node.Right);
|
if (node.NodeType == ExpressionType.GreaterThan)
|
return Expression.LessThanOrEqual(node.Left, node.Right);
|
if (node.NodeType == ExpressionType.GreaterThanOrEqual)
|
return Expression.LessThan(node.Left, node.Right);
|
if (node.NodeType == ExpressionType.LessThan)
|
return Expression.GreaterThanOrEqual(node.Left, node.Right);
|
if (node.NodeType == ExpressionType.LessThanOrEqual)
|
return Expression.GreaterThan(node.Left, node.Right);
|
|
// 处理逻辑与/或
|
if (node.NodeType == ExpressionType.AndAlso)
|
return Expression.OrElse(Visit(node.Left), Visit(node.Right));
|
if (node.NodeType == ExpressionType.OrElse)
|
return Expression.AndAlso(Visit(node.Left), Visit(node.Right));
|
|
return base.VisitBinary(node);
|
}
|
|
protected override Expression VisitUnary(UnaryExpression node) {
|
// 处理双重否定
|
if (node.NodeType == ExpressionType.Not)
|
return node.Operand;
|
|
return base.VisitUnary(node);
|
}
|
}
|
|
#endregion
|
|
}
|
}
|
