zhusenlin/serein-flow
1
0
Fork 0
mirror of https://gitee.com/langsisi_admin/serein-flow synced 2026-03-30 04:56:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

将部分节点基类与表达式工具类从nodeflow迁移到library，重写了环境与工作台的交互，解耦节点的获取，下一部分将尝试远程登录环境编辑流程。

Browse Source
This commit is contained in:
fengjiayi
2024-10-15 10:55:41 +08:00
parent 4338554384
commit dbbde4f03e
48 changed files with 3687 additions and 292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -20,3 +20,5 @@ obj/
# 排除发布文件夹
.Output/
/.git1
WorkBench.ControlLibrary.Core
WorkBench.Remote

34
Extend.FlowRemoteManagement/SereinFlowRemoteControl.cs
View File

@@ -67,7 +67,7 @@ namespace SereinFlowRemoteManagement
await Console.Out.WriteLineAsync("启动远程管理模块");
await socketServer.StartAsync($"http://*:{ServerPort}/");
});
SereinProjectData projectData = environment.SaveProject();
SereinProjectData projectData = environment.GetProjectInfo();
}
#endregion
@@ -83,32 +83,10 @@ namespace SereinFlowRemoteManagement
{
await Send("尝试获取");
Dictionary<NodeLibrary, List<MethodDetailsInfo>> LibraryMds = [];
foreach (var mdskv in environment.MethodDetailss)
{
var library = mdskv.Key;
var mds = mdskv.Value;
foreach (var md in mds)
{
if (!LibraryMds.TryGetValue(library, out var t_mds))
{
t_mds = new List<MethodDetailsInfo>();
LibraryMds[library] = t_mds;
}
var mdInfo = md.ToInfo();
mdInfo.LibraryName = library.Assembly.GetName().FullName;
t_mds.Add(mdInfo);
}
}
try
{
var project = await GetProjectInfo();
return new
{
project = project,
envNode = LibraryMds.Values,
};
var envInfo = this.environment.GetEnvInfo();
return envInfo;
}
catch (Exception ex)
{
@@ -128,9 +106,9 @@ namespace SereinFlowRemoteManagement
throw new InvalidOperationException("类型错误");
}
if (this.environment.TryGetMethodDetails(methodName,out var md))
if (this.environment.TryGetMethodDetailsInfo(methodName,out var mdInfo))
{
this.environment.CreateNode(connectionType, new Position(x, y), md); ;
this.environment.CreateNode(connectionType, new Position(x, y), mdInfo); ;
}
@@ -191,7 +169,7 @@ namespace SereinFlowRemoteManagement
public async Task<SereinProjectData> GetProjectInfo()
{
await Task.Delay(0);
return environment.SaveProject();
return environment.GetProjectInfo();
}

BIN
FlowEdit/FlowEdit可视化流程编辑器beta.zip Normal file
View File

Binary file not shown.

115
Library/Api/IFlowEnvironment.cs
View File

@@ -2,6 +2,7 @@
using Serein.Library.Enums;
using Serein.Library.Utils;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Reflection;
using System.Threading.Tasks;
@@ -35,17 +36,13 @@ namespace Serein.Library.Api
/// <summary>
/// 运行环境节点连接发生了改变
/// </summary>
/// <param name="fromNodeGuid"></param>
/// <param name="toNodeGuid"></param>
/// <param name="connectionType"></param>
/// <param name="eventArgs"></param>
public delegate void NodeConnectChangeHandler(NodeConnectChangeEventArgs eventArgs);
/// <summary>
/// 环境中加载了一个节点
/// </summary>
/// <param name="fromNodeGuid"></param>
/// <param name="toNodeGuid"></param>
/// <param name="connectionType"></param>
/// <param name="eventArgs"></param>
public delegate void NodeCreateHandler(NodeCreateEventArgs eventArgs);
/// <summary>
@@ -72,6 +69,16 @@ namespace Serein.Library.Api
/// <param name="eventArgs"></param>
public delegate void ExpInterruptTriggerHandler(InterruptTriggerEventArgs eventArgs);
/// <summary>
/// IOC容器发生变化
/// </summary>
public delegate void IOCMembersChangedHandler(IOCMembersChangedEventArgs eventArgs);
/// <summary>
/// 节点需要定位
/// </summary>
/// <param name="eventArgs"></param>
public delegate void NodeLocatedHandler(NodeLocatedEventArgs eventArgs);
#endregion
@@ -118,7 +125,7 @@ namespace Serein.Library.Api
public class LoadDllEventArgs : FlowEventArgs
{
public LoadDllEventArgs(NodeLibrary nodeLibrary, List<MethodDetails> MethodDetailss)
public LoadDllEventArgs(NodeLibrary nodeLibrary, List<MethodDetailsInfo> MethodDetailss)
{
this.NodeLibrary = nodeLibrary;
this.MethodDetailss = MethodDetailss;
@@ -130,7 +137,7 @@ namespace Serein.Library.Api
/// <summary>
/// dll文件中有效的流程方法描述
/// </summary>
public List<MethodDetails> MethodDetailss { get; protected set; }
public List<MethodDetailsInfo> MethodDetailss { get; protected set; }
}
public class RemoteDllEventArgs : FlowEventArgs
@@ -251,11 +258,27 @@ namespace Serein.Library.Api
/// </summary>
public class MonitorObjectEventArgs : FlowEventArgs
{
/// <summary>
/// 变化的数据类别
/// </summary>
public enum ObjSourceType
{
/// <summary>
/// 流程节点的数据
/// </summary>
NodeFlowData,
/// <summary>
/// IOC容器对象
/// </summary>
IOCObj,
}
/// <summary>
/// 在某个节点运行时，监听的数据发生了改变
/// </summary>
/// <param name="nodeGuid"></param>
/// <param name="monitorData"></param>
/// <param name="objSourceType"></param>
public MonitorObjectEventArgs(string nodeGuid, object monitorData, ObjSourceType objSourceType)
{
NodeGuid = nodeGuid;
@@ -267,6 +290,10 @@ namespace Serein.Library.Api
/// 中断的节点Guid
/// </summary>
public string NodeGuid { get; protected set; }
/// <summary>
/// 监听对象类别
/// </summary>
public ObjSourceType ObjSource { get; protected set; }
/// <summary>
/// 新的数据
@@ -326,14 +353,8 @@ namespace Serein.Library.Api
public string Expression { get; protected set; }
public InterruptTriggerType Type { get; protected set; }
}
#endregion
/// <summary>
/// IOC容器发生变化
/// </summary>
public delegate void IOCMembersChangedHandler(IOCMembersChangedEventArgs eventArgs);
/// <summary>
/// 流程事件签名基类
@@ -360,11 +381,6 @@ namespace Serein.Library.Api
public object Instance { get; private set; }
}
/// <summary>
/// 节点需要定位
/// </summary>
/// <param name="eventArgs"></param>
public delegate void NodeLocatedHandler(NodeLocatedEventArgs eventArgs);
public class NodeLocatedEventArgs : FlowEventArgs
{
@@ -375,6 +391,14 @@ namespace Serein.Library.Api
public string NodeGuid { get; private set; }
}
#endregion
/// <summary>
/// 运行环境
/// </summary>
public interface IFlowEnvironment
{
#region 属性
@@ -397,7 +421,7 @@ namespace Serein.Library.Api
/// <summary>
/// DLL中NodeAction特性的方法描述的所有原始副本
/// </summary>
Dictionary<NodeLibrary, List<MethodDetails>> MethodDetailss { get; }
// ConcurrentDictionary<string, MethodDetails> MethodDetailss { get; }
/// <summary>
@@ -478,14 +502,19 @@ namespace Serein.Library.Api
/// <summary>
/// 获取方法描述
/// 获取方法描述信息
/// </summary>
/// <param name="name"></param>
/// <param name="md"></param>
/// <param name="methodName">方法描述</param>
/// <param name="mdInfo">方法信息</param>
/// <returns></returns>
bool TryGetMethodDetails(string methodName, out MethodDetails md);
bool TryGetMethodDetailsInfo(string methodName, out MethodDetailsInfo mdInfo);
/// <summary>
/// 获取指定方法的Emit委托
/// </summary>
/// <param name="methodName"></param>
/// <param name="del"></param>
/// <returns></returns>
bool TryGetDelegateDetails(string methodName, out DelegateDetails del);
//bool TryGetNodeData(string methodName, out NodeData node);
@@ -496,13 +525,22 @@ namespace Serein.Library.Api
/// 保存当前项目
/// </summary>
/// <returns></returns>
SereinProjectData SaveProject();
SereinProjectData GetProjectInfo();
/// <summary>
/// 加载项目文件
/// </summary>
/// <param name="projectFile"></param>
/// <param name="filePath"></param>
void LoadProject(SereinProjectData projectFile, string filePath);
/// <summary>
/// 加载远程项目
/// </summary>
/// <param name="addres">远程项目地址</param>
/// <param name="port">远程项目端口</param>
/// <param name="token">密码</param>
void LoadRemoteProject(string addres,int port, string token);
/// <summary>
/// 从文件中加载Dll
/// </summary>
@@ -511,7 +549,7 @@ namespace Serein.Library.Api
/// <summary>
/// 移除DLL
/// </summary>
/// <param name="dllPath"></param>
/// <param name="assemblyFullName">程序集的名称</param>
bool RemoteDll(string assemblyFullName);
/// <summary>
@@ -552,8 +590,10 @@ namespace Serein.Library.Api
/// 创建节点/区域/基础控件
/// </summary>
/// <param name="nodeBase">节点/区域/基础控件</param>
/// <param name="methodDetails">节点绑定的方法说明（</param>
void CreateNode(NodeControlType nodeBase, Position position, MethodDetails methodDetails = null);
/// <param name="position">节点在画布上的位置（</param>
/// <param name="methodDetailsInfo">节点绑定的方法说明（</param>
void CreateNode(NodeControlType nodeBase, Position position, MethodDetailsInfo methodDetailsInfo = null);
/// <summary>
/// 移除两个节点之间的连接关系
/// </summary>
@@ -590,15 +630,15 @@ namespace Serein.Library.Api
/// <summary>
/// 添加作用于某个对象的中断表达式
/// </summary>
/// <param name="nodeGuid"></param>
/// <param name="key"></param>
/// <param name="expression"></param>
/// <returns></returns>
bool AddInterruptExpression(string key, string expression);
/// <summary>
/// 监视指定对象
/// </summary>
/// <param name="obj">需要监视的对象</param>
/// <param name="key">需要监视的对象</param>
/// <param name="isMonitor">是否启用监视</param>
void SetMonitorObjState(string key,bool isMonitor);
@@ -620,6 +660,14 @@ namespace Serein.Library.Api
Task<CancelType> GetOrCreateGlobalInterruptAsync();
#region 远程相关
/// <summary>
/// (适用于远程连接后获取环境的运行状态)获取当前环境的信息
/// </summary>
/// <returns></returns>
object GetEnvInfo();
#endregion
#endregion
#region 启动器调用
@@ -628,7 +676,8 @@ namespace Serein.Library.Api
/// 流程启动器调用，监视数据更新通知
/// </summary>
/// <param name="nodeGuid">更新了数据的节点Guid</param>
/// <param name="flowData">更新的数据</param>
/// <param name="monitorData">更新的数据</param>
/// <param name="sourceType">更新的数据</param>
void MonitorObjectNotification(string nodeGuid, object monitorData, MonitorObjectEventArgs.ObjSourceType sourceType);
/// <summary>

225
Library/Entity/Base/NodeModelBaseData.cs Normal file
View File

@@ -0,0 +1,225 @@
using Serein.Library.Api;
using Serein.Library.Entity;
using Serein.Library.Enums;
using System;
using System.Collections.Generic;
using System.Threading;
namespace Serein.NodeFlow.Base
{
/// <summary>
/// 节点基类（数据）：条件控件，动作控件，条件区域，动作区域
/// </summary>
public abstract partial class NodeModelBase : IDynamicFlowNode
{
public NodeModelBase()
{
PreviousNodes = [];
SuccessorNodes = [];
foreach (ConnectionType ctType in NodeStaticConfig.ConnectionTypes)
{
PreviousNodes[ctType] = new List<NodeModelBase>();
SuccessorNodes[ctType] = new List<NodeModelBase>();
}
DebugSetting = new NodeDebugSetting();
}
/// <summary>
/// 调试功能
/// </summary>
public NodeDebugSetting DebugSetting { get; set; }
/// <summary>
/// 节点对应的控件类型
/// </summary>
public NodeControlType ControlType { get; set; }
/// <summary>
/// 方法描述，对应DLL的方法
/// </summary>
public MethodDetails MethodDetails { get; set; }
/// <summary>
/// 节点guid
/// </summary>
public string Guid { get; set; }
/// <summary>
/// 显示名称
/// </summary>
public string DisplayName { get; set; } = string.Empty;
/// <summary>
/// 是否为起点控件
/// </summary>
public bool IsStart { get; set; }
/// <summary>
/// 运行时的上一节点
/// </summary>
public NodeModelBase PreviousNode { get; set; }
/// <summary>
/// 不同分支的父节点
/// </summary>
public Dictionary<ConnectionType,List<NodeModelBase>> PreviousNodes { get; }
/// <summary>
/// 不同分支的子节点
/// </summary>
public Dictionary<ConnectionType,List<NodeModelBase>> SuccessorNodes { get; }
/// <summary>
/// 当前节点执行完毕后需要执行的下一个分支的类别
/// </summary>
public ConnectionType NextOrientation { get; set; } = ConnectionType.None;
/// <summary>
/// 运行时的异常信息（仅在 FlowState 为 Error 时存在对应值）
/// </summary>
public Exception RuningException { get; set; } = null;
/// <summary>
/// 控制FlowData在同一时间只会被同一个线程更改。
/// </summary>
private readonly ReaderWriterLockSlim _flowDataLock = new ReaderWriterLockSlim();
private object _flowData;
/// <summary>
/// 当前传递数据（执行了节点对应的方法，才会存在值）。
/// </summary>
protected object FlowData
{
get
{
_flowDataLock.EnterReadLock();
try
{
return _flowData;
}
finally
{
_flowDataLock.ExitReadLock();
}
}
set
{
_flowDataLock.EnterWriteLock();
try
{
_flowData = value;
}
finally
{
_flowDataLock.ExitWriteLock();
}
}
}
}
/// <summary>
/// 节点基类（数据）：条件控件，动作控件，条件区域，动作区域
/// </summary>
//public class NodeModelBaseBuilder
//{
// public NodeModelBaseBuilder(NodeModelBase builder)
// {
// this.ControlType = builder.ControlType;
// this.MethodDetails = builder.MethodDetails;
// this.Guid = builder.Guid;
// this.DisplayName = builder.DisplayName;
// this.IsStart = builder.IsStart;
// this.PreviousNode = builder.PreviousNode;
// this.PreviousNodes = builder.PreviousNodes;
// this.SucceedBranch = builder.SucceedBranch;
// this.FailBranch = builder.FailBranch;
// this.ErrorBranch = builder.ErrorBranch;
// this.UpstreamBranch = builder.UpstreamBranch;
// this.FlowState = builder.FlowState;
// this.RuningException = builder.RuningException;
// this.FlowData = builder.FlowData;
// }
// /// <summary>
// /// 节点对应的控件类型
// /// </summary>
// public NodeControlType ControlType { get; }
// /// <summary>
// /// 方法描述，对应DLL的方法
// /// </summary>
// public MethodDetails MethodDetails { get; }
// /// <summary>
// /// 节点guid
// /// </summary>
// public string Guid { get; }
// /// <summary>
// /// 显示名称
// /// </summary>
// public string DisplayName { get;}
// /// <summary>
// /// 是否为起点控件
// /// </summary>
// public bool IsStart { get; }
// /// <summary>
// /// 运行时的上一节点
// /// </summary>
// public NodeModelBase? PreviousNode { get; }
// /// <summary>
// /// 上一节点集合
// /// </summary>
// public List<NodeModelBase> PreviousNodes { get; } = [];
// /// <summary>
// /// 下一节点集合（真分支）
// /// </summary>
// public List<NodeModelBase> SucceedBranch { get; } = [];
// /// <summary>
// /// 下一节点集合（假分支）
// /// </summary>
// public List<NodeModelBase> FailBranch { get; } = [];
// /// <summary>
// /// 异常分支
// /// </summary>
// public List<NodeModelBase> ErrorBranch { get; } = [];
// /// <summary>
// /// 上游分支
// /// </summary>
// public List<NodeModelBase> UpstreamBranch { get; } = [];
// /// <summary>
// /// 当前执行状态（进入真分支还是假分支，异常分支在异常中确定）
// /// </summary>
// public FlowStateType FlowState { get; set; } = FlowStateType.None;
// /// <summary>
// /// 运行时的异常信息（仅在 FlowState 为 Error 时存在对应值）
// /// </summary>
// public Exception RuningException { get; set; } = null;
// /// <summary>
// /// 当前传递数据（执行了节点对应的方法，才会存在值）
// /// </summary>
// public object? FlowData { get; set; } = null;
//}
}

457
Library/Entity/Base/NodeModelBaseFunc.cs Normal file
View File

@@ -0,0 +1,457 @@
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Serein.Library.Api;
using Serein.Library.Attributes;
using Serein.Library.Entity;
using Serein.Library.Enums;
using Serein.Library.Ex;
using Serein.Library.Utils;
using Serein.NodeFlow.Tool;
using Serein.NodeFlow.Tool.SereinExpression;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Net.Http.Headers;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.NodeFlow.Base
{
/// <summary>
/// 节点基类（数据）：条件控件，动作控件，条件区域，动作区域
/// </summary>
public abstract partial class NodeModelBase : IDynamicFlowNode
{
#region 调试中断
/// <summary>
/// 不再中断
/// </summary>
public void CancelInterrupt()
{
this.DebugSetting.InterruptClass = InterruptClass.None;
DebugSetting.CancelInterruptCallback?.Invoke();
}
#endregion
#region 导出/导入项目文件节点信息
internal abstract Parameterdata[] GetParameterdatas();
public virtual NodeInfo ToInfo()
{
// if (MethodDetails == null) return null;
var trueNodes = SuccessorNodes[ConnectionType.IsSucceed].Select(item => item.Guid); // 真分支
var falseNodes = SuccessorNodes[ConnectionType.IsFail].Select(item => item.Guid);// 假分支
var errorNodes = SuccessorNodes[ConnectionType.IsError].Select(item => item.Guid);// 异常分支
var upstreamNodes = SuccessorNodes[ConnectionType.Upstream].Select(item => item.Guid);// 上游分支
// 生成参数列表
Parameterdata[] parameterData = GetParameterdatas();
return new NodeInfo
{
Guid = Guid,
MethodName = MethodDetails?.MethodName,
Label = DisplayName ?? "",
Type = this.GetType().ToString(),
TrueNodes = trueNodes.ToArray(),
FalseNodes = falseNodes.ToArray(),
UpstreamNodes = upstreamNodes.ToArray(),
ParameterData = parameterData.ToArray(),
ErrorNodes = errorNodes.ToArray(),
};
}
public virtual NodeModelBase LoadInfo(NodeInfo nodeInfo)
{
this.Guid = nodeInfo.Guid;
if (this.MethodDetails is not null)
{
for (int i = 0; i < nodeInfo.ParameterData.Length; i++)
{
Parameterdata? pd = nodeInfo.ParameterData[i];
this.MethodDetails.ParameterDetailss[i].IsExplicitData = pd.State;
this.MethodDetails.ParameterDetailss[i].DataValue = pd.Value;
}
}
return this;
}
#endregion
#region 节点方法的执行
/// <summary>
/// 是否应该退出执行
/// </summary>
/// <param name="context"></param>
/// <param name="flowCts"></param>
/// <returns></returns>
public static bool IsBradk(IDynamicContext context, CancellationTokenSource? flowCts)
{
// 上下文不再执行
if(context.RunState == RunState.Completion)
{
return true;
}
// 不存在全局触发器时，流程运行状态被设置为完成，退出执行，用于打断无限循环分支。
if (flowCts is null && context.Env.FlowState == RunState.Completion)
{
return true;
}
// 如果存在全局触发器，且触发器的执行任务已经被取消时，退出执行。
if (flowCts is not null)
{
if (flowCts.IsCancellationRequested)
return true;
}
return false;
}
/// <summary>
/// 开始执行
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task StartFlowAsync(IDynamicContext context)
{
Stack<NodeModelBase> stack = new Stack<NodeModelBase>();
stack.Push(this);
var flowCts = context.Env.IOC.Get<CancellationTokenSource>(FlowStarter.FlipFlopCtsName);
bool hasFlipflow = flowCts != null;
while (stack.Count > 0) // 循环中直到栈为空才会退出循环
{
await Task.Delay(0);
// 从栈中弹出一个节点作为当前节点进行处理
var currentNode = stack.Pop();
#region 执行相关
// 筛选出上游分支
var upstreamNodes = currentNode.SuccessorNodes[ConnectionType.Upstream].ToArray();
for (int index = 0; index < upstreamNodes.Length; index++)
{
NodeModelBase? upstreamNode = upstreamNodes[index];
if (upstreamNode is not null && upstreamNode.DebugSetting.IsEnable)
{
if (upstreamNode.DebugSetting.InterruptClass != InterruptClass.None) // 执行触发前
{
var cancelType = await upstreamNode.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{upstreamNode.MethodDetails?.MethodName}]中断已{cancelType}，开始执行后继分支");
}
upstreamNode.PreviousNode = currentNode;
await upstreamNode.StartFlowAsync(context); // 执行流程节点的上游分支
if (upstreamNode.NextOrientation == ConnectionType.IsError)
{
// 如果上游分支执行失败，不再继续执行
// 使上游节点（仅上游节点本身，不包含上游节点的后继节点）
// 具备通过抛出异常中断流程的能力
break;
}
}
}
if (IsBradk(context, flowCts)) break; // 退出执行
// 上游分支执行完成，才执行当前节点
object? newFlowData = await currentNode.ExecutingAsync(context);
if (IsBradk(context, flowCts)) break; // 退出执行
await RefreshFlowDataAndExpInterrupt(context, currentNode, newFlowData); // 执行当前节点后刷新数据
#endregion
#region 执行完成
// 选择后继分支
var nextNodes = currentNode.SuccessorNodes[currentNode.NextOrientation];
// 将下一个节点集合中的所有节点逆序推入栈中
for (int i = nextNodes.Count - 1; i >= 0; i--)
{
// 筛选出启用的节点的节点
if (nextNodes[i].DebugSetting.IsEnable)
{
nextNodes[i].PreviousNode = currentNode;
stack.Push(nextNodes[i]);
}
}
#endregion
}
}
/// <summary>
/// 执行节点对应的方法
/// </summary>
/// <param name="context">流程上下文</param>
/// <returns>节点传回数据对象</returns>
public virtual async Task<object?> ExecutingAsync(IDynamicContext context)
{
#region 调试中断
if (DebugSetting.InterruptClass != InterruptClass.None) // 执行触发检查是否需要中断
{
var cancelType = await this.DebugSetting.GetInterruptTask(); // 等待中断结束
await Console.Out.WriteLineAsync($"[{this.MethodDetails?.MethodName}]中断已{cancelType}，开始执行后继分支");
}
#endregion
MethodDetails? md = MethodDetails;
//var del = md.MethodDelegate.Clone();
if (md is null)
{
throw new Exception($"节点{this.Guid}不存在方法信息，请检查是否需要重写节点的ExecutingAsync");
}
if (!context.Env.TryGetDelegateDetails(md.MethodName, out var dd))
{
throw new Exception($"节点{this.Guid}不存在对应委托");
}
md.ActingInstance ??= context.Env.IOC.Get(md.ActingInstanceType);
object instance = md.ActingInstance;
object? result = null;
try
{
object?[]? args = GetParameters(context, this, md);
result = await dd.InvokeAsync(md.ActingInstance, args);
NextOrientation = ConnectionType.IsSucceed;
return result;
}
catch (Exception ex)
{
await Console.Out.WriteLineAsync($"节点[{this.MethodDetails?.MethodName}]异常：" + ex);
NextOrientation = ConnectionType.IsError;
RuningException = ex;
return null;
}
}
/// <summary>
/// 获取对应的参数数组
/// </summary>
public static object?[]? GetParameters(IDynamicContext context, NodeModelBase nodeModel, MethodDetails md)
{
// 用正确的大小初始化参数数组
if (md.ParameterDetailss.Length == 0)
{
return null;// md.ActingInstance
}
object?[]? parameters = new object[md.ParameterDetailss.Length];
var flowData = nodeModel.PreviousNode?.FlowData; // 当前传递的数据
var previousDataType = flowData?.GetType();
for (int i = 0; i < parameters.Length; i++)
{
object? inputParameter; // 存放解析的临时参数
var ed = md.ParameterDetailss[i]; // 方法入参描述
if (ed.IsExplicitData) // 判断是否使用显示的输入参数
{
if (ed.DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase) && flowData is not null)
{
// 执行表达式从上一节点获取对象
inputParameter = SerinExpressionEvaluator.Evaluate(ed.DataValue, flowData, out _);
}
else
{
// 使用输入的固定值
inputParameter = ed.DataValue;
}
}
else
{
inputParameter = flowData; // 使用上一节点的对象
}
// 入参存在取值转换器
if (ed.ExplicitType.IsEnum && ed.Convertor is not null)
{
if (Enum.TryParse(ed.ExplicitType, ed.DataValue, out var resultEnum))
{
var value = ed.Convertor(resultEnum);
if (value is not null)
{
parameters[i] = value;
continue;
}
else
{
throw new InvalidOperationException("转换器调用失败");
}
}
}
// 入参存在类型转换器，获取枚举转换器中记录的枚举
if (ed.ExplicitType.IsEnum && ed.DataType != ed.ExplicitType)
{
if (Enum.TryParse(ed.ExplicitType, ed.DataValue, out var resultEnum)) // 获取对应的枚举项
{
// 获取绑定的类型
var type = EnumHelper.GetBoundValue(ed.ExplicitType, resultEnum, attr => attr.Value);
if (type is Type enumBindType && enumBindType is not null)
{
var value = context.Env.IOC.Instantiate(enumBindType);
if (value is not null)
{
parameters[i] = value;
continue;
}
}
}
}
if (ed.DataType.IsValueType)
{
var valueStr = inputParameter?.ToString();
parameters[i] = valueStr.ToValueData(ed.DataType);
}
else
{
var valueStr = inputParameter?.ToString();
parameters[i] = ed.DataType switch
{
Type t when t == typeof(string) => valueStr,
Type t when t == typeof(IDynamicContext) => context, // 上下文
Type t when t == typeof(DateTime) => string.IsNullOrEmpty(valueStr) ? 0 : DateTime.Parse(valueStr),
Type t when t == typeof(MethodDetails) => md, // 节点方法描述
Type t when t == typeof(NodeModelBase) => nodeModel, // 节点实体类
Type t when t.IsArray => (inputParameter as Array)?.Cast<object>().ToList(),
Type t when t.IsGenericType && t.GetGenericTypeDefinition() == typeof(List<>) => inputParameter,
_ => inputParameter,
};
}
}
return parameters;
}
/// <summary>
/// 更新节点数据，并检查监视表达式是否生效
/// </summary>
/// <param name="context">上下文</param>
/// <param name="nodeModel">节点Moel</param>
/// <param name="newData">新的数据</param>
/// <returns></returns>
public static async Task RefreshFlowDataAndExpInterrupt(IDynamicContext context, NodeModelBase nodeModel, object? newData = null)
{
string guid = nodeModel.Guid;
if (newData is not null)
{
await MonitorObjExpInterrupt(context, nodeModel, newData, 0); // 首先监视对象
await MonitorObjExpInterrupt(context, nodeModel, newData, 1); // 然后监视节点
nodeModel.FlowData = newData; // 替换数据
context.AddOrUpdate(guid, nodeModel); // 上下文中更新数据
}
}
private static async Task MonitorObjExpInterrupt(IDynamicContext context, NodeModelBase nodeModel, object? data, int monitorType)
{
MonitorObjectEventArgs.ObjSourceType sourceType;
string? key;
if (monitorType == 0)
{
key = data?.GetType()?.FullName;
sourceType = MonitorObjectEventArgs.ObjSourceType.IOCObj;
}
else
{
key = nodeModel.Guid;
sourceType = MonitorObjectEventArgs.ObjSourceType.IOCObj;
}
if (string.IsNullOrEmpty(key))
{
return;
}
if (context.Env.CheckObjMonitorState(key, out List<string> exps)) // 如果新的数据处于查看状态，通知UI进行更新？交给运行环境判断？
{
context.Env.MonitorObjectNotification(nodeModel.Guid, data, sourceType); // 对象处于监视状态，通知UI更新数据显示
if (exps.Count > 0)
{
// 表达式环境下判断是否需要执行中断
bool isExpInterrupt = false;
string? exp = "";
// 判断执行监视表达式，直到为 true 时退出
for (int i = 0; i < exps.Count && !isExpInterrupt; i++)
{
exp = exps[i];
if (string.IsNullOrEmpty(exp)) continue;
isExpInterrupt = SereinConditionParser.To(data, exp);
}
if (isExpInterrupt) // 触发中断
{
InterruptClass interruptClass = InterruptClass.Branch; // 分支中断
if (context.Env.SetNodeInterrupt(nodeModel.Guid, interruptClass))
{
context.Env.TriggerInterrupt(nodeModel.Guid, exp, InterruptTriggerEventArgs.InterruptTriggerType.Exp);
var cancelType = await nodeModel.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{data}]中断已{cancelType}，开始执行后继分支");
}
}
}
}
}
/// <summary>
/// 释放对象
/// </summary>
public void ReleaseFlowData()
{
if (typeof(IDisposable).IsAssignableFrom(FlowData?.GetType()) && FlowData is IDisposable disposable)
{
disposable?.Dispose();
}
this.FlowData = null;
}
/// <summary>
/// 获取节点数据
/// </summary>
/// <returns></returns>
public object? GetFlowData()
{
return this.FlowData;
}
#endregion
}
}

32
Library/Entity/DelegateDetails.cs
View File

@@ -14,11 +14,21 @@ namespace Serein.Library.Entity
/// </summary>
public class DelegateDetails
{
/// <summary>
/// 记录Emit委托
/// </summary>
/// <param name="EmitMethodType"></param>
/// <param name="EmitDelegate"></param>
public DelegateDetails(EmitMethodType EmitMethodType, Delegate EmitDelegate)
{
this._emitMethodType = EmitMethodType;
this._emitDelegate = EmitDelegate;
}
/// <summary>
/// 更新委托方法
/// </summary>
/// <param name="EmitMethodType"></param>
/// <param name="EmitDelegate"></param>
public void Upload(EmitMethodType EmitMethodType, Delegate EmitDelegate)
{
_emitMethodType = EmitMethodType;
@@ -26,18 +36,30 @@ namespace Serein.Library.Entity
}
private Delegate _emitDelegate;
private EmitMethodType _emitMethodType;
/// <summary>
/// <para>普通方法：Func&lt;object,object[],object&gt;</para>
/// <para>异步方法：Func&lt;object,object[],Task&gt;</para>
/// <para>异步有返回值方法：Func&lt;object,object[],Task&lt;object&gt;&gt;</para>
/// </summary>
public Delegate EmitDelegate { get => _emitDelegate; }
/// <summary>
/// 表示Emit构造的委托类型
/// </summary>
public EmitMethodType EmitMethodType { get => _emitMethodType; }
/// <summary>
/// 异步等待Emit创建的委托。
/// 需要注意的是，传入的实例必须包含创建委托的方法信息，传入的参数也必须符合方法入参信息。
/// </summary>
/// <para>使用的实例必须能够正确调用该委托，传入的参数也必须符合方法入参信息。</para>
/// </summary>
/// <param name="instance">实例</param>
/// <param name="args">入参</param>
/// <returns>返回值</returns>
public async Task<object> Invoke(object instance, object[] args)
/// <returns>void方法自动返回null</returns>
public async Task<object> InvokeAsync(object instance, object[] args)
{
if(args is null)
{
args = new object[0];
}
object result = null;
try
{

5
Library/Entity/MethodDetails.cs
View File

@@ -23,7 +23,7 @@ namespace Serein.Library.Entity
/// <summary>
/// 节点类型
/// </summary>
public string NodeType { get; set; }
public NodeType NodeType { get; set; }
/// <summary>
/// 方法说明
@@ -39,7 +39,6 @@ namespace Serein.Library.Entity
/// <summary>
/// 出参类型
/// </summary>
public string ReturnTypeFullName { get; set; }
}
@@ -60,7 +59,7 @@ namespace Serein.Library.Entity
{
MethodName = MethodName,
MethodTips = MethodTips,
NodeType = MethodDynamicType.ToString(),
NodeType = MethodDynamicType,
ParameterDetailsInfos = this.ParameterDetailss.Select(p => p.ToInfo()).ToArray(),
ReturnTypeFullName = ReturnType.FullName,

1
Library/Entity/NodeLibrary.cs
View File

@@ -15,6 +15,7 @@ namespace Serein.Library.Entity
/// </summary>
public string Path { get; set; }
public string Name{ get; set; }
public Assembly Assembly { get; set; }
}

225
Library/Entity/NodeModelBaseData.cs Normal file
View File

@@ -0,0 +1,225 @@
using Serein.Library.Api;
using Serein.Library.Entity;
using Serein.Library.Enums;
using System;
using System.Collections.Generic;
using System.Threading;
namespace Serein.NodeFlow.Base
{
/// <summary>
/// 节点基类（数据）：条件控件，动作控件，条件区域，动作区域
/// </summary>
public abstract partial class NodeModelBase : IDynamicFlowNode
{
public NodeModelBase()
{
PreviousNodes = new Dictionary<ConnectionType, List<NodeModelBase>>();
SuccessorNodes = new Dictionary<ConnectionType, List<NodeModelBase>>();
foreach (ConnectionType ctType in NodeStaticConfig.ConnectionTypes)
{
PreviousNodes[ctType] = new List<NodeModelBase>();
SuccessorNodes[ctType] = new List<NodeModelBase>();
}
DebugSetting = new NodeDebugSetting();
}
/// <summary>
/// 调试功能
/// </summary>
public NodeDebugSetting DebugSetting { get; set; }
/// <summary>
/// 节点对应的控件类型
/// </summary>
public NodeControlType ControlType { get; set; }
/// <summary>
/// 方法描述，对应DLL的方法
/// </summary>
public MethodDetails MethodDetails { get; set; }
/// <summary>
/// 节点guid
/// </summary>
public string Guid { get; set; }
/// <summary>
/// 显示名称
/// </summary>
public string DisplayName { get; set; } = string.Empty;
/// <summary>
/// 是否为起点控件
/// </summary>
public bool IsStart { get; set; }
/// <summary>
/// 运行时的上一节点
/// </summary>
public NodeModelBase PreviousNode { get; set; }
/// <summary>
/// 不同分支的父节点
/// </summary>
public Dictionary<ConnectionType,List<NodeModelBase>> PreviousNodes { get; }
/// <summary>
/// 不同分支的子节点
/// </summary>
public Dictionary<ConnectionType,List<NodeModelBase>> SuccessorNodes { get; }
/// <summary>
/// 当前节点执行完毕后需要执行的下一个分支的类别
/// </summary>
public ConnectionType NextOrientation { get; set; } = ConnectionType.None;
/// <summary>
/// 运行时的异常信息（仅在 FlowState 为 Error 时存在对应值）
/// </summary>
public Exception RuningException { get; set; } = null;
/// <summary>
/// 控制FlowData在同一时间只会被同一个线程更改。
/// </summary>
private readonly ReaderWriterLockSlim _flowDataLock = new ReaderWriterLockSlim();
private object _flowData;
/// <summary>
/// 当前传递数据（执行了节点对应的方法，才会存在值）。
/// </summary>
protected object FlowData
{
get
{
_flowDataLock.EnterReadLock();
try
{
return _flowData;
}
finally
{
_flowDataLock.ExitReadLock();
}
}
set
{
_flowDataLock.EnterWriteLock();
try
{
_flowData = value;
}
finally
{
_flowDataLock.ExitWriteLock();
}
}
}
}
/// <summary>
/// 节点基类（数据）：条件控件，动作控件，条件区域，动作区域
/// </summary>
//public class NodeModelBaseBuilder
//{
// public NodeModelBaseBuilder(NodeModelBase builder)
// {
// this.ControlType = builder.ControlType;
// this.MethodDetails = builder.MethodDetails;
// this.Guid = builder.Guid;
// this.DisplayName = builder.DisplayName;
// this.IsStart = builder.IsStart;
// this.PreviousNode = builder.PreviousNode;
// this.PreviousNodes = builder.PreviousNodes;
// this.SucceedBranch = builder.SucceedBranch;
// this.FailBranch = builder.FailBranch;
// this.ErrorBranch = builder.ErrorBranch;
// this.UpstreamBranch = builder.UpstreamBranch;
// this.FlowState = builder.FlowState;
// this.RuningException = builder.RuningException;
// this.FlowData = builder.FlowData;
// }
// /// <summary>
// /// 节点对应的控件类型
// /// </summary>
// public NodeControlType ControlType { get; }
// /// <summary>
// /// 方法描述，对应DLL的方法
// /// </summary>
// public MethodDetails MethodDetails { get; }
// /// <summary>
// /// 节点guid
// /// </summary>
// public string Guid { get; }
// /// <summary>
// /// 显示名称
// /// </summary>
// public string DisplayName { get;}
// /// <summary>
// /// 是否为起点控件
// /// </summary>
// public bool IsStart { get; }
// /// <summary>
// /// 运行时的上一节点
// /// </summary>
// public NodeModelBase? PreviousNode { get; }
// /// <summary>
// /// 上一节点集合
// /// </summary>
// public List<NodeModelBase> PreviousNodes { get; } = [];
// /// <summary>
// /// 下一节点集合（真分支）
// /// </summary>
// public List<NodeModelBase> SucceedBranch { get; } = [];
// /// <summary>
// /// 下一节点集合（假分支）
// /// </summary>
// public List<NodeModelBase> FailBranch { get; } = [];
// /// <summary>
// /// 异常分支
// /// </summary>
// public List<NodeModelBase> ErrorBranch { get; } = [];
// /// <summary>
// /// 上游分支
// /// </summary>
// public List<NodeModelBase> UpstreamBranch { get; } = [];
// /// <summary>
// /// 当前执行状态（进入真分支还是假分支，异常分支在异常中确定）
// /// </summary>
// public FlowStateType FlowState { get; set; } = FlowStateType.None;
// /// <summary>
// /// 运行时的异常信息（仅在 FlowState 为 Error 时存在对应值）
// /// </summary>
// public Exception RuningException { get; set; } = null;
// /// <summary>
// /// 当前传递数据（执行了节点对应的方法，才会存在值）
// /// </summary>
// public object? FlowData { get; set; } = null;
//}
}

487
Library/Entity/NodeModelBaseFunc.cs Normal file
View File

@@ -0,0 +1,487 @@
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Serein.Library.Api;
using Serein.Library.Attributes;
using Serein.Library.Entity;
using Serein.Library.Enums;
using Serein.Library.Ex;
using Serein.Library.Utils;
using Serein.NodeFlow.Tool.SereinExpression;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Net.Http.Headers;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.NodeFlow.Base
{
/// <summary>
/// 节点基类（数据）：条件控件，动作控件，条件区域，动作区域
/// </summary>
public abstract partial class NodeModelBase : IDynamicFlowNode
{
#region 调试中断
/// <summary>
/// 不再中断
/// </summary>
public void CancelInterrupt()
{
this.DebugSetting.InterruptClass = InterruptClass.None;
DebugSetting.CancelInterruptCallback?.Invoke();
}
#endregion
#region 导出/导入项目文件节点信息
public abstract Parameterdata[] GetParameterdatas();
public virtual NodeInfo ToInfo()
{
// if (MethodDetails == null) return null;
var trueNodes = SuccessorNodes[ConnectionType.IsSucceed].Select(item => item.Guid); // 真分支
var falseNodes = SuccessorNodes[ConnectionType.IsFail].Select(item => item.Guid);// 假分支
var errorNodes = SuccessorNodes[ConnectionType.IsError].Select(item => item.Guid);// 异常分支
var upstreamNodes = SuccessorNodes[ConnectionType.Upstream].Select(item => item.Guid);// 上游分支
// 生成参数列表
Parameterdata[] parameterData = GetParameterdatas();
return new NodeInfo
{
Guid = Guid,
MethodName = MethodDetails?.MethodName,
Label = DisplayName ?? "",
Type = this.GetType().ToString(),
TrueNodes = trueNodes.ToArray(),
FalseNodes = falseNodes.ToArray(),
UpstreamNodes = upstreamNodes.ToArray(),
ParameterData = parameterData.ToArray(),
ErrorNodes = errorNodes.ToArray(),
};
}
public virtual NodeModelBase LoadInfo(NodeInfo nodeInfo)
{
this.Guid = nodeInfo.Guid;
if (this.MethodDetails != null)
{
for (int i = 0; i < nodeInfo.ParameterData.Length; i++)
{
Parameterdata pd = nodeInfo.ParameterData[i];
this.MethodDetails.ParameterDetailss[i].IsExplicitData = pd.State;
this.MethodDetails.ParameterDetailss[i].DataValue = pd.Value;
}
}
return this;
}
#endregion
#region 节点方法的执行
/// <summary>
/// 是否应该退出执行
/// </summary>
/// <param name="context"></param>
/// <param name="flowCts"></param>
/// <returns></returns>
public static bool IsBradk(IDynamicContext context, CancellationTokenSource flowCts)
{
// 上下文不再执行
if(context.RunState == RunState.Completion)
{
return true;
}
// 不存在全局触发器时，流程运行状态被设置为完成，退出执行，用于打断无限循环分支。
if (flowCts is null && context.Env.FlowState == RunState.Completion)
{
return true;
}
// 如果存在全局触发器，且触发器的执行任务已经被取消时，退出执行。
if (flowCts != null)
{
if (flowCts.IsCancellationRequested)
return true;
}
return false;
}
/// <summary>
/// 开始执行
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task StartFlowAsync(IDynamicContext context)
{
Stack<NodeModelBase> stack = new Stack<NodeModelBase>();
stack.Push(this);
var flowCts = context.Env.IOC.Get<CancellationTokenSource>(NodeStaticConfig.FlipFlopCtsName);
bool hasFlipflow = flowCts != null;
while (stack.Count > 0) // 循环中直到栈为空才会退出循环
{
await Task.Delay(0);
// 从栈中弹出一个节点作为当前节点进行处理
var currentNode = stack.Pop();
#region 执行相关
// 筛选出上游分支
var upstreamNodes = currentNode.SuccessorNodes[ConnectionType.Upstream].ToArray();
for (int index = 0; index < upstreamNodes.Length; index++)
{
NodeModelBase upstreamNode = upstreamNodes[index];
if (!(upstreamNode is null) && upstreamNode.DebugSetting.IsEnable)
{
if (upstreamNode.DebugSetting.InterruptClass != InterruptClass.None) // 执行触发前
{
var cancelType = await upstreamNode.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{upstreamNode.MethodDetails?.MethodName}]中断已{cancelType}，开始执行后继分支");
}
upstreamNode.PreviousNode = currentNode;
await upstreamNode.StartFlowAsync(context); // 执行流程节点的上游分支
if (upstreamNode.NextOrientation == ConnectionType.IsError)
{
// 如果上游分支执行失败，不再继续执行
// 使上游节点（仅上游节点本身，不包含上游节点的后继节点）
// 具备通过抛出异常中断流程的能力
break;
}
}
}
if (IsBradk(context, flowCts)) break; // 退出执行
// 上游分支执行完成，才执行当前节点
object newFlowData = await currentNode.ExecutingAsync(context);
if (IsBradk(context, flowCts)) break; // 退出执行
await RefreshFlowDataAndExpInterrupt(context, currentNode, newFlowData); // 执行当前节点后刷新数据
#endregion
#region 执行完成
// 选择后继分支
var nextNodes = currentNode.SuccessorNodes[currentNode.NextOrientation];
// 将下一个节点集合中的所有节点逆序推入栈中
for (int i = nextNodes.Count - 1; i >= 0; i--)
{
// 筛选出启用的节点的节点
if (nextNodes[i].DebugSetting.IsEnable)
{
nextNodes[i].PreviousNode = currentNode;
stack.Push(nextNodes[i]);
}
}
#endregion
}
}
/// <summary>
/// 执行节点对应的方法
/// </summary>
/// <param name="context">流程上下文</param>
/// <returns>节点传回数据对象</returns>
public virtual async Task<object> ExecutingAsync(IDynamicContext context)
{
#region 调试中断
if (DebugSetting.InterruptClass != InterruptClass.None) // 执行触发检查是否需要中断
{
var cancelType = await this.DebugSetting.GetInterruptTask(); // 等待中断结束
await Console.Out.WriteLineAsync($"[{this.MethodDetails?.MethodName}]中断已{cancelType}，开始执行后继分支");
}
#endregion
MethodDetails md = MethodDetails;
//var del = md.MethodDelegate.Clone();
if (md is null)
{
throw new Exception($"节点{this.Guid}不存在方法信息，请检查是否需要重写节点的ExecutingAsync");
}
if (!context.Env.TryGetDelegateDetails(md.MethodName, out var dd))
{
throw new Exception($"节点{this.Guid}不存在对应委托");
}
if(md.ActingInstance is null)
{
md.ActingInstance = context.Env.IOC.Get(md.ActingInstanceType);
}
// md.ActingInstance ??= context.Env.IOC.Get(md.ActingInstanceType);
object instance = md.ActingInstance;
object result = null;
try
{
object[] args = GetParameters(context, this, md);
result = await dd.InvokeAsync(md.ActingInstance, args);
NextOrientation = ConnectionType.IsSucceed;
return result;
}
catch (Exception ex)
{
await Console.Out.WriteLineAsync($"节点[{this.MethodDetails?.MethodName}]异常：" + ex);
NextOrientation = ConnectionType.IsError;
RuningException = ex;
return null;
}
}
/// <summary>
/// 获取对应的参数数组
/// </summary>
public static object[] GetParameters(IDynamicContext context, NodeModelBase nodeModel, MethodDetails md)
{
// 用正确的大小初始化参数数组
if (md.ParameterDetailss.Length == 0)
{
return null;// md.ActingInstance
}
object[] parameters = new object[md.ParameterDetailss.Length];
var flowData = nodeModel.PreviousNode?.FlowData; // 当前传递的数据
var previousDataType = flowData?.GetType();
for (int i = 0; i < parameters.Length; i++)
{
object inputParameter; // 存放解析的临时参数
var ed = md.ParameterDetailss[i]; // 方法入参描述
if (ed.IsExplicitData) // 判断是否使用显示的输入参数
{
if (ed.DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase) && !(flowData is null))
{
// 执行表达式从上一节点获取对象
inputParameter = SerinExpressionEvaluator.Evaluate(ed.DataValue, flowData, out _);
}
else
{
// 使用输入的固定值
inputParameter = ed.DataValue;
}
}
else
{
inputParameter = flowData; // 使用上一节点的对象
}
// 入参存在取值转换器
if (ed.ExplicitType.IsEnum && !(ed.Convertor is null))
{
//var resultEnum = Enum.ToObject(ed.ExplicitType, ed.DataValue);
var resultEnum = Enum.Parse(ed.ExplicitType, ed.DataValue);
var value = ed.Convertor(resultEnum);
if (value is null)
{
throw new InvalidOperationException("转换器调用失败");
}
else
{
parameters[i] = value;
continue;
}
//if (Enum.TryParse(ed.ExplicitType, ed.DataValue, out var resultEnum))
//{
//}
}
// 入参存在类型转换器，获取枚举转换器中记录的枚举
if (ed.ExplicitType.IsEnum && ed.DataType != ed.ExplicitType)
{
var resultEnum = Enum.Parse(ed.ExplicitType, ed.DataValue);
// 获取绑定的类型
var type = EnumHelper.GetBoundValue(ed.ExplicitType, resultEnum, attr => attr.Value);
if (type is Type enumBindType && !(enumBindType is null))
{
var value = context.Env.IOC.Instantiate(enumBindType);
if (value is null)
{
}
else
{
parameters[i] = value;
continue;
}
}
}
if (ed.DataType.IsValueType)
{
var valueStr = inputParameter?.ToString();
parameters[i] = valueStr.ToValueData(ed.DataType);
}
else
{
var valueStr = inputParameter?.ToString();
if(ed.DataType == typeof(string))
{
parameters[i] = valueStr;
}
else if(ed.DataType == typeof(IDynamicContext))
{
parameters[i] = context;
}
else if(ed.DataType == typeof(MethodDetails))
{
parameters[i] = md;
}
else if(ed.DataType == typeof(NodeModelBase))
{
parameters[i] = nodeModel;
}
else
{
parameters[i] = inputParameter;
}
//parameters[i] = ed.DataType switch
//{
// Type t when t == typeof(string) => valueStr,
// Type t when t == typeof(IDynamicContext) => context, // 上下文
// Type t when t == typeof(DateTime) => string.IsNullOrEmpty(valueStr) ? null : DateTime.Parse(valueStr),
// Type t when t == typeof(MethodDetails) => md, // 节点方法描述
// Type t when t == typeof(NodeModelBase) => nodeModel, // 节点实体类
// Type t when t.IsArray => (inputParameter as Array)?.Cast<object>().ToList(),
// Type t when t.IsGenericType && t.GetGenericTypeDefinition() == typeof(List<>) => inputParameter,
// _ => inputParameter,
//};
}
}
return parameters;
}
/// <summary>
/// 更新节点数据，并检查监视表达式是否生效
/// </summary>
/// <param name="context">上下文</param>
/// <param name="nodeModel">节点Moel</param>
/// <param name="newData">新的数据</param>
/// <returns></returns>
public static async Task RefreshFlowDataAndExpInterrupt(IDynamicContext context, NodeModelBase nodeModel, object newData = null)
{
string guid = nodeModel.Guid;
if (newData is null)
{
}
else
{
await MonitorObjExpInterrupt(context, nodeModel, newData, 0); // 首先监视对象
await MonitorObjExpInterrupt(context, nodeModel, newData, 1); // 然后监视节点
nodeModel.FlowData = newData; // 替换数据
context.AddOrUpdate(guid, nodeModel); // 上下文中更新数据
}
}
private static async Task MonitorObjExpInterrupt(IDynamicContext context, NodeModelBase nodeModel, object data, int monitorType)
{
MonitorObjectEventArgs.ObjSourceType sourceType;
string key;
if (monitorType == 0)
{
key = data?.GetType()?.FullName;
sourceType = MonitorObjectEventArgs.ObjSourceType.IOCObj;
}
else
{
key = nodeModel.Guid;
sourceType = MonitorObjectEventArgs.ObjSourceType.IOCObj;
}
if (string.IsNullOrEmpty(key))
{
return;
}
if (context.Env.CheckObjMonitorState(key, out List<string> exps)) // 如果新的数据处于查看状态，通知UI进行更新？交给运行环境判断？
{
context.Env.MonitorObjectNotification(nodeModel.Guid, data, sourceType); // 对象处于监视状态，通知UI更新数据显示
if (exps.Count > 0)
{
// 表达式环境下判断是否需要执行中断
bool isExpInterrupt = false;
string exp = "";
// 判断执行监视表达式，直到为 true 时退出
for (int i = 0; i < exps.Count && !isExpInterrupt; i++)
{
exp = exps[i];
if (string.IsNullOrEmpty(exp)) continue;
// isExpInterrupt = SereinConditionParser.To(data, exp);
}
if (isExpInterrupt) // 触发中断
{
InterruptClass interruptClass = InterruptClass.Branch; // 分支中断
if (context.Env.SetNodeInterrupt(nodeModel.Guid, interruptClass))
{
context.Env.TriggerInterrupt(nodeModel.Guid, exp, InterruptTriggerEventArgs.InterruptTriggerType.Exp);
var cancelType = await nodeModel.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{data}]中断已{cancelType}，开始执行后继分支");
}
}
}
}
}
/// <summary>
/// 释放对象
/// </summary>
public void ReleaseFlowData()
{
if (typeof(IDisposable).IsAssignableFrom(FlowData?.GetType()) && FlowData is IDisposable disposable)
{
disposable?.Dispose();
}
this.FlowData = null;
}
/// <summary>
/// 获取节点数据
/// </summary>
/// <returns></returns>
public object GetFlowData()
{
return this.FlowData;
}
#endregion
}
}

7
Library/Network/WebSocket/Handle/WebSocketHandleConfig.cs → Library/Network/WebSocket/Handle/JsonMsgHandleConfig.cs
View File

@@ -15,14 +15,17 @@ using System.Threading.Tasks;
namespace Serein.Library.Network.WebSocketCommunication.Handle
{
public class WebSocketHandleConfig
/// <summary>
///
/// </summary>
public class JsonMsgHandleConfig
{
private readonly Delegate EmitDelegate;
private readonly EmitHelper.EmitMethodType EmitMethodType;
private Action<Exception, Action<object>> OnExceptionTracking;
internal WebSocketHandleConfig(SocketHandleModel model,ISocketHandleModule instance, MethodInfo methodInfo, Action<Exception, Action<object>> onExceptionTracking)
internal JsonMsgHandleConfig(SocketHandleModel model,ISocketHandleModule instance, MethodInfo methodInfo, Action<Exception, Action<object>> onExceptionTracking)
{
EmitMethodType = EmitHelper.CreateDynamicMethod(methodInfo,out EmitDelegate);
this.Model = model;

44
Library/Network/WebSocket/Handle/WebSocketHandleModule.cs
View File

@@ -8,30 +8,51 @@ using System.Threading.Tasks;
namespace Serein.Library.Network.WebSocketCommunication.Handle
{
/// <summary>
/// Json消息处理模块
/// </summary>
public class WebSocketHandleModule
{
/// <summary>
/// Json消息处理模块
/// </summary>
public WebSocketHandleModule(string ThemeJsonKey, string DataJsonKey)
{
this.ThemeJsonKey = ThemeJsonKey;
this.DataJsonKey = DataJsonKey;
}
/// <summary>
/// 指示处理模块该使用json中的哪个key作为业务区别字段
/// </summary>
public string ThemeJsonKey { get; }
/// <summary>
/// 指示处理模块该使用json中的哪个key作为业务数据字段
/// </summary>
public string DataJsonKey { get; }
/// <summary>
/// 存储处理数据的配置
/// </summary>
public ConcurrentDictionary<string, JsonMsgHandleConfig> MyHandleConfigs = new ConcurrentDictionary<string, JsonMsgHandleConfig>();
public ConcurrentDictionary<string, WebSocketHandleConfig> MyHandleConfigs = new ConcurrentDictionary<string, WebSocketHandleConfig>();
internal void AddHandleConfigs(SocketHandleModel model, ISocketHandleModule instance, MethodInfo methodInfo
, Action<Exception, Action<object>> onExceptionTracking)
{
if (!MyHandleConfigs.ContainsKey(model.ThemeValue))
{
var myHandleConfig = new WebSocketHandleConfig(model,instance, methodInfo, onExceptionTracking);
MyHandleConfigs[model.ThemeValue] = myHandleConfig;
var jsonMsgHandleConfig = new JsonMsgHandleConfig(model,instance, methodInfo, onExceptionTracking);
MyHandleConfigs[model.ThemeValue] = jsonMsgHandleConfig;
}
}
public bool ResetConfig(ISocketHandleModule socketControlBase)
/// <summary>
/// 移除某个处理模块
/// </summary>
/// <param name="socketControlBase"></param>
/// <returns></returns>
public bool RemoveConfig(ISocketHandleModule socketControlBase)
{
foreach (var kv in MyHandleConfigs.ToArray())
{
@@ -44,7 +65,10 @@ namespace Serein.Library.Network.WebSocketCommunication.Handle
return MyHandleConfigs.Count == 0;
}
public void ResetConfig()
/// <summary>
/// 卸载当前模块的所有配置
/// </summary>
public void UnloadConfig()
{
var temp = MyHandleConfigs.Values;
MyHandleConfigs.Clear();
@@ -54,7 +78,11 @@ namespace Serein.Library.Network.WebSocketCommunication.Handle
}
}
/// <summary>
/// 处理JSON数据
/// </summary>
/// <param name="RecoverAsync"></param>
/// <param name="jsonObject"></param>
public void HandleSocketMsg(Func<string, Task> RecoverAsync, JObject jsonObject)
{
// 获取到消息

12
Library/Network/WebSocket/Handle/WebSocketMsgHandleHelper.cs
View File

@@ -19,7 +19,9 @@ using System.Security.Cryptography;
namespace Serein.Library.Network.WebSocketCommunication.Handle
{
/// <summary>
/// 适用于Json数据格式的WebSocket消息处理类
/// </summary>
public class WebSocketMsgHandleHelper
{
/// <summary>
@@ -68,7 +70,7 @@ namespace Serein.Library.Network.WebSocketCommunication.Handle
var key = (themeKeyName, dataKeyName);
if (MyHandleModuleDict.TryGetValue(key, out var myHandleModules))
{
var isRemote = myHandleModules.ResetConfig(socketControlBase);
var isRemote = myHandleModules.RemoveConfig(socketControlBase);
if (isRemote) MyHandleModuleDict.TryGetValue(key, out _);
}
@@ -132,6 +134,12 @@ namespace Serein.Library.Network.WebSocketCommunication.Handle
}
/// <summary>
/// 异步处理消息
/// </summary>
/// <param name="RecoverAsync"></param>
/// <param name="message"></param>
/// <returns></returns>
public async Task HandleMsgAsync(Func<string, Task> RecoverAsync, string message)
{
JObject json = JObject.Parse(message);

22
Library/Network/WebSocket/WebSocketServer.cs
View File

@@ -14,12 +14,25 @@ using System.Threading.Tasks;
namespace Serein.Library.Network.WebSocketCommunication
{
/// <summary>
/// WebSocket服务类
/// </summary>
[AutoRegister]
public class WebSocketServer
{
/// <summary>
/// 消息处理
/// </summary>
public WebSocketMsgHandleHelper MsgHandleHelper { get; } = new WebSocketMsgHandleHelper();
private HttpListener listener;
/// <summary>
/// 进行监听服务
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public async Task StartAsync(string url)
{
listener = new HttpListener();
@@ -58,6 +71,9 @@ namespace Serein.Library.Network.WebSocketCommunication
}
}
/// <summary>
/// 停止监听服务
/// </summary>
public void Stop()
{
listener?.Stop();
@@ -96,6 +112,12 @@ namespace Serein.Library.Network.WebSocketCommunication
}
}
/// <summary>
/// 发送消息
/// </summary>
/// <param name="webSocket"></param>
/// <param name="message"></param>
/// <returns></returns>
public static async Task SendAsync(WebSocket webSocket, string message)
{
var buffer = Encoding.UTF8.GetBytes(message);

41
Library/NodeStaticConfig.cs Normal file
View File

@@ -0,0 +1,41 @@
using Serein.Library.Api;
using Serein.Library.Enums;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow
{
public static class NodeStaticConfig
{
/// <summary>
/// 全局触发器CTS
/// </summary>
public const string FlipFlopCtsName = "<>.FlowFlipFlopCts";
/// <summary>
/// 流程运行CTS
/// </summary>
public const string FlowRungCtsName = "<>.FlowRungCtsName";
/// <summary>
/// 节点的命名空间
/// </summary>
//public const string NodeSpaceName = $"{nameof(Serein)}.{nameof(Serein.NodeFlow)}.{nameof(Serein.NodeFlow.Model)}";
public const string NodeSpaceName = "Serein.NodeFlow.Model";
/// <summary>
/// 节点连接关系种类
/// </summary>
public static readonly ConnectionType[] ConnectionTypes = new ConnectionType[]
{
ConnectionType.Upstream,
ConnectionType.IsSucceed,
ConnectionType.IsFail,
ConnectionType.IsError,
};
}
}

3
Library/Serein.Library.csproj
View File

@@ -14,10 +14,13 @@
</PropertyGroup>
<ItemGroup>
<Compile Remove="Entity\Base\**" />
<Compile Remove="Http\**" />
<Compile Remove="Utils\SerinExpression\**" />
<EmbeddedResource Remove="Entity\Base\**" />
<EmbeddedResource Remove="Http\**" />
<EmbeddedResource Remove="Utils\SerinExpression\**" />
<None Remove="Entity\Base\**" />
<None Remove="Http\**" />
<None Remove="Utils\SerinExpression\**" />
</ItemGroup>

2
Library/Utils/EnumHelper.cs
View File

@@ -29,6 +29,8 @@ namespace Serein.Library.Utils
result = default;
return false;
}
/// <summary>
/// 从枚举值的 BindValueAttribute 特性中 获取绑定的参数（用于绑定了某些内容的枚举值）

38
Library/Utils/SereinExpression/Resolver/BoolConditionResolver.cs Normal file
View File

@@ -0,0 +1,38 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow.Tool.SereinExpression.Resolver
{
public class BoolConditionResolver : SereinConditionResolver
{
public enum Operator
{
/// <summary>
/// 是
/// </summary>
Is
}
public Operator Op { get; set; }
public bool Value { get; set; }
public override bool Evaluate(object obj)
{
if (obj is bool boolObj)
{
return boolObj == Value;
/*switch (Op)
{
case Operator.Is:
return boolObj == Value;
}*/
}
return false;
}
}
}

59
Library/Utils/SereinExpression/Resolver/MemberConditionResolver.cs Normal file
View File

@@ -0,0 +1,59 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow.Tool.SereinExpression.Resolver
{
public class MemberConditionResolver<T> : SereinConditionResolver where T : struct, IComparable<T>
{
//public string MemberPath { get; set; }
public ValueTypeConditionResolver<T>.Operator Op { get; set; }
public object TargetObj { get; set; }
public T Value { get; set; }
public string ArithmeticExpression { get; set; }
public T RangeEnd { get; internal set; }
public T RangeStart { get; internal set; }
public override bool Evaluate(object obj)
{
//object? memberValue = GetMemberValue(obj, MemberPath);
if (TargetObj is T typedObj)
{
return new ValueTypeConditionResolver<T>
{
RangeStart = RangeStart,
RangeEnd = RangeEnd,
Op = Op,
Value = Value,
ArithmeticExpression = ArithmeticExpression,
}.Evaluate(typedObj);
}
return false;
}
//private object? GetMemberValue(object? obj, string memberPath)
//{
// string[] members = memberPath[1..].Split('.');
// foreach (var member in members)
// {
// if (obj == null) return null;
// Type type = obj.GetType();
// PropertyInfo? propertyInfo = type.GetProperty(member);
// FieldInfo? fieldInfo = type.GetField(member);
// if (propertyInfo != null)
// obj = propertyInfo.GetValue(obj);
// else if (fieldInfo != null)
// obj = fieldInfo.GetValue(obj);
// else
// throw new ArgumentException($"Member {member} not found in type {type.FullName}");
// }
// return obj;
//}
}
}

86
Library/Utils/SereinExpression/Resolver/MemberStringConditionResolver.cs Normal file
View File

@@ -0,0 +1,86 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow.Tool.SereinExpression.Resolver
{
public class MemberStringConditionResolver : SereinConditionResolver
{
public string MemberPath { get; set; }
public StringConditionResolver.Operator Op { get; set; }
public string Value { get; set; }
public override bool Evaluate(object obj)
{
object memberValue;
if (!string.IsNullOrWhiteSpace(MemberPath))
{
memberValue = GetMemberValue(obj, MemberPath);
}
else
{
memberValue = obj;
}
if (memberValue is string strObj)
{
return new StringConditionResolver
{
Op = Op,
Value = Value
}.Evaluate(strObj);
}
return false;
}
private object GetMemberValue(object obj, string memberPath)
{
//string[] members = memberPath[1..].Split('.');
string[] members = memberPath.Substring(1).Split('.');
foreach (var member in members)
{
if (obj is null) return null;
Type type = obj.GetType();
PropertyInfo propertyInfo = type.GetProperty(member);
FieldInfo fieldInfo = type.GetField(member);
if (propertyInfo != null)
obj = propertyInfo.GetValue(obj);
else if (fieldInfo != null)
obj = fieldInfo.GetValue(obj);
else
throw new ArgumentException($"Member {member} not found in type {type.FullName}");
}
return obj;
}
private static string GetArithmeticExpression(string part)
{
int startIndex = part.IndexOf('[');
int endIndex = part.IndexOf(']');
if (startIndex >= 0 && endIndex > startIndex)
{
return part.Substring(startIndex + 1, endIndex - startIndex - 1);
}
return null;
}
}
}

38
Library/Utils/SereinExpression/Resolver/PassConditionResolver.cs Normal file
View File

@@ -0,0 +1,38 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow.Tool.SereinExpression.Resolver
{
public class PassConditionResolver : SereinConditionResolver
{
public Operator Op { get; set; }
public override bool Evaluate(object obj)
{
/*return Op switch
{
Operator.Pass => true,
Operator.NotPass => false,
_ => throw new NotSupportedException("不支持的条件类型")
};*/
switch (Op)
{
case Operator.Pass:
return true;
case Operator.NotPass:
return false;
default:
throw new NotSupportedException("不支持的条件类型");
}
}
public enum Operator
{
Pass,
NotPass,
}
}
}

80
Library/Utils/SereinExpression/Resolver/StringConditionResolver.cs Normal file
View File

@@ -0,0 +1,80 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow.Tool.SereinExpression.Resolver
{
public class StringConditionResolver : SereinConditionResolver
{
public enum Operator
{
/// <summary>
/// 出现过
/// </summary>
Contains,
/// <summary>
/// 没有出现过
/// </summary>
DoesNotContain,
/// <summary>
/// 相等
/// </summary>
Equal,
/// <summary>
/// 不相等
/// </summary>
NotEqual,
/// <summary>
/// 起始字符串等于
/// </summary>
StartsWith,
/// <summary>
/// 结束字符串等于
/// </summary>
EndsWith
}
public Operator Op { get; set; }
public string Value { get; set; }
public override bool Evaluate(object obj)
{
if (obj is string strObj)
{
/*return Op switch
{
Operator.Contains => strObj.Contains(Value),
Operator.DoesNotContain => !strObj.Contains(Value),
Operator.Equal => strObj == Value,
Operator.NotEqual => strObj != Value,
Operator.StartsWith => strObj.StartsWith(Value),
Operator.EndsWith => strObj.EndsWith(Value),
_ => throw new NotSupportedException("不支持的条件类型"),
};*/
switch (Op)
{
case Operator.Contains:
return strObj.Contains(Value);
case Operator.DoesNotContain:
return !strObj.Contains(Value);
case Operator.Equal:
return strObj == Value;
case Operator.NotEqual:
return strObj != Value;
case Operator.StartsWith:
return strObj.StartsWith(Value);
case Operator.EndsWith:
return strObj.EndsWith(Value);
default:
throw new NotSupportedException("不支持的条件类型");
}
}
return false;
}
}
}

128
Library/Utils/SereinExpression/Resolver/ValueTypeConditionResolver.cs Normal file
View File

@@ -0,0 +1,128 @@
using Serein.Library.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow.Tool.SereinExpression.Resolver
{
public class ValueTypeConditionResolver<T> : SereinConditionResolver where T : struct, IComparable<T>
{
public enum Operator
{
/// <summary>
/// 不进行任何操作
/// </summary>
Node,
/// <summary>
/// 大于
/// </summary>
GreaterThan,
/// <summary>
/// 小于
/// </summary>
LessThan,
/// <summary>
/// 等于
/// </summary>
Equal,
/// <summary>
/// 大于或等于
/// </summary>
GreaterThanOrEqual,
/// <summary>
/// 小于或等于
/// </summary>
LessThanOrEqual,
/// <summary>
/// 在两者之间
/// </summary>
InRange,
/// <summary>
/// 不在两者之间
/// </summary>
OutOfRange
}
public Operator Op { get; set; }
public T Value { get; set; }
public T RangeStart { get; set; }
public T RangeEnd { get; set; }
public string ArithmeticExpression { get; set; }
public override bool Evaluate(object obj)
{
var evaluatedValue = obj.ToConvert<T>();
if (!string.IsNullOrEmpty(ArithmeticExpression))
{
evaluatedValue = SerinArithmeticExpressionEvaluator<T>.Evaluate(ArithmeticExpression, evaluatedValue);
}
switch (Op)
{
case Operator.GreaterThan:
return evaluatedValue.CompareTo(Value) > 0;
case Operator.LessThan:
return evaluatedValue.CompareTo(Value) < 0;
case Operator.Equal:
return evaluatedValue.CompareTo(Value) == 0;
case Operator.GreaterThanOrEqual:
return evaluatedValue.CompareTo(Value) >= 0;
case Operator.LessThanOrEqual:
return evaluatedValue.CompareTo(Value) <= 0;
case Operator.InRange:
return evaluatedValue.CompareTo(RangeStart) >= 0 && evaluatedValue.CompareTo(RangeEnd) <= 0;
case Operator.OutOfRange:
return evaluatedValue.CompareTo(RangeStart) < 0 || evaluatedValue.CompareTo(RangeEnd) > 0;
}
return false;
//if (obj is T typedObj)
//{
// numericValue = Convert.ToDouble(typedObj);
// numericValue = Convert.ToDouble(obj);
// if (!string.IsNullOrEmpty(ArithmeticExpression))
// {
// numericValue = SerinArithmeticExpressionEvaluator.Evaluate(ArithmeticExpression, numericValue);
// }
// T evaluatedValue = (T)Convert.ChangeType(numericValue, typeof(T));
// /*return Op switch
// {
// Operator.GreaterThan => evaluatedValue.CompareTo(Value) > 0,
// Operator.LessThan => evaluatedValue.CompareTo(Value) < 0,
// Operator.Equal => evaluatedValue.CompareTo(Value) == 0,
// Operator.GreaterThanOrEqual => evaluatedValue.CompareTo(Value) >= 0,
// Operator.LessThanOrEqual => evaluatedValue.CompareTo(Value) <= 0,
// Operator.InRange => evaluatedValue.CompareTo(RangeStart) >= 0 && evaluatedValue.CompareTo(RangeEnd) <= 0,
// Operator.OutOfRange => evaluatedValue.CompareTo(RangeStart) < 0 || evaluatedValue.CompareTo(RangeEnd) > 0,
// _ => throw new NotSupportedException("不支持的条件类型")
// };*/
// switch (Op)
// {
// case Operator.GreaterThan:
// return evaluatedValue.CompareTo(Value) > 0;
// case Operator.LessThan:
// return evaluatedValue.CompareTo(Value) < 0;
// case Operator.Equal:
// return evaluatedValue.CompareTo(Value) == 0;
// case Operator.GreaterThanOrEqual:
// return evaluatedValue.CompareTo(Value) >= 0;
// case Operator.LessThanOrEqual:
// return evaluatedValue.CompareTo(Value) <= 0;
// case Operator.InRange:
// return evaluatedValue.CompareTo(RangeStart) >= 0 && evaluatedValue.CompareTo(RangeEnd) <= 0;
// case Operator.OutOfRange:
// return evaluatedValue.CompareTo(RangeStart) < 0 || evaluatedValue.CompareTo(RangeEnd) > 0;
// }
//}
//return false;
}
}
}

775
Library/Utils/SereinExpression/SereinConditionParser.cs Normal file
View File

@@ -0,0 +1,775 @@
using Newtonsoft.Json.Linq;
using Serein.Library.Utils;
using Serein.NodeFlow.Tool.SereinExpression.Resolver;
using System;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Globalization;
using System.Linq;
using System.Reflection;
namespace Serein.NodeFlow.Tool.SereinExpression
{
/// <summary>
/// 字符串工具类
/// </summary>
public static class StringHelper
{
/// <summary>
/// Net低版本无法引入Skip函数，所以使用扩展方法代替
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source"></param>
/// <param name="count"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static IEnumerable<T> MySkip<T>(this IEnumerable<T> source, int count)
{
if (source == null)
throw new ArgumentNullException(nameof(source));
int skipped = 0;
foreach (var item in source)
{
if (skipped++ >= count)
yield return item;
}
}
public static string JoinStrings(string[] parts, int startIndex, int count, char separator)
{
if (parts == null)
throw new ArgumentNullException(nameof(parts));
if (startIndex < 0 || startIndex >= parts.Length || count < 0 || startIndex + count > parts.Length)
throw new ArgumentOutOfRangeException();
// 复制需要的部分到新的数组
string[] subArray = new string[count];
Array.Copy(parts, startIndex, subArray, 0, count);
// 使用 string.Join 连接
return string.Join(separator.ToString(), subArray);
}
}
public class SereinConditionParser
{
public static bool To<T>(T data, string expression)
{
try
{
if (string.IsNullOrEmpty(expression))
{
return false;
}
var parse = ConditionParse(data, expression);
var result = parse.Evaluate(data);
return result;
}
catch (Exception ex)
{
Console.WriteLine(ex);
throw;
}
}
public static SereinConditionResolver ConditionParse(object data, string expression)
{
if (expression.StartsWith(".")) // 表达式前缀属于从上一个节点数据对象获取成员值
{
return ParseObjectExpression(data, expression);
}
else
{
return ParseSimpleExpression(data, expression);
}
//bool ContainsArithmeticOperators(string expression)
//{
// return expression.Contains('+') || expression.Contains('-') || expression.Contains('*') || expression.Contains('/');
//}
}
/// <summary>
/// 获取计算表达式的部分
/// </summary>
/// <param name="part"></param>
/// <returns></returns>
private static string GetArithmeticExpression(string part)
{
int startIndex = part.IndexOf('[');
int endIndex = part.IndexOf(']');
if (startIndex >= 0 && endIndex > startIndex)
{
return part.Substring(startIndex + 1, endIndex - startIndex - 1);
}
return null;
}
/// <summary>
/// 获取对象指定名称的成员
/// </summary>
private static object GetMemberValue(object obj, string memberPath)
{
//string[] members = memberPath[1..].Split('.');
string[] members = memberPath.Substring(1).Split('.');
foreach (var member in members)
{
if (obj is null) return null;
Type type = obj.GetType();
PropertyInfo propertyInfo = type.GetProperty(member);
FieldInfo fieldInfo = type.GetField(member);
if (propertyInfo != null)
obj = propertyInfo.GetValue(obj);
else if (fieldInfo != null)
obj = fieldInfo.GetValue(obj);
else
throw new ArgumentException($"Member {member} not found in type {type.FullName}");
}
return obj;
}
/// <summary>
/// 解析对象表达式
/// </summary>
private static SereinConditionResolver ParseObjectExpression(object data, string expression)
{
var parts = expression.Split(' ');
string operatorStr = parts[0]; // 获取操作类型
string valueStr; //= string.Join(' ', parts, 1, parts.Length - 1);
string memberPath;
Type type;
object targetObj;
// 尝试获取指定类型
int typeStartIndex = expression.IndexOf('<');
int typeEndIndex = expression.IndexOf('>');
if (typeStartIndex + typeStartIndex == -2)
{
// 如果不需要转为指定类型
memberPath = operatorStr;
targetObj = SerinExpressionEvaluator.Evaluate("@get " + operatorStr, data, out _);
//targetObj = GetMemberValue(data, operatorStr);
type = targetObj.GetType();
operatorStr = parts[1].ToLower(); //
valueStr = string.Join(" ", parts.Skip(2));
}
else
{
// 类型语法不正确
if (typeStartIndex >= typeEndIndex)
{
throw new ArgumentException("无效的表达式格式");
}
memberPath = expression.Substring(0, typeStartIndex).Trim();
string typeStr = expression.Substring(typeStartIndex + 1, typeEndIndex - typeStartIndex - 1)
.Trim().ToLower(); // 手动置顶的类型
// 对象取值表达式
parts = expression.Substring(typeEndIndex + 1).Trim().Split(' ');
if (parts.Length == 3)
{
operatorStr = parts[1].ToLower(); // 操作类型
valueStr = string.Join(" ", parts.Skip(2)); // 表达式值
}
else
{
operatorStr = parts[0].ToLower(); // 操作类型
valueStr = string.Join(" ", parts.Skip(1)); // 表达式值
}
Type tempType;
switch (typeStr)
{
case "bool":
tempType = typeof(bool);
break;
case "float":
tempType = typeof(float);
break;
case "decimal":
tempType = typeof(decimal);
break;
case "double":
tempType = typeof(double);
break;
case "sbyte":
tempType = typeof(sbyte);
break;
case "byte":
tempType = typeof(byte);
break;
case "short":
tempType = typeof(short);
break;
case "ushort":
tempType = typeof(ushort);
break;
case "int":
tempType = typeof(int);
break;
case "uint":
tempType = typeof(uint);
break;
case "long":
tempType = typeof(long);
break;
case "ulong":
tempType = typeof(ulong);
break;
// 如果需要支持 nint 和 nuint
// case "nint":
// tempType = typeof(nint);
// break;
// case "nuint":
// tempType = typeof(nuint);
// break;
case "string":
tempType = typeof(string);
break;
default:
tempType = Type.GetType(typeStr);
break;
}
type = tempType ?? throw new ArgumentException("对象表达式无效的类型声明");
if (string.IsNullOrWhiteSpace(memberPath))
{
targetObj = Convert.ChangeType(data, type);
}
else
{
targetObj = GetMemberValue(data, memberPath);// 获取对象成员，作为表达式的目标对象
}
}
#region 解析类型 int
if (type.IsValueType)
{
//return GetValueResolver(type, valueStr, operatorStr, parts);
}
if (type == typeof(int))
{
var op = ParseValueTypeOperator<int>(operatorStr);
if (op == ValueTypeConditionResolver<int>.Operator.InRange || op == ValueTypeConditionResolver<int>.Operator.OutOfRange)
{
var temp = valueStr.Split('-');
if (temp.Length < 2)
throw new ArgumentException($"范围无效：{valueStr}。");
int rangeStart = int.Parse(temp[0], CultureInfo.InvariantCulture);
int rangeEnd = int.Parse(temp[1], CultureInfo.InvariantCulture);
return new MemberConditionResolver<int>
{
Op = op,
RangeStart = rangeStart,
RangeEnd = rangeEnd,
TargetObj = targetObj,
ArithmeticExpression = GetArithmeticExpression(parts[0]),
};
}
else
{
int value = int.Parse(valueStr, CultureInfo.InvariantCulture);
return new MemberConditionResolver<int>
{
TargetObj = targetObj,
//MemberPath = memberPath,
Op = ParseValueTypeOperator<int>(operatorStr),
Value = value,
ArithmeticExpression = GetArithmeticExpression(parts[0])
};
}
}
#endregion
#region 解析类型 double
else if (type == typeof(double))
{
double value = double.Parse(valueStr, CultureInfo.InvariantCulture);
return new MemberConditionResolver<double>
{
//MemberPath = memberPath,
TargetObj = targetObj,
Op = ParseValueTypeOperator<double>(operatorStr),
Value = value,
ArithmeticExpression = GetArithmeticExpression(parts[0])
};
}
#endregion
#region 解析类型 bool
else if (type == typeof(bool))
{
return new MemberConditionResolver<bool>
{
//MemberPath = memberPath,
TargetObj = targetObj,
Op = (ValueTypeConditionResolver<bool>.Operator)ParseBoolOperator(operatorStr)
};
}
#endregion
#region 解析类型 string
else if (type == typeof(string))
{
return new MemberStringConditionResolver
{
MemberPath = memberPath,
Op = ParseStringOperator(operatorStr),
Value = valueStr
};
}
#endregion
throw new NotSupportedException($"Type {type} is not supported.");
}
/// <summary>
/// 条件表达式解析
/// </summary>
/// <param name="data"></param>
/// <param name="expression"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="NotSupportedException"></exception>
private static SereinConditionResolver ParseSimpleExpression(object data, string expression)
{
if ("pass".Equals(expression.ToLower()))
{
return new PassConditionResolver
{
Op = PassConditionResolver.Operator.Pass,
};
}
else
{
if ("not pass".Equals(expression.ToLower()))
{
return new PassConditionResolver
{
Op = PassConditionResolver.Operator.NotPass,
};
}
if ("!pass".Equals(expression.ToLower()))
{
return new PassConditionResolver
{
Op = PassConditionResolver.Operator.NotPass,
};
}
}
var parts = expression.Split(' ');
if (parts.Length < 2)
throw new ArgumentException("无效的表达式格式。");
string operatorStr;
string valueStr;
Type type = null;
// 尝试获取指定类型
int typeStartIndex = expression.IndexOf('<');
int typeEndIndex = expression.IndexOf('>');
if (typeStartIndex + typeStartIndex == -2)
{
// 如果不需要转为指定类型
operatorStr = parts[0];
#if NET8_0_OR_GREATER
valueStr = string.Join(' ', parts, 1, parts.Length - 1);
#elif NET462_OR_GREATER
valueStr = StringHelper.JoinStrings(parts, 1, parts.Length - 1, ' ');
#endif
type = data.GetType();
}
else
{//string typeStr = parts[0];
string typeStr = expression.Substring(typeStartIndex + 1, typeEndIndex - typeStartIndex - 1)
.Trim().ToLower(); // 手动置顶的类型
parts = expression.Substring(typeEndIndex + 1).Trim().Split(' ');
operatorStr = parts[0].ToLower(); // 操作类型
valueStr = string.Join(" ", parts.Skip(1)); // 表达式值
Type tempType;
switch (typeStr)
{
case "bool":
tempType = typeof(bool);
break;
case "float":
tempType = typeof(float);
break;
case "decimal":
tempType = typeof(decimal);
break;
case "double":
tempType = typeof(double);
break;
case "sbyte":
tempType = typeof(sbyte);
break;
case "byte":
tempType = typeof(byte);
break;
case "short":
tempType = typeof(short);
break;
case "ushort":
tempType = typeof(ushort);
break;
case "int":
tempType = typeof(int);
break;
case "uint":
tempType = typeof(uint);
break;
case "long":
tempType = typeof(long);
break;
case "ulong":
tempType = typeof(ulong);
break;
// 如果需要支持 nint 和 nuint
// case "nint":
// tempType = typeof(nint);
// break;
// case "nuint":
// tempType = typeof(nuint);
// break;
case "string":
tempType = typeof(string);
break;
default:
tempType = Type.GetType(typeStr);
break;
}
}
if (type == typeof(bool))
{
bool value = bool.Parse(valueStr);
return new BoolConditionResolver
{
Op = ParseBoolOperator(operatorStr),
Value = value,
};
}
else if (type.IsValueType)
{
return GetValueResolver(type, valueStr, operatorStr, parts);
}
else if (type == typeof(string))
{
return new StringConditionResolver
{
Op = ParseStringOperator(operatorStr),
Value = valueStr
};
}
throw new NotSupportedException($"Type {type} is not supported.");
}
public static SereinConditionResolver GetValueResolver(Type valueType, string valueStr, string operatorStr, string[] parts)// where T : struct, IComparable<T>
{
SereinConditionResolver resolver;
if (valueType == typeof(float))
{
resolver = GetValueResolver<float>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(decimal))
{
resolver = GetValueResolver<decimal>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(double))
{
resolver = GetValueResolver<double>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(sbyte))
{
resolver = GetValueResolver<sbyte>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(byte))
{
resolver = GetValueResolver<byte>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(short))
{
resolver = GetValueResolver<short>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(ushort))
{
resolver = GetValueResolver<ushort>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(int))
{
resolver = GetValueResolver<int>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(uint))
{
resolver = GetValueResolver<uint>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(long))
{
resolver = GetValueResolver<long>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(ulong))
{
resolver = GetValueResolver<ulong>(valueStr, operatorStr, parts);
}
#if NET8_0_OR_GREATER
else if (valueType == typeof(nint))
{
resolver = GetValueResolver<nint>(valueStr, operatorStr, parts);
}
else if (valueType == typeof(nuint))
{
resolver = GetValueResolver<nuint>(valueStr, operatorStr, parts);
}
#endif
else
{
throw new ArgumentException("非预期值类型");
}
return resolver;
}
private static ValueTypeConditionResolver<T> GetValueResolver<T>(string valueStr, string operatorStr, string[] parts)
where T :struct, IComparable<T>
{
var op = ParseValueTypeOperator<T>(operatorStr);
if (op == ValueTypeConditionResolver<T>.Operator.InRange || op == ValueTypeConditionResolver<T>.Operator.OutOfRange)
{
var temp = valueStr.Split('-');
var leftNum = string.Empty;
var rightNum = string.Empty;
if (temp.Length < 2 || temp.Length > 4)
{
throw new ArgumentException($"范围无效：{valueStr}。");
}
else if (temp.Length == 2)
{
leftNum = temp[0];
rightNum = temp[1];
}
else if (temp.Length == 3)
{
if (string.IsNullOrEmpty(temp[0])
&& !string.IsNullOrEmpty(temp[1])
&& !string.IsNullOrEmpty(temp[2]))
{
leftNum = "-" + temp[1];
rightNum = temp[2];
}
else
{
throw new ArgumentException($"范围无效：{valueStr}。");
}
}
else if (temp.Length == 4)
{
if (string.IsNullOrEmpty(temp[0])
&& !string.IsNullOrEmpty(temp[1])
&& string.IsNullOrEmpty(temp[2])
&& !string.IsNullOrEmpty(temp[3]))
{
leftNum = "-" + temp[1];
rightNum = temp[3];
}
else
{
throw new ArgumentException($"范围无效：{valueStr}。");
}
}
return new ValueTypeConditionResolver<T>
{
Op = op,
RangeStart = leftNum.ToValueData<T>(),
RangeEnd = rightNum.ToValueData<T>(),
ArithmeticExpression = GetArithmeticExpression(parts[0]),
};
}
else
{
return new ValueTypeConditionResolver<T>
{
Op = op,
Value = valueStr.ToValueData<T>(),
ArithmeticExpression = GetArithmeticExpression(parts[0])
};
}
}
//public static T ValueParse<T>(object value) where T : struct, IComparable<T>
//{
// return (T)ValueParse(typeof(T), value);
//}
//public static object ValueParse(Type type, object value)
//{
// string? valueStr = value.ToString();
// if (string.IsNullOrEmpty(valueStr))
// {
// throw new ArgumentException("value is null");
// }
// object result = type switch
// {
// Type t when t.IsEnum => Enum.Parse(type, valueStr),
// Type t when t == typeof(bool) => bool.Parse(valueStr),
// Type t when t == typeof(float) => float.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(decimal) => decimal.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(double) => double.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(sbyte) => sbyte.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(byte) => byte.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(short) => short.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(ushort) => ushort.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(int) => int.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(uint) => uint.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(long) => long.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(ulong) => ulong.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(nint) => nint.Parse(valueStr, CultureInfo.InvariantCulture),
// Type t when t == typeof(nuint) => nuint.Parse(valueStr, CultureInfo.InvariantCulture),
// _ => throw new ArgumentException("非预期值类型")
// };
// return result;
//}
/// <summary>
/// 数值操作类型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="operatorStr"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
private static ValueTypeConditionResolver<T>.Operator ParseValueTypeOperator<T>(string operatorStr) where T : struct, IComparable<T>
{
if (operatorStr == ">")
{
return ValueTypeConditionResolver<T>.Operator.GreaterThan;
}
else if (operatorStr == "<")
{
return ValueTypeConditionResolver<T>.Operator.LessThan;
}
else if (operatorStr == "==")
{
return ValueTypeConditionResolver<T>.Operator.Equal;
}
else if (operatorStr == ">=" || operatorStr == "≥")
{
return ValueTypeConditionResolver<T>.Operator.GreaterThanOrEqual;
}
else if (operatorStr == "<=" || operatorStr == "≤")
{
return ValueTypeConditionResolver<T>.Operator.LessThanOrEqual;
}
else if (operatorStr == "in")
{
return ValueTypeConditionResolver<T>.Operator.InRange;
}
else if (operatorStr == "!in")
{
return ValueTypeConditionResolver<T>.Operator.OutOfRange;
}
else
{
throw new ArgumentException($"Invalid operator {operatorStr} for value type.");
}
}
/// <summary>
/// 布尔操作类型
/// </summary>
/// <param name="operatorStr"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
private static BoolConditionResolver.Operator ParseBoolOperator(string operatorStr)
{
if (operatorStr == "is" || operatorStr == "==" || operatorStr == "equals")
{
return BoolConditionResolver.Operator.Is;
}
else
{
throw new ArgumentException($"Invalid operator {operatorStr} for bool type.");
}
}
/// <summary>
/// 字符串操作类型
/// </summary>
/// <param name="operatorStr"></param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
private static StringConditionResolver.Operator ParseStringOperator(string operatorStr)
{
operatorStr = operatorStr.ToLower();
if (operatorStr == "c" || operatorStr == "contains")
{
return StringConditionResolver.Operator.Contains;
}
else if (operatorStr == "nc" || operatorStr == "doesnotcontain")
{
return StringConditionResolver.Operator.DoesNotContain;
}
else if (operatorStr == "sw" || operatorStr == "startswith")
{
return StringConditionResolver.Operator.StartsWith;
}
else if (operatorStr == "ew" || operatorStr == "endswith")
{
return StringConditionResolver.Operator.EndsWith;
}
else if (operatorStr == "==" || operatorStr == "equals")
{
return StringConditionResolver.Operator.Equal;
}
else if (operatorStr == "!=" || operatorStr == "notequals")
{
return StringConditionResolver.Operator.NotEqual;
}
else
{
throw new ArgumentException($"Invalid operator {operatorStr} for string type.");
}
}
}
}

12
Library/Utils/SereinExpression/SereinConditionResolver.cs Normal file
View File

@@ -0,0 +1,12 @@
using System.Reflection;
namespace Serein.NodeFlow.Tool.SereinExpression
{
/// <summary>
/// 条件解析抽象类
/// </summary>
public abstract class SereinConditionResolver
{
public abstract bool Evaluate(object obj);
}
}

378
Library/Utils/SereinExpression/SerinExpressionEvaluator.cs Normal file
View File

@@ -0,0 +1,378 @@
using Serein.Library.Utils;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
namespace Serein.NodeFlow.Tool.SereinExpression
{
/// <summary>
/// 使用表达式操作/获取 对象的值
/// 获取值 @get .xx.xxx
/// 设置值 @set .xx.xxx = [data]
/// </summary>
/// <param name="obj">操作的对象</param>
/// <returns></returns>
public class SerinArithmeticExpressionEvaluator<T> where T : struct, IComparable<T>
{
private static readonly DataTable table = new DataTable();
public static T Evaluate(string expression, T inputValue)
{
// 替换占位符@为输入值
expression = expression.Replace("@", inputValue.ToString());
try
{
// 使用 DataTable.Compute 方法计算表达式
var result = table.Compute(expression, string.Empty);
return (T)result;
}
catch
{
throw new ArgumentException("Invalid arithmetic expression.");
}
}
}
public class SerinExpressionEvaluator
{
/// <summary>
///
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="targetObJ">操作对象</param>
/// <param name="isChange">是否改变了对象（Set语法）</param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
/// <exception cref="NotSupportedException"></exception>
public static object Evaluate(string expression, object targetObJ, out bool isChange)
{
//var parts = expression.Split([' '], 2);
var parts = expression.Split(new[] { ' ' }, 2, StringSplitOptions.None);
if (parts.Length != 2)
{
throw new ArgumentException("Invalid expression format.");
}
var operation = parts[0].ToLower();
var operand = parts[1][0] == '.' ? parts[1].Substring(1) : parts[1];
object result;
if (operation == "@num")
{
result = ComputedNumber(targetObJ, operand);
}
else if (operation == "@call")
{
result = InvokeMethod(targetObJ, operand);
}
else if (operation == "@get")
{
result = GetMember(targetObJ, operand);
}
else if (operation == "@set")
{
result = SetMember(targetObJ, operand);
}
else
{
throw new NotSupportedException($"Operation {operation} is not supported.");
}
if(operation == "@set")
{
isChange = true;
}
else
{
isChange = false;
}
return result;
}
private static readonly char[] separator = new char[] { '(', ')' };
private static readonly char[] separatorArray = new char[] { ',' };
/// <summary>
/// 调用目标方法
/// </summary>
/// <param name="target">目标实例</param>
/// <param name="methodCall">方法名称</param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
private static object InvokeMethod(object target, string methodCall)
{
if (target is null) return null;
var methodParts = methodCall.Split(separator, StringSplitOptions.RemoveEmptyEntries);
if (methodParts.Length != 2)
{
throw new ArgumentException("Invalid method call format.");
}
var methodName = methodParts[0];
var parameterList = methodParts[1];
var parameters = parameterList.Split(separatorArray, StringSplitOptions.RemoveEmptyEntries)
.Select(p => p.Trim())
.ToArray();
var method = target.GetType().GetMethod(methodName) ?? throw new ArgumentException($"Method {methodName} not found on target.");
var parameterValues = method.GetParameters()
.Select((p, index) => Convert.ChangeType(parameters[index], p.ParameterType))
.ToArray();
return method.Invoke(target, parameterValues);
}
/// <summary>
/// 获取值
/// </summary>
/// <param name="target">目标实例</param>
/// <param name="memberPath">属性路径</param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
private static object GetMember(object target, string memberPath)
{
if (target is null) return null;
// 分割成员路径，按 '.' 处理多级访问
var members = memberPath.Split('.');
foreach (var member in members)
{
// 检查成员是否包含数组索引，例如 "cars[0]"
var arrayIndexStart = member.IndexOf('[');
if (arrayIndexStart != -1)
{
// 解析数组/集合名与索引部分
var arrayName = member.Substring(0, arrayIndexStart);
var arrayIndexEnd = member.IndexOf(']');
if (arrayIndexEnd == -1 || arrayIndexEnd <= arrayIndexStart + 1)
{
throw new ArgumentException($"Invalid array syntax for member {member}");
}
// 提取数组索引
var indexStr = member.Substring(arrayIndexStart + 1, arrayIndexEnd - arrayIndexStart - 1);
if (!int.TryParse(indexStr, out int index))
{
throw new ArgumentException($"Invalid array index '{indexStr}' for member {member}");
}
// 获取数组或集合对象
var arrayProperty = target?.GetType().GetProperty(arrayName);
if (arrayProperty is null)
{
var arrayField = target?.GetType().GetField(arrayName);
if (arrayField is null)
{
throw new ArgumentException($"Member {arrayName} not found on target.");
}
else
{
target = arrayField.GetValue(target);
}
}
else
{
target = arrayProperty.GetValue(target);
}
// 访问数组或集合中的指定索引
if (target is Array array)
{
if (index < 0 || index >= array.Length)
{
throw new ArgumentException($"Index {index} out of bounds for array {arrayName}");
}
target = array.GetValue(index);
}
else if (target is IList<object> list)
{
if (index < 0 || index >= list.Count)
{
throw new ArgumentException($"Index {index} out of bounds for list {arrayName}");
}
target = list[index];
}
else
{
throw new ArgumentException($"Member {arrayName} is not an array or list.");
}
}
else
{
// 处理非数组情况的属性或字段
var property = target?.GetType().GetProperty(member);
if (property is null)
{
var field = target?.GetType().GetField(member);
if (field is null)
{
throw new ArgumentException($"Member {member} not found on target.");
}
else
{
target = field.GetValue(target);
}
}
else
{
target = property.GetValue(target);
}
}
}
return target;
}
/// <summary>
/// 设置目标的值
/// </summary>
/// <param name="target">目标实例</param>
/// <param name="assignment">属性路径 </param>
/// <returns></returns>
/// <exception cref="ArgumentException"></exception>
private static object SetMember(object target, string assignment)
{
var parts = assignment.Split(new[] { '=' }, 2);
if (parts.Length != 2)
{
throw new ArgumentException("Invalid assignment format.");
}
var memberPath = parts[0].Trim();
var value = parts[1].Trim();
var members = memberPath.Split('.');
for (int i = 0; i < members.Length - 1; i++)
{
var member = members[i];
// 检查是否包含数组索引
var arrayIndexStart = member.IndexOf('[');
if (arrayIndexStart != -1)
{
// 解析数组名和索引
var arrayName = member.Substring(0, arrayIndexStart);
var arrayIndexEnd = member.IndexOf(']');
if (arrayIndexEnd == -1 || arrayIndexEnd <= arrayIndexStart + 1)
{
throw new ArgumentException($"Invalid array syntax for member {member}");
}
var indexStr = member.Substring(arrayIndexStart + 1, arrayIndexEnd - arrayIndexStart - 1);
if (!int.TryParse(indexStr, out int index))
{
throw new ArgumentException($"Invalid array index '{indexStr}' for member {member}");
}
// 获取数组或集合
var arrayProperty = target?.GetType().GetProperty(arrayName);
if (arrayProperty is null)
{
var arrayField = target?.GetType().GetField(arrayName);
if (arrayField is null)
{
throw new ArgumentException($"Member {arrayName} not found on target.");
}
else
{
target = arrayField.GetValue(target);
}
}
else
{
target = arrayProperty.GetValue(target);
}
// 获取目标数组或集合中的指定元素
if (target is Array array)
{
if (index < 0 || index >= array.Length)
{
throw new ArgumentException($"Index {index} out of bounds for array {arrayName}");
}
target = array.GetValue(index);
}
else if (target is IList<object> list)
{
if (index < 0 || index >= list.Count)
{
throw new ArgumentException($"Index {index} out of bounds for list {arrayName}");
}
target = list[index];
}
else
{
throw new ArgumentException($"Member {arrayName} is not an array or list.");
}
}
else
{
// 处理非数组情况的属性或字段
var property = target?.GetType().GetProperty(member);
if (property is null)
{
var field = target?.GetType().GetField(member);
if (field is null)
{
throw new ArgumentException($"Member {member} not found on target.");
}
else
{
target = field.GetValue(target);
}
}
else
{
target = property.GetValue(target);
}
}
}
// 设置值
var lastMember = members.Last();
var lastProperty = target?.GetType().GetProperty(lastMember);
if (lastProperty is null)
{
var lastField = target?.GetType().GetField(lastMember);
if (lastField is null)
{
throw new ArgumentException($"Member {lastMember} not found on target.");
}
else
{
var convertedValue = Convert.ChangeType(value, lastField.FieldType);
lastField.SetValue(target, convertedValue);
}
}
else
{
var convertedValue = Convert.ChangeType(value, lastProperty.PropertyType);
lastProperty.SetValue(target, convertedValue);
}
return target;
}
/// <summary>
/// 计算数学简单表达式
/// </summary>
/// <param name="value"></param>
/// <param name="expression"></param>
/// <returns></returns>
private static decimal ComputedNumber(object value, string expression)
{
return ComputedNumber<decimal>(value, expression);
}
private static T ComputedNumber<T>(object value, string expression) where T : struct, IComparable<T>
{
T result = value.ToConvert<T>();
return SerinArithmeticExpressionEvaluator<T>.Evaluate(expression, result);
}
}
}

3
Library/Utils/SereinIoc.cs
View File

@@ -87,8 +87,7 @@ namespace Serein.Library.Utils
/// <summary>
/// 用于临时实例的创建，不登记到IOC容器中，依赖项注入失败时也不记录。
/// </summary>
/// <param name="controllerType"></param>
/// <param name="parameters"></param>
/// <param name="type"></param>
/// <returns></returns>
public object Instantiate(Type type)
{

2
NodeFlow/Base/NodeModelBaseFunc.cs
View File

@@ -233,7 +233,7 @@ namespace Serein.NodeFlow.Base
try
{
object?[]? args = GetParameters(context, this, md);
result = await dd.Invoke(md.ActingInstance, args);
result = await dd.InvokeAsync(md.ActingInstance, args);
NextOrientation = ConnectionType.IsSucceed;
return result;
}

215
NodeFlow/FlowEnvironment.cs
View File

@@ -8,9 +8,13 @@ using Serein.Library.Utils;
using Serein.NodeFlow.Base;
using Serein.NodeFlow.Model;
using Serein.NodeFlow.Tool;
using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Reflection;
using System.Security.Cryptography;
using System.Xml.Linq;
using static Serein.Library.Utils.ChannelFlowInterrupt;
using static Serein.NodeFlow.FlowStarter;
@@ -180,11 +184,20 @@ namespace Serein.NodeFlow
/// </summary>
public ISereinIOC IOC { get => this; }
/// <summary>
/// Library 与 MethodDetailss的依赖关系
/// </summary>
public ConcurrentDictionary<NodeLibrary, List<MethodDetails>> MethodDetailsOfLibrarys { get; } = [];
/// <summary>
/// 描述所有DLL中NodeAction特性的方法的原始副本
/// 存储已加载的程序集
/// </summary>
public Dictionary<NodeLibrary, List<MethodDetails>> MethodDetailss { get; } = [];
public ConcurrentDictionary<string, NodeLibrary> Librarys { get; } = [];
/// <summary>
/// 存储已加载的方法信息。描述所有DLL中NodeAction特性的方法的原始副本
/// </summary>
public ConcurrentDictionary<string, MethodDetails> MethodDetailss { get; } = [];
#endregion
@@ -194,17 +207,6 @@ namespace Serein.NodeFlow
/// </summary>
public readonly SereinIOC sereinIOC;
/// <summary>
/// 存储加载的程序集路径
/// </summary>
/// <summary>
/// 存储加载的程序集
/// </summary>
public List<NodeLibrary> NodeLibrarys { get; } = [];
/// <summary>
/// 环境加载的节点集合
/// Node Guid - Node Model
@@ -266,7 +268,9 @@ namespace Serein.NodeFlow
#endregion
#region 对外暴露的接口
#region 基础接口
/// <summary>
/// 异步运行
@@ -281,15 +285,22 @@ namespace Serein.NodeFlow
List<MethodDetails> initMethods = [];
List<MethodDetails> loadMethods = [];
List<MethodDetails> exitMethods = [];
foreach(var mds in MethodDetailss.Values)
{
var initMds = mds.Where(it => it.MethodDynamicType == NodeType.Init);
var loadMds = mds.Where(it => it.MethodDynamicType == NodeType.Loading);
var exitMds = mds.Where(it => it.MethodDynamicType == NodeType.Exit);
initMethods.AddRange(initMds);
loadMethods.AddRange(loadMds);
exitMethods.AddRange(exitMds);
}
//foreach(var mds in MethodDetailss.Values)
//{
// var initMds = mds.Where(it => it.MethodDynamicType == NodeType.Init);
// var loadMds = mds.Where(it => it.MethodDynamicType == NodeType.Loading);
// var exitMds = mds.Where(it => it.MethodDynamicType == NodeType.Exit);
// initMethods.AddRange(initMds);
// loadMethods.AddRange(loadMds);
// exitMethods.AddRange(exitMds);
//}
var initMds = MethodDetailss.Values.Where(it => it.MethodDynamicType == NodeType.Init);
var loadMds = MethodDetailss.Values.Where(it => it.MethodDynamicType == NodeType.Loading);
var exitMds = MethodDetailss.Values.Where(it => it.MethodDynamicType == NodeType.Exit);
initMethods.AddRange(initMds);
loadMethods.AddRange(loadMds);
exitMethods.AddRange(exitMds);
this.IOC.Reset(); // 开始运行时清空ioc中注册的实例
this.IOC.CustomRegisterInstance(typeof(IFlowEnvironment).FullName,this);
@@ -354,8 +365,8 @@ namespace Serein.NodeFlow
public void ClearAll()
{
//LoadedAssemblyPaths.Clear();
NodeLibrarys.Clear();
MethodDetailss.Clear();
//NodeLibrarys.Clear();
//MethodDetailss.Clear();
}
@@ -396,8 +407,10 @@ namespace Serein.NodeFlow
}
else
{
TryGetMethodDetails(nodeInfo.MethodName, out MethodDetails? methodDetails); // 加载项目时尝试获取方法信息
if(controlType == NodeControlType.ExpOp || controlType == NodeControlType.ExpOp)
//TryGetMethodDetails(nodeInfo.MethodName, out MethodDetailsInfo? methodDetailsInfo);
MethodDetailss.TryGetValue(nodeInfo.MethodName, out var methodDetails);// 加载项目时尝试获取方法信息
if (controlType == NodeControlType.ExpOp || controlType == NodeControlType.ExpOp)
{
methodDetails ??= new MethodDetails();
}
@@ -495,22 +508,53 @@ namespace Serein.NodeFlow
SetStartNode(project.StartNode);
OnProjectLoaded?.Invoke(new ProjectLoadedEventArgs());
}
/// <summary>
/// 保存项目为项目文件
/// 加载远程项目
/// </summary>
/// <param name="addres">远程项目地址</param>
/// <param name="port">远程项目端口</param>
/// <param name="token">密码</param>
public void LoadRemoteProject(string addres, int port, string token)
{
// -- 第1种，直接从远程环境复制所有dll信息，项目信息，在本地打开？（安全问题）
// 第2种，WebSocket连接到远程环境，实时接收远程环境的响应？
Console.WriteLine($"准备连接：{addres}:{port},{token}");
// bool success = false;
//try
//{
// TcpClient tcpClient = new TcpClient();
// var result = tcpClient.BeginConnect(addres, port, null, null);
// success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(3));
//}
//catch (Exception ex)
//{
//}
//if (!success)
//{
// Console.WriteLine($"无法连接远程:{addres}:{port}");
//}
}
/// <summary>
/// 序列化当前项目的依赖信息、节点信息
/// </summary>
/// <returns></returns>
public SereinProjectData SaveProject()
public SereinProjectData GetProjectInfo()
{
var projectData = new SereinProjectData()
{
Librarys = NodeLibrarys.Select(assemblies => assemblies.Assembly.ToLibrary()).ToArray(),
Librarys = Librarys.Values.Select(assemblies => assemblies.Assembly.ToLibrary()).ToArray(),
Nodes = Nodes.Values.Select(node => node.ToInfo()).Where(info => info is not null).ToArray(),
StartNode = Nodes.Values.FirstOrDefault(it => it.IsStart)?.Guid,
};
return projectData;
}
/// <summary>
/// 从文件路径中加载DLL
/// </summary>
@@ -521,9 +565,14 @@ namespace Serein.NodeFlow
LoadDllNodeInfo(dllPath);
}
/// <summary>
/// 移除DLL
/// </summary>
/// <param name="assemblyFullName"></param>
/// <returns></returns>
public bool RemoteDll(string assemblyFullName)
{
var library = NodeLibrarys.FirstOrDefault(nl => assemblyFullName.Equals(nl.Assembly.FullName));
var library = Librarys.Values.FirstOrDefault(nl => assemblyFullName.Equals(nl.Assembly.FullName));
if(library is null)
{
return false;
@@ -535,12 +584,14 @@ namespace Serein.NodeFlow
.ToDictionary(
key => key.Key,
group => group.Count());
if(Nodes.Count == 0)
{
return true; // 当前无节点，可以直接删除
}
if (MethodDetailss.TryGetValue(library,out var mds)) // 存在方法
if (MethodDetailsOfLibrarys.TryGetValue(library,out var mds)) // 存在方法
{
foreach(var md in mds)
{
@@ -548,12 +599,17 @@ namespace Serein.NodeFlow
{
if (count > 0)
{
return false; // 创建过相关的节点
return false; // 创建过相关的节点，无法移除
}
}
}
MethodDetailss.Remove(library);
return true; // 没有创建相关的节点
// 开始移除相关信息
foreach (var md in mds)
{
MethodDetailss.TryRemove(md.MethodName, out _);
}
MethodDetailsOfLibrarys.TryRemove(library, out _);
return true;
}
else
{
@@ -567,9 +623,14 @@ namespace Serein.NodeFlow
/// </summary>
/// <param name="nodeControlType"></param>
/// <param name="position"></param>
/// <param name="methodDetails"></param>
public void CreateNode(NodeControlType nodeControlType, Position position, MethodDetails? methodDetails = null)
/// <param name="methodDetailsInfo">如果是表达式节点条件节点，该项为null</param>
public void CreateNode(NodeControlType nodeControlType, Position position, MethodDetailsInfo? methodDetailsInfo = null)
{
MethodDetails? methodDetails = null;
if (methodDetailsInfo != null &&!MethodDetailss.TryGetValue(methodDetailsInfo.MethodName, out methodDetails))
{
return;
}
var nodeModel = CreateNode(nodeControlType, methodDetails);
TryAddNode(nodeModel);
@@ -646,8 +707,8 @@ namespace Serein.NodeFlow
/// <summary>
/// 连接节点
/// </summary>
/// <param name="fromNode">起始节点</param>
/// <param name="toNode">目标节点</param>
/// <param name="fromNodeGuid">起始节点</param>
/// <param name="toNodeGuid">目标节点</param>
/// <param name="connectionType">连接关系</param>
public void ConnectNode(string fromNodeGuid, string toNodeGuid, ConnectionType connectionType)
{
@@ -684,13 +745,13 @@ namespace Serein.NodeFlow
/// <summary>
/// 获取方法描述
/// </summary>
public bool TryGetMethodDetails(string name, out MethodDetails? md)
public bool TryGetMethodDetailsInfo(string name, out MethodDetailsInfo? md)
{
if (!string.IsNullOrEmpty(name))
{
foreach(var mds in MethodDetailss.Values)
foreach(var t_md in MethodDetailss.Values)
{
md = mds.FirstOrDefault(it => it.MethodName == name);
md = t_md.ToInfo();
if(md != null)
{
return true;
@@ -706,6 +767,16 @@ namespace Serein.NodeFlow
}
}
/// <summary>
/// <para>通过方法名称获取对应的Emit委托</para>
/// <para>方法无入参时需要传入空数组，void方法自动返回null</para>
/// <para>普通方法：Func&lt;object,object[],object&gt;</para>
/// <para>异步方法：Func&lt;object,object[],Task&gt;</para>
/// <para>异步有返回值方法：Func&lt;object,object[],Task&lt;object&gt;&gt;</para>
/// </summary>
/// <param name="methodName"></param>
/// <param name="delegateDetails"></param>
/// <returns></returns>
public bool TryGetDelegateDetails(string methodName, out DelegateDetails? delegateDetails)
{
@@ -875,7 +946,8 @@ namespace Serein.NodeFlow
}
}
} /// <summary>
}
/// <summary>
/// 关闭全局触发器
/// </summary>
/// <param name="nodeGuid"></param>
@@ -888,13 +960,48 @@ namespace Serein.NodeFlow
flowStarter.TerminateGlobalFlipflopRuning(flipflopNode);
}
}
/// <summary>
/// 环境执行中断
/// </summary>
/// <returns></returns>
public Task<CancelType> GetOrCreateGlobalInterruptAsync()
{
IsGlobalInterrupt = true;
return ChannelFlowInterrupt.GetOrCreateChannelAsync(this.EnvName);
}
/// <summary>
/// 获取当前环境信息（远程连接）
/// </summary>
/// <returns></returns>
public object GetEnvInfo()
{
Dictionary<NodeLibrary, List<MethodDetailsInfo>> LibraryMds = [];
foreach (var mdskv in this.MethodDetailsOfLibrarys)
{
var library = mdskv.Key;
var mds = mdskv.Value;
foreach (var md in mds)
{
if (!LibraryMds.TryGetValue(library, out var t_mds))
{
t_mds = new List<MethodDetailsInfo>();
LibraryMds[library] = t_mds;
}
var mdInfo = md.ToInfo();
mdInfo.LibraryName = library.Assembly.GetName().FullName;
t_mds.Add(mdInfo);
}
}
var project = this.GetProjectInfo();
return new
{
project = project,
envNode = LibraryMds.Values,
};
}
/// <summary>
/// Guid 转 NodeModel
@@ -902,7 +1009,7 @@ namespace Serein.NodeFlow
/// <param name="nodeGuid">节点Guid</param>
/// <returns>节点Model</returns>
/// <exception cref="ArgumentNullException">无法获取节点、Guid/节点为null时报错</exception>
public NodeModelBase? GuidToModel(string nodeGuid)
private NodeModelBase? GuidToModel(string nodeGuid)
{
if (string.IsNullOrEmpty(nodeGuid))
{
@@ -931,10 +1038,15 @@ namespace Serein.NodeFlow
(var nodeLibrary, var registerTypes, var mdlist) = LoadAssembly(dllPath);
if (nodeLibrary is not null && mdlist.Count > 0)
{
MethodDetailss.Add(nodeLibrary, mdlist);
NodeLibrarys.Add(nodeLibrary);
Librarys.TryAdd(nodeLibrary.Name, nodeLibrary);
MethodDetailsOfLibrarys.TryAdd(nodeLibrary, mdlist);
foreach(var md in mdlist)
{
MethodDetailss.TryAdd(md.MethodName, md);
}
foreach(var kv in registerTypes)
foreach (var kv in registerTypes)
{
if (!AutoRegisterTypes.TryGetValue(kv.Key, out var types))
{
@@ -943,8 +1055,8 @@ namespace Serein.NodeFlow
}
types.AddRange(kv.Value);
}
OnDllLoad?.Invoke(new LoadDllEventArgs(nodeLibrary, mdlist)); // 通知UI创建dll面板显示
var mdInfo = mdlist.Select(md => md.ToInfo()).ToList(); // 转换成方法信息
OnDllLoad?.Invoke(new LoadDllEventArgs(nodeLibrary, mdInfo)); // 通知UI创建dll面板显示
}
}
@@ -1046,6 +1158,7 @@ namespace Serein.NodeFlow
var nodeLibrary = new NodeLibrary
{
Name = assembly.GetName().FullName,
Assembly = assembly,
Path = dllPath,
};

18
NodeFlow/FlowStarter.cs
View File

@@ -24,15 +24,7 @@ namespace Serein.NodeFlow
/// </summary>
public class FlowStarter
{
/// <summary>
/// 全局触发器CTS
/// </summary>
public const string FlipFlopCtsName = "<>.FlowFlipFlopCts";
/// <summary>
/// 流程运行CTS
/// </summary>
public const string FlowRungCtsName = "<>.FlowRungCtsName";
public FlowStarter()
{
}
@@ -209,7 +201,7 @@ namespace Serein.NodeFlow
{
throw new Exception("不存在对应委托");
}
await dd.Invoke(md.ActingInstance, [Context]);
await dd.InvokeAsync(md.ActingInstance, [Context]);
//((Func<object, object[], object>)dd.EmitDelegate).Invoke(md.ActingInstance, [Context]);
}
Context.Env.IOC.Build(); // 绑定初始化时注册的类型
@@ -230,7 +222,7 @@ namespace Serein.NodeFlow
{
throw new Exception("不存在对应委托");
}
await dd.Invoke(md.ActingInstance, [Context]);
await dd.InvokeAsync(md.ActingInstance, [Context]);
//((Action<object, object?[]?>)del).Invoke(md.ActingInstance, [Context]);
//((Func<object, object[], object>)dd.EmitDelegate).Invoke(md.ActingInstance, [Context]);
}
@@ -250,7 +242,7 @@ namespace Serein.NodeFlow
{
throw new Exception("不存在对应委托");
}
await dd.Invoke(md.ActingInstance, [Context]);
await dd.InvokeAsync(md.ActingInstance, [Context]);
//((Func<object, object[], object>)dd.EmitDelegate).Invoke(md.ActingInstance, [Context]);
}
@@ -277,7 +269,7 @@ namespace Serein.NodeFlow
env.FlipFlopState = RunState.Running;
// 如果存在需要启动的触发器，则开始启动
_flipFlopCts = new CancellationTokenSource();
env.IOC.CustomRegisterInstance(FlipFlopCtsName, _flipFlopCts,false);
env.IOC.CustomRegisterInstance(NodeStaticConfig.FlipFlopCtsName, _flipFlopCts,false);
// 使用 TaskCompletionSource 创建未启动的触发器任务
var tasks = flipflopNodes.Select(async node =>

2
NodeFlow/Model/CompositeActionNode.cs
View File

@@ -26,7 +26,7 @@ namespace Serein.NodeFlow.Model
throw new NotImplementedException("动作区域暂未实现");
}
internal override Parameterdata[] GetParameterdatas()
public override Parameterdata[] GetParameterdatas()
{
return [];
}

4
NodeFlow/Model/CompositeConditionNode.cs
View File

@@ -37,7 +37,7 @@ namespace Serein.NodeFlow.Model
break;
}
}
return Task.FromResult(PreviousNode?.GetFlowData()); // 条件区域透传上一节点的数据
return Task.FromResult( PreviousNode?.GetFlowData()); // 条件区域透传上一节点的数据
}
@@ -57,7 +57,7 @@ namespace Serein.NodeFlow.Model
}
}
internal override Parameterdata[] GetParameterdatas()
public override Parameterdata[] GetParameterdatas()
{
return [];
}

2
NodeFlow/Model/SingleActionNode.cs
View File

@@ -10,7 +10,7 @@ namespace Serein.NodeFlow.Model
public class SingleActionNode : NodeModelBase
{
internal override Parameterdata[] GetParameterdatas()
public override Parameterdata[] GetParameterdatas()
{
if (base.MethodDetails.ParameterDetailss.Length > 0)
{

4
NodeFlow/Model/SingleConditionNode.cs
View File

@@ -71,7 +71,7 @@ namespace Serein.NodeFlow.Model
return Task.FromResult(result);
}
internal override Parameterdata[] GetParameterdatas()
public override Parameterdata[] GetParameterdatas()
{
var value = CustomData switch
{
@@ -90,8 +90,6 @@ namespace Serein.NodeFlow.Model
}];
}
public override NodeModelBase LoadInfo(NodeInfo nodeInfo)
{
var node = this;

2
NodeFlow/Model/SingleExpOpNode.cs
View File

@@ -49,7 +49,7 @@ namespace Serein.NodeFlow.Model
}
internal override Parameterdata[] GetParameterdatas()
public override Parameterdata[] GetParameterdatas()
{
return [new Parameterdata{ Expression = Expression}];
}

4
NodeFlow/Model/SingleFlipflopNode.cs
View File

@@ -42,7 +42,7 @@ namespace Serein.NodeFlow.Model
try
{
var args = GetParameters(context, this, md);
var result = await dd.Invoke(md.ActingInstance, args);
var result = await dd.InvokeAsync(md.ActingInstance, args);
dynamic flipflopContext = result;
FlipflopStateType flipflopStateType = flipflopContext.State;
NextOrientation = flipflopStateType.ToContentType();
@@ -80,7 +80,7 @@ namespace Serein.NodeFlow.Model
{
return context.Value; // dynamic 会在运行时处理类型
}
internal override Parameterdata[] GetParameterdatas()
public override Parameterdata[] GetParameterdatas()
{
if (base.MethodDetails.ParameterDetailss.Length > 0)
{

3
NodeFlow/MoveNodeData.cs
View File

@@ -11,6 +11,7 @@ namespace Serein.NodeFlow
public class MoveNodeData
{
public NodeControlType NodeControlType { get; set; }
public MethodDetails MethodDetails { get; set; }
// public MethodDetails MethodDetails { get; set; }
public MethodDetailsInfo MethodDetailsInfo { get; set; }
}
}

3
NodeFlow/NodeStaticConfig.cs
View File

@@ -1,5 +1,4 @@
using Serein.Library.Api;
using Serein.Library.Enums;
using Serein.Library.Enums;
using System;
using System.Collections.Generic;
using System.Linq;

7
NodeFlow/Serein.NodeFlow.csproj
View File

@@ -19,18 +19,25 @@
</PropertyGroup>
<ItemGroup>
<Compile Remove="Base\**" />
<Compile Remove="bin\**" />
<Compile Remove="SerinExpression\**" />
<Compile Remove="Tool\SereinExpression\**" />
<EmbeddedResource Remove="Base\**" />
<EmbeddedResource Remove="bin\**" />
<EmbeddedResource Remove="SerinExpression\**" />
<EmbeddedResource Remove="Tool\SereinExpression\**" />
<None Remove="Base\**" />
<None Remove="bin\**" />
<None Remove="SerinExpression\**" />
<None Remove="Tool\SereinExpression\**" />
</ItemGroup>
<ItemGroup>
<Compile Remove="ConnectionType.cs" />
<Compile Remove="DynamicContext.cs" />
<Compile Remove="MethodDetails.cs" />
<Compile Remove="NodeStaticConfig.cs" />
<Compile Remove="Tool\Attribute.cs" />
<Compile Remove="Tool\DynamicTool.cs" />
<Compile Remove="Tool\ExpressionHelper.cs" />

51
WorkBench/MainWindow.xaml
View File

@@ -10,7 +10,6 @@
Loaded="Window_Loaded"
ContentRendered="Window_ContentRendered"
PreviewKeyDown="Window_PreviewKeyDown"
PreviewTextInput="Window_PreviewTextInput"
Closing="Window_Closing">
<Window.Resources>
@@ -36,40 +35,56 @@
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<StackPanel Grid.Row="0" Grid.ColumnSpan="5" Background="#F5F5F5" Orientation="Horizontal" >
<Button x:Name="ButtonDebugRun" Content="运行" Width="100" Margin="10" Click="ButtonDebugRun_Click"></Button>
<Button x:Name="ButtonDebugFlipflopNode" Content="结束" Width="100" Margin="10" Click="ButtonDebugFlipflopNode_Click"></Button>
<Button x:Name="ButtonStartFlowInSelectNode" Content="从选定节点开始" Width="100" Margin="10" Click="ButtonStartFlowInSelectNode_Click"></Button>
<Button x:Name="ButtonResetCanvas" Content="重置画布" Width="100" Margin="10" Click="ButtonResetCanvas_Click"></Button>
<Button x:Name="ButtonTestExpObj" Content="测试对象表达式" Width="100" Margin="10" Click="ButtonTestExpObj_Click"></Button>
</StackPanel>
<Menu DockPanel.Dock="Top" Grid.Row="0" Height="20">
<MenuItem Header="文件">
<!--菜单项为MenuItem，文字使用属性 Header-->
<MenuItem Header="保存项目" Click="ButtonSaveFile_Click" ></MenuItem>
<MenuItem Header="打开本地文件" Click="OpenLocalProject_Click"></MenuItem>
<MenuItem Header="连接远程环境" Click="OpenRemoteProject_Click"></MenuItem>
</MenuItem>
<MenuItem Header="调试">
<MenuItem Header="运行（从起始节点）" Click="ButtonDebugRun_Click"></MenuItem>
<MenuItem Header="运行（从选定节点）" Click="ButtonDebugFlipflopNode_Click"></MenuItem>
<MenuItem Header="结束流程" Click="ButtonDebugFlipflopNode_Click"></MenuItem>
</MenuItem>
<MenuItem Header="视图">
<MenuItem Header="输出窗口" Click="ButtonOpenConsoleOutWindow_Click"></MenuItem>
<MenuItem Header="重置画布" Click="ButtonResetCanvas_Click"></MenuItem>
</MenuItem>
<!--<MenuItem Header="说明"></MenuItem>-->
</Menu>
<DockPanel Grid.Row="1" Grid.Column="0" Background="#F5F5F5">
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="40"></RowDefinition>
<RowDefinition Height="Auto"></RowDefinition>
<RowDefinition Height="2*"></RowDefinition>
<RowDefinition Height="auto"></RowDefinition>
<RowDefinition Height="*"></RowDefinition>
<!--<RowDefinition Height="3"></RowDefinition>-->
<!--<RowDefinition Height="3*"></RowDefinition>-->
</Grid.RowDefinitions>
<Grid Margin="2,2,1,5" Grid.Row="0" >
<Button Grid.Row="0" Content="保存项目" Click="ButtonSaveFile_Click" HorizontalAlignment="Left" Margin="5,5,5,5"/>
<!--<Button Grid.Row="0" Content="卸载清空" Click="UnloadAllButton_Click" HorizontalAlignment="Right" Margin="5,5,5,5"/>-->
</Grid>
<!--<Grid Margin="2,2,1,5" Grid.Row="0" >
<Grid.ColumnDefinitions>
<ColumnDefinition Width="auto"/>
<ColumnDefinition Width="auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Button Grid.Column="0" Content="保存项目" Click="ButtonSaveFile_Click" HorizontalAlignment="Left" Margin="5,5,5,5"/>
--><!--<Button Grid.Column="1" Content="加载项目" Click="ButtonLoadProjectFile_Click" HorizontalAlignment="Left" Margin="5,5,5,5"/>-->
<!--<Button Grid.Row="0" Content="卸载清空" Click="UnloadAllButton_Click" HorizontalAlignment="Right" Margin="5,5,5,5"/>--><!--
</Grid>-->
<ScrollViewer Grid.Row="1" HorizontalScrollBarVisibility="Auto">
<ScrollViewer Grid.Row="0" HorizontalScrollBarVisibility="Auto">
<StackPanel Orientation="Horizontal">
<nodeView:ExpOpNodeControl x:Name="ExpOpNodeControl" Margin="10" AllowDrop="True" PreviewMouseMove="BaseNodeControl_PreviewMouseMove"/>
<nodeView:ConditionNodeControl x:Name="ConditionNodeControl" Margin="10" AllowDrop="True" PreviewMouseMove="BaseNodeControl_PreviewMouseMove"/>
<nodeView:ConditionRegionControl x:Name="ConditionRegionControl" Margin="10" AllowDrop="True" PreviewMouseMove="BaseNodeControl_PreviewMouseMove"/>
</StackPanel>
</ScrollViewer>
<ScrollViewer Grid.Row="2" VerticalScrollBarVisibility="Auto" MaxHeight="400" Grid.RowSpan="2">
<ScrollViewer Grid.Row="1" VerticalScrollBarVisibility="Auto" MaxHeight="400" Grid.RowSpan="2">
<StackPanel x:Name="DllStackPanel" Margin="5"/>
</ScrollViewer>
<!--<GridSplitter Grid.Row="3" Height="5" HorizontalAlignment="Stretch" VerticalAlignment="Center" ResizeBehavior="PreviousAndNext" Background="Gray"/>-->

216
WorkBench/MainWindow.xaml.cs
View File

@@ -255,6 +255,7 @@ namespace Serein.WorkBench
#endregion
#region 运行环境事件
/// <summary>
/// 加载完成
/// </summary>
@@ -281,19 +282,19 @@ namespace Serein.WorkBench
{
this.Dispatcher.Invoke(() => {
NodeLibrary nodeLibrary = eventArgs.NodeLibrary;
List<MethodDetails> methodDetailss = eventArgs.MethodDetailss;
List<MethodDetailsInfo> methodDetailss = eventArgs.MethodDetailss;
var dllControl = new DllControl(nodeLibrary);
foreach (var methodDetails in methodDetailss)
foreach (var methodDetailsInfo in methodDetailss)
{
switch (methodDetails.MethodDynamicType)
switch (methodDetailsInfo.NodeType)
{
case Library.Enums.NodeType.Action:
dllControl.AddAction(methodDetails.Clone()); // 添加动作类型到控件
dllControl.AddAction(methodDetailsInfo); // 添加动作类型到控件
break;
case Library.Enums.NodeType.Flipflop:
dllControl.AddFlipflop(methodDetails.Clone()); // 添加触发器方法到控件
dllControl.AddFlipflop(methodDetailsInfo); // 添加触发器方法到控件
break;
}
}
@@ -320,20 +321,13 @@ namespace Serein.WorkBench
/// <summary>
/// 节点连接关系变更
/// </summary>
/// <param name="fromNodeGuid"></param>
/// <param name="toNodeGuid"></param>
/// <param name="connectionType"></param>
/// <param name="eventArgs"></param>
private void FlowEnvironment_NodeConnectChangeEvemt(NodeConnectChangeEventArgs eventArgs)
{
string fromNodeGuid = eventArgs.FromNodeGuid;
string toNodeGuid = eventArgs.ToNodeGuid;
NodeControlBase? fromNode = GuidToControl(fromNodeGuid);
NodeControlBase? toNode = GuidToControl(toNodeGuid);
if(fromNode != null && toNode != null)
{
}
else
if (!TryGetControl(fromNodeGuid, out var fromNode)
|| !TryGetControl(toNodeGuid, out var toNode))
{
return;
}
@@ -394,8 +388,6 @@ namespace Serein.WorkBench
}
/// <summary>
/// 节点移除事件
/// </summary>
@@ -403,7 +395,11 @@ namespace Serein.WorkBench
private void FlowEnvironment_NodeRemoteEvent(NodeRemoteEventArgs eventArgs)
{
var nodeGuid = eventArgs.NodeGuid;
NodeControlBase? nodeControl = GuidToControl(nodeGuid);
if (!TryGetControl(nodeGuid, out var nodeControl))
{
return;
}
if (nodeControl is null) return;
if (selectNodeControls.Count > 0)
{
@@ -494,7 +490,6 @@ namespace Serein.WorkBench
});
}
/// <summary>
/// 设置了流程起始控件
/// </summary>
@@ -506,12 +501,10 @@ namespace Serein.WorkBench
{
string oldNodeGuid = eventArgs.OldNodeGuid;
string newNodeGuid = eventArgs.NewNodeGuid;
NodeControlBase? newStartNodeControl = GuidToControl(newNodeGuid);
if (newStartNodeControl is null) return;
if (!TryGetControl(newNodeGuid, out var newStartNodeControl)) return;
if (!string.IsNullOrEmpty(oldNodeGuid))
{
NodeControlBase? oldStartNodeControl = GuidToControl(oldNodeGuid);
if (oldStartNodeControl is null) return;
if (!TryGetControl(oldNodeGuid, out var oldStartNodeControl)) return;
oldStartNodeControl.BorderBrush = Brushes.Black;
oldStartNodeControl.BorderThickness = new Thickness(0);
}
@@ -527,7 +520,6 @@ namespace Serein.WorkBench
}
/// <summary>
/// 被监视的对象发生改变
/// </summary>
@@ -564,7 +556,6 @@ namespace Serein.WorkBench
}
/// <summary>
/// 节点中断状态改变。
/// </summary>
@@ -572,8 +563,8 @@ namespace Serein.WorkBench
private void FlowEnvironment_OnNodeInterruptStateChange(NodeInterruptStateChangeEventArgs eventArgs)
{
string nodeGuid = eventArgs.NodeGuid;
NodeControlBase? nodeControl = GuidToControl(nodeGuid);
if (nodeControl is null) return;
if (!TryGetControl(nodeGuid, out var nodeControl)) return;
if (eventArgs.Class == InterruptClass.None)
{
nodeControl.ViewModel.IsInterrupt = false;
@@ -610,8 +601,7 @@ namespace Serein.WorkBench
private void FlowEnvironment_OnInterruptTrigger(InterruptTriggerEventArgs eventArgs)
{
string nodeGuid = eventArgs.NodeGuid;
NodeControlBase? nodeControl = GuidToControl(nodeGuid);
if (nodeControl is null) return;
if (!TryGetControl(nodeGuid, out var nodeControl)) return;
if(eventArgs.Type == InterruptTriggerEventArgs.InterruptTriggerType.Exp)
{
Console.WriteLine($"表达式触发了中断:{eventArgs.Expression}");
@@ -639,8 +629,7 @@ namespace Serein.WorkBench
/// <exception cref="NotImplementedException"></exception>
private void FlowEnvironment_OnNodeLocate(NodeLocatedEventArgs eventArgs)
{
NodeControlBase? nodeControl = GuidToControl(eventArgs.NodeGuid);
if (nodeControl is null) return;
if (!TryGetControl(eventArgs.NodeGuid, out var nodeControl)) return;
//scaleTransform.ScaleX = 1;
//scaleTransform.ScaleY = 1;
// 获取控件在 FlowChartCanvas 上的相对位置
@@ -669,7 +658,6 @@ namespace Serein.WorkBench
//if (!isInView)
//{
//}
// 计算平移偏移量，使得控件在可视区域的中心
double translateX = scaledCenterX - FlowChartStackGrid.ActualWidth / 2;
@@ -688,6 +676,7 @@ namespace Serein.WorkBench
ElasticAnimation(nodeControl, translateTransform, 4,1,0.5);
}
/// <summary>
/// 控件抖动
/// 来源：https://www.cnblogs.com/RedSky/p/17705411.html
@@ -695,6 +684,7 @@ namespace Serein.WorkBench
/// （……太好用了）
/// </summary>
/// <param name="translate"></param>
/// <param name="nodeControl">需要抖动的控件</param>
/// <param name="power">抖动第一下偏移量</param>
/// <param name="range">减弱幅度（小于等于power，大于0）</param>
/// <param name="speed">持续系数(大于0)，越大时间越长，</param>
@@ -724,26 +714,28 @@ namespace Serein.WorkBench
/// <summary>
/// Guid 转 NodeControl
/// </summary>
/// <param name="nodeGuid">节点Guid</param>
/// <returns>节点Model</returns>
/// <exception cref="ArgumentNullException">无法获取节点、Guid/节点为null时报错</exception>
private NodeControlBase? GuidToControl(string nodeGuid)
/// <param name="nodeGuid"></param>
/// <param name="nodeControl"></param>
/// <returns></returns>
private bool TryGetControl(string nodeGuid,out NodeControlBase nodeControl)
{
if (string.IsNullOrEmpty(nodeGuid))
{
return null;
throw new ArgumentNullException("not contains - Guid没有对应节点:" + (nodeGuid));
nodeControl = null;
return false;
}
if (!NodeControls.TryGetValue(nodeGuid, out NodeControlBase? nodeControl) || nodeControl is null)
if (!NodeControls.TryGetValue(nodeGuid, out nodeControl))
{
return null;
throw new ArgumentNullException("null - Guid存在对应节点,但节点为null:" + (nodeGuid));
nodeControl = null;
return false;
}
return nodeControl;
if(nodeControl is null)
{
return false;
}
return true;
}
#endregion
#region 加载项目文件后触发事件相关方法
@@ -906,7 +898,7 @@ namespace Serein.WorkBench
#endregion
if (nodeControl?.ViewModel?.Node?.MethodDetails?.ReturnType is Type returnType && returnType != typeof(void))
if (nodeControl.ViewModel?.Node?.MethodDetails?.ReturnType is Type returnType && returnType != typeof(void))
{
contextMenu.Items.Add(CreateMenuItem("查看返回类型", (s, e) =>
{
@@ -1180,7 +1172,7 @@ namespace Serein.WorkBench
if (e.Data.GetData(MouseNodeType.CreateDllNodeInCanvas) is MoveNodeData nodeData)
{
// 创建DLL文件的节点对象
FlowEnvironment.CreateNode(nodeData.NodeControlType, position, nodeData.MethodDetails);
FlowEnvironment.CreateNode(nodeData.NodeControlType, position, nodeData.MethodDetailsInfo);
}
}
else if (e.Data.GetDataPresent(MouseNodeType.CreateBaseNodeInCanvas))
@@ -1208,8 +1200,7 @@ namespace Serein.WorkBench
/// 尝试将节点放置在区域中
/// </summary>
/// <param name="nodeControl"></param>
/// <param name="dropPosition"></param>
/// <param name="e"></param>
/// <param name="position"></param>
/// <returns></returns>
private bool TryPlaceNodeInRegion(NodeControlBase nodeControl, Position position)
{
@@ -1764,6 +1755,7 @@ namespace Serein.WorkBench
/// <param name="e"></param>
private void FlowChartCanvas_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
Console.WriteLine(1);
if (!IsSelectControl)
{
// 进入选取状态
@@ -2335,32 +2327,8 @@ namespace Serein.WorkBench
#endregion
/// <summary>
/// 卸载DLL文件，清空当前项目
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void UnloadAllButton_Click(object sender, RoutedEventArgs e)
{
FlowEnvironment.ClearAll();
}
/// <summary>
/// 卸载DLL文件，清空当前项目
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void UnloadAllAssemblies()
{
DllStackPanel.Children.Clear();
FlowChartCanvas.Children.Clear();
Connections.Clear();
NodeControls.Clear();
currentLine = null;
startConnectNodeControl = null;
MessageBox.Show("所有DLL已卸载。", "信息", MessageBoxButton.OK, MessageBoxImage.Information);
}
#region 顶部菜单栏 - 调试功能区
/// <summary>
/// 运行测试
@@ -2394,7 +2362,7 @@ namespace Serein.WorkBench
/// <param name="e"></param>
private async void ButtonStartFlowInSelectNode_Click(object sender, RoutedEventArgs e)
{
if(selectNodeControls.Count == 0)
if (selectNodeControls.Count == 0)
{
Console.WriteLine("请至少选择一个节点");
}
@@ -2409,6 +2377,14 @@ namespace Serein.WorkBench
}
#endregion
#region 顶部菜单栏 - 项目文件菜单
/// <summary>
/// 保存为项目文件
/// </summary>
@@ -2416,7 +2392,7 @@ namespace Serein.WorkBench
/// <param name="e"></param>
private void ButtonSaveFile_Click(object sender, RoutedEventArgs e)
{
var projectData = FlowEnvironment.SaveProject();
var projectData = FlowEnvironment.GetProjectInfo();
projectData.Basic = new Basic
{
@@ -2432,10 +2408,10 @@ namespace Serein.WorkBench
Versions = "1",
};
foreach(var node in projectData.Nodes)
foreach (var node in projectData.Nodes)
{
if(NodeControls.TryGetValue(node.Guid,out var nodeControl))
if (NodeControls.TryGetValue(node.Guid, out var nodeControl))
{
Point positionRelativeToParent = nodeControl.TranslatePoint(new Point(0, 0), FlowChartCanvas);
node.Position = new Position(positionRelativeToParent.X, positionRelativeToParent.Y);
@@ -2481,7 +2457,7 @@ namespace Serein.WorkBench
}
JObject projectJsonData = JObject.FromObject(projectData);
savaProjectFile?.Invoke(savePath, projectJsonData.ToString());
savaProjectFile?.Invoke(savePath, projectJsonData.ToString());
}
public static bool SaveContentToFile(out string savePath, out Action<string, string>? savaProjectFile)
{
@@ -2499,7 +2475,7 @@ namespace Serein.WorkBench
// 如果用户选择了文件并点击了保存按钮
if (result == true)
{
savePath = saveFileDialog.FileName;
savePath = saveFileDialog.FileName;
savaProjectFile = File.WriteAllText;
return true;
}
@@ -2507,18 +2483,57 @@ namespace Serein.WorkBench
savaProjectFile = null;
return false;
}
public static string GetRelativePath(string baseDirectory, string fullPath)
{
Uri baseUri = new(baseDirectory + System.IO.Path.DirectorySeparatorChar);
Uri fullUri = new(fullPath);
Uri relativeUri = baseUri.MakeRelativeUri(fullUri);
return Uri.UnescapeDataString(relativeUri.ToString().Replace('/', System.IO.Path.DirectorySeparatorChar));
}
private void Window_PreviewTextInput(object sender, TextCompositionEventArgs e)
/// <summary>
/// 打开本地项目文件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OpenLocalProject_Click(object sender, RoutedEventArgs e)
{
}
/// <summary>
/// 连接远程运行环境
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OpenRemoteProject_Click(object sender, RoutedEventArgs e)
{
var windowEnvRemoteLoginView = new WindowEnvRemoteLoginView((addres,port,token) =>
{
this.FlowEnvironment.LoadRemoteProject(addres, port, token);
});
windowEnvRemoteLoginView.Show();
}
#endregion
#region 顶部菜单栏 - 视图管理
/// <summary>
/// 重置画布
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ButtonResetCanvas_Click(object sender, RoutedEventArgs e)
{
translateTransform.X = 0;
translateTransform.Y = 0;
scaleTransform.ScaleX = 1;
scaleTransform.ScaleY = 1;
}
private void ButtonOpenConsoleOutWindow_Click(object sender, RoutedEventArgs e)
{
logWindow?.Show();
}
#endregion
/// <summary>
/// 按键监听。esc取消操作
/// </summary>
@@ -2596,16 +2611,29 @@ namespace Serein.WorkBench
data = SerinExpressionEvaluator.Evaluate(exp,result!, out isChange);
Console.WriteLine($"{exp} => {data}");
}
/// <summary>
/// 重置画布
/// 卸载DLL文件，清空当前项目
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ButtonResetCanvas_Click(object sender, RoutedEventArgs e)
private void UnloadAllButton_Click(object sender, RoutedEventArgs e)
{
translateTransform.X = 0;
translateTransform.Y = 0;
FlowEnvironment.ClearAll();
}
/// <summary>
/// 卸载DLL文件，清空当前项目
/// </summary>
private void UnloadAllAssemblies()
{
DllStackPanel.Children.Clear();
FlowChartCanvas.Children.Clear();
Connections.Clear();
NodeControls.Clear();
currentLine = null;
startConnectNodeControl = null;
MessageBox.Show("所有DLL已卸载。", "信息", MessageBoxButton.OK, MessageBoxImage.Information);
}
}

2
WorkBench/Node/View/ConditionRegionControl.xaml.cs
View File

@@ -31,7 +31,7 @@ namespace Serein.WorkBench.Node.View
/// <summary>
/// 添加条件控件
/// </summary>
/// <param name="condition"></param>
/// <param name="node"></param>
public void AddCondition(NodeControlBase node)
{
((CompositeConditionNode)ViewModel.Node).AddNode((SingleConditionNode)node.ViewModel.Node);

9
WorkBench/Node/View/DllControlControl.xaml
View File

@@ -14,22 +14,17 @@
<DockPanel>
<Grid>
<Grid.RowDefinitions>
<!--<RowDefinition Height="*"/>-->
<RowDefinition Height="*"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="*" />
<!--<ColumnDefinition Width="*" />-->
</Grid.ColumnDefinitions>
<!--<GroupBox Grid.Row="0" Header="条件" Margin="5">
<ListBox x:Name="ConditionsListBox" Background="#A8D8EA"/>
</GroupBox>-->
<GroupBox Grid.Row="0" Header="动作" Margin="5">
<GroupBox x:Name="ActionNodes" Grid.Row="0" Header="动作" Margin="5">
<ListBox x:Name="ActionsListBox" Background="#D0F1F9"/>
</GroupBox>
<GroupBox Grid.Row="1" Header="触发器" Margin="5">
<GroupBox x:Name="FlipflopNodes" Grid.Row="1" Header="触发器" Margin="5" >
<ListBox x:Name="FlipflopsListBox" Background="#FACFC1"/>
</GroupBox>
</Grid>

20
WorkBench/Node/View/DllControlControl.xaml.cs
View File

@@ -53,18 +53,18 @@ namespace Serein.WorkBench.Node.View
/// 向动作面板添加类型的文本块
/// </summary>
/// <param name="type">要添加的类型</param>
public void AddAction(MethodDetails md)
public void AddAction(MethodDetailsInfo mdInfo)
{
AddTypeToListBox(md, ActionsListBox);
AddTypeToListBox(mdInfo, ActionsListBox);
}
/// <summary>
/// 向触发器面板添加类型的文本块
/// </summary>
/// <param name="type">要添加的类型</param>
public void AddFlipflop(MethodDetails md)
public void AddFlipflop(MethodDetailsInfo mdInfo)
{
AddTypeToListBox(md, FlipflopsListBox);
AddTypeToListBox(mdInfo, FlipflopsListBox);
}
/// <summary>
@@ -72,14 +72,14 @@ namespace Serein.WorkBench.Node.View
/// </summary>
/// <param name="type">要添加的类型</param>
/// <param name="panel">要添加到的面板</param>
private void AddTypeToListBox(MethodDetails md, ListBox listBox)
private void AddTypeToListBox(MethodDetailsInfo mdInfo, ListBox listBox)
{
// 创建一个新的 TextBlock 并设置其属性
TextBlock typeText = new TextBlock
{
Text = $"{md.MethodTips}",
Text = $"{mdInfo.MethodTips}",
Margin = new Thickness(10, 2, 0, 0),
Tag = md
Tag = mdInfo
};
// 为 TextBlock 添加鼠标左键按下事件处理程序
typeText.MouseLeftButtonDown += TypeText_MouseLeftButtonDown;
@@ -125,17 +125,17 @@ namespace Serein.WorkBench.Node.View
// 获取触发事件的 TextBlock
if (sender is TextBlock typeText && typeText.Tag is MethodDetails md)
if (sender is TextBlock typeText && typeText.Tag is MethodDetailsInfo mdInfo)
{
MoveNodeData moveNodeData = new MoveNodeData
{
NodeControlType = md.MethodDynamicType switch
NodeControlType = mdInfo.NodeType switch
{
NodeType.Action => NodeControlType.Action,
NodeType.Flipflop => NodeControlType.Flipflop,
_ => NodeControlType.None,
},
MethodDetails = md,
MethodDetailsInfo = mdInfo,
};
if(moveNodeData.NodeControlType == NodeControlType.None)
{

6
WorkBench/Themes/IOCObjectViewControl.xaml.cs
View File

@@ -91,7 +91,11 @@ namespace Serein.WorkBench.Themes
public void ClearObjItem()
{
DependenciesListBox.Items.Clear();
DependenciesListBox.Dispatcher.Invoke(() =>
{
DependenciesListBox.Items.Clear();
});
}
private static void SortLisbox(ListBox listBox)

30
WorkBench/Themes/WindowDialogInput.xaml Normal file
View File

@@ -0,0 +1,30 @@
<Window x:Class="Serein.WorkBench.Themes.WindowEnvRemoteLoginView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:local="clr-namespace:Serein.WorkBench.Themes"
Title="登录远程环境" Height="150" Width="200">
<Grid Margin="0,10,0,0">
<Grid.RowDefinitions>
<RowDefinition Height="auto"/>
<RowDefinition Height="auto"/>
<RowDefinition Height="auto"/>
<RowDefinition Height="auto"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="40"/>
<ColumnDefinition Width="auto"/>
</Grid.ColumnDefinitions>
<TextBlock Grid.Row="0" Grid.Column="0" Text="地址" HorizontalAlignment="Center"></TextBlock>
<TextBox x:Name="TextBlockAddres" Grid.Row="0" Grid.Column="1" Text="192.168.1.100"></TextBox>
<TextBlock Grid.Row="1" Grid.Column="0" Text="端口" HorizontalAlignment="Center"></TextBlock>
<TextBox x:Name="TextBlockPort" Grid.Row="1" Grid.Column="1" Text="7525"></TextBox>
<TextBlock Grid.Row="2" Grid.Column="0" Text="密码" HorizontalAlignment="Center"></TextBlock>
<TextBox x:Name="TextBlockToken" Grid.Row="2" Grid.Column="1" Text="123456"></TextBox>
<StackPanel Grid.Row="3" Grid.Column="1" HorizontalAlignment="Center" Orientation="Horizontal" Margin="4">
<Button Content="测试连接" Margin="2" Click="ButtonTestConnect_Client"></Button>
<Button Content="登录环境" Margin="2" Click="ButtonTestLoginEnv_Client"></Button>
</StackPanel>
</Grid>
</Window>

68
WorkBench/Themes/WindowDialogInput.xaml.cs Normal file
View File

@@ -0,0 +1,68 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
namespace Serein.WorkBench.Themes
{
/// <summary>
/// WindowDialogInput.xaml 的交互逻辑
/// </summary>
public partial class WindowEnvRemoteLoginView : Window
{
private Action<string, int, string> ConnectRemoteFlowEnv;
/// <summary>
/// 弹窗输入
/// </summary>
/// <param name="connectRemoteFlowEnv"></param>
public WindowEnvRemoteLoginView(Action<string, int, string> connectRemoteFlowEnv)
{
WindowStartupLocation = WindowStartupLocation.CenterScreen;
InitializeComponent();
ConnectRemoteFlowEnv = connectRemoteFlowEnv;
}
private void ButtonTestConnect_Client(object sender, RoutedEventArgs e)
{
var addres = this.TextBlockAddres.Text;
_ = int.TryParse(this.TextBlockPort.Text, out var port);
_ = Task.Run(() => {
bool success = false;
try
{
TcpClient tcpClient = new TcpClient();
var result = tcpClient.BeginConnect(addres, port, null, null);
success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(3));
}
catch (Exception ex)
{
}
if (!success)
{
Console.WriteLine($"无法连接远程:{addres}:{port}");
}
});
}
private void ButtonTestLoginEnv_Client(object sender, RoutedEventArgs e)
{
var addres = this.TextBlockAddres.Text;
_ = int.TryParse(this.TextBlockPort.Text, out var port);
var token = this.TextBlockToken.Text;
ConnectRemoteFlowEnv?.Invoke(addres, port, token);
}
}
}