使用异步重构了节点执行方法，将触发器节点与其他节点统一。使用Channel代替Tcs更改了信号触发，使其符合异步编程的习惯。增加了节点是否启用勾选框、参数遮罩勾选框，节点右键面板增加中断功能（试验）。增加了选择后被选择的节点的视觉效果。更改平移缩放逻辑，使其更加符合一般的使用习惯。

NodeFlow/Base/NodeModelBaseFunc.cs

@@ -11,6 +11,7 @@ using System.Linq;
 using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
+using static Serein.Library.Utils.ChannelFlowInterrupt;
 
 namespace Serein.NodeFlow.Base
 {
@@ -20,6 +21,32 @@ namespace Serein.NodeFlow.Base
     /// </summary>
     public abstract partial class NodeModelBase : IDynamicFlowNode
     {
+
+
+        #region 调试中断
+
+        public Action? CancelInterruptCallback;
+
+        /// <summary>
+        /// 中断节点
+        /// </summary>
+        public void Interrupt()
+        {
+            this.DebugSetting.InterruptClass = InterruptClass.Branch;
+            this.DebugSetting.IsInterrupt = true;
+        }
+        /// <summary>
+        /// 不再中断
+        /// </summary>
+        public void CancelInterrupt()
+        {
+            this.DebugSetting.InterruptClass = InterruptClass.None;
+            this.DebugSetting.IsInterrupt = false;
+            CancelInterruptCallback?.Invoke();
+            CancelInterruptCallback = null;
+        }
+        #endregion
+
         #region 导出/导入项目文件节点信息
 
         internal abstract Parameterdata[] GetParameterdatas();
@@ -84,19 +111,19 @@ namespace Serein.NodeFlow.Base
 
         #endregion
 
+        #region 节点方法的执行
 
         /// <summary>
         /// 开始执行
         /// </summary>
         /// <param name="context"></param>
         /// <returns></returns>
-        public async Task StartExecution(IDynamicContext context)
+        public async Task StartExecute(IDynamicContext context)
         {
             var cts = context.SereinIoc.GetOrRegisterInstantiate<CancellationTokenSource>();
 
             Stack<NodeModelBase> stack = new Stack<NodeModelBase>();
             stack.Push(this);
-
             while (stack.Count > 0 && !cts.IsCancellationRequested) // 循环中直到栈为空才会退出循环
             {
                 // 从栈中弹出一个节点作为当前节点进行处理
@@ -108,51 +135,112 @@ namespace Serein.NodeFlow.Base
                     currentNode.MethodDetails.ActingInstance ??= context.SereinIoc.GetOrRegisterInstantiate(currentNode.MethodDetails.ActingInstanceType);
                 }
 
+                //if (TryCreateInterruptTask(context, currentNode, out Task<CancelType>? task))
+                //{
+                //    var cancelType = await task!;
+                //    await Console.Out.WriteLineAsync($"[{currentNode.MethodDetails.MethodName}]中断已{(cancelType == CancelType.Manual ? "手动取消" : "自动取消")}，开始执行后继分支");
+                //}
+
+                #region 执行相关
                 // 首先执行上游分支
                 var upstreamNodes = currentNode.SuccessorNodes[ConnectionType.Upstream];
                 for (int i = upstreamNodes.Count - 1; i >= 0; i--)
                 {
-                    upstreamNodes[i].PreviousNode = currentNode;
-                    await upstreamNodes[i].StartExecution(context); // 执行上游分支
+                    if (upstreamNodes[i].DebugSetting.IsEnable) // 排除未启用的上游节点
+                    {
+                        upstreamNodes[i].PreviousNode = currentNode;
+                        await upstreamNodes[i].StartExecute(context); // 执行流程节点的上游分支
+                    }
                 }
 
+                currentNode.FlowData = currentNode.ExecutingAsync(context); // 流程中正常执行
+
                 // 判断是否为触发器节点，如果是，则开始等待。
-                if (currentNode.MethodDetails != null && currentNode.MethodDetails.MethodDynamicType == NodeType.Flipflop)
-                {
-                    
-                    currentNode.FlowData = await currentNode.ExecuteAsync(context); // 流程中遇到了触发器
-                }
-                else
-                {
-                    currentNode.FlowData = currentNode.Execute(context); // 流程中正常执行
-                }
+                //if (currentNode.MethodDetails != null && currentNode.MethodDetails.MethodDynamicType == NodeType.Flipflop)
+                //{
 
-                if(currentNode.NextOrientation == ConnectionType.None)
-                {
-                    // 不再执行
-                    break;
-                }
+                //    currentNode.FlowData = await currentNode.ExecutingFlipflopAsync(context); // 流程中遇到了触发器
+                //}
+                //else
+                //{
+                   
+                //}
+                #endregion
 
-                // 获取下一分支
+
+
+
+                #region 执行完成
+                if (currentNode.NextOrientation == ConnectionType.None) break; // 不再执行
+
+
+                // 选择后继分支
                 var nextNodes = currentNode.SuccessorNodes[currentNode.NextOrientation];
 
                 // 将下一个节点集合中的所有节点逆序推入栈中
                 for (int i = nextNodes.Count - 1; i >= 0; i--)
                 {
-                    nextNodes[i].PreviousNode = currentNode;
-                    stack.Push(nextNodes[i]);
-                }
+                    // 排除未启用的节点
+                    if (nextNodes[i].DebugSetting.IsEnable)
+                    {
+                        nextNodes[i].PreviousNode = currentNode;
+                        stack.Push(nextNodes[i]);
+                    }
+                } 
+                #endregion
             }
         }
 
+        public static bool TryCreateInterruptTask(IDynamicContext context, NodeModelBase currentNode, out Task<CancelType>? task)
+        {
+            if (!currentNode.DebugSetting.IsInterrupt)
+            {
+                task = null;
+                return false;
+            }
+
+            Task<CancelType>? result = null;
+            bool haveTask = false;
+            Console.WriteLine($"[{currentNode.MethodDetails.MethodName}]在当前分支中断");
+            if (currentNode.DebugSetting.InterruptClass == InterruptClass.None)
+            {
+                haveTask = false;
+                task = null;
+                currentNode.DebugSetting.IsInterrupt = false; // 纠正设置
+            }
+            if (currentNode.DebugSetting.InterruptClass == InterruptClass.Branch) // 中断当前分支
+            {
+                currentNode.DebugSetting.IsInterrupt = true;
+                haveTask = true;
+                task = context.FlowEnvironment.ChannelFlowInterrupt.CreateChannelWithTimeoutAsync(currentNode.Guid, TimeSpan.FromSeconds(1));
+                currentNode.CancelInterruptCallback ??= () => context.FlowEnvironment.ChannelFlowInterrupt.TriggerSignal(currentNode.Guid);
+
+            }
+            else
+            {
+                haveTask = false;
+                task = null;
+            }
+
+            return haveTask;
+        }
 
         /// <summary>
         /// 执行节点对应的方法
         /// </summary>
         /// <param name="context">流程上下文</param>
         /// <returns>节点传回数据对象</returns>
-        public virtual object? Execute(IDynamicContext context)
+        public virtual async Task<object?> ExecutingAsync(IDynamicContext context)
         {
+            #region 调试中断
+            if (TryCreateInterruptTask(context, this, out Task<CancelType>? task))
+            {
+                var cancelType = await task!;
+                await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已{(cancelType == CancelType.Manual ? "手动取消" : "自动取消")}，开始执行后继分支");
+            }
+
+            #endregion
+
             MethodDetails md = MethodDetails;
             var del = md.MethodDelegate;
             object instance = md.ActingInstance;
@@ -186,38 +274,7 @@ namespace Serein.NodeFlow.Base
         /// <param name="context"></param>
         /// <returns>节点传回数据对象</returns>
         /// <exception cref="RuningException"></exception>
-        public virtual async Task<object?> ExecuteAsync(IDynamicContext context)
-        {
-            MethodDetails md = MethodDetails;
-            Delegate del = md.MethodDelegate;
-            object instance = md.ActingInstance;
-            var haveParameter = md.ExplicitDatas.Length >= 0;
-            try
-            {
-                // 调用委托并获取结果
-                Task<IFlipflopContext> flipflopTask = haveParameter switch
-                {
-                    true => ((Func<object, object?[]?, Task<IFlipflopContext>>)del).Invoke(instance, GetParameters(context, md)), // 执行流程中的触发器方法时获取入参参数
-                    false => ((Func<object, Task<IFlipflopContext>>)del).Invoke(instance),
-                };
-
-                IFlipflopContext flipflopContext = (await flipflopTask) ?? throw new FlipflopException("没有返回上下文");
-                NextOrientation = flipflopContext.State.ToContentType();
-                return flipflopContext.Data;
-            }
-            //catch(FlipflopException ex)
-            //{
-            //    NextOrientation = ConnectionType.IsError;
-            //    RuningException = ex;
-            //    return null;
-            //}
-            catch (Exception ex)
-            {
-                NextOrientation = ConnectionType.IsError;
-                RuningException = ex;
-                return null;
-            }
-        }
+        
 
 
         #region 节点转换的委托类型
@@ -248,45 +305,34 @@ namespace Serein.NodeFlow.Base
         public object?[]? GetParameters(IDynamicContext context, MethodDetails md)
         {
             // 用正确的大小初始化参数数组
-            var types = md.ExplicitDatas.Select(it => it.DataType).ToArray();
-            if (types.Length == 0)
+            if (md.ExplicitDatas.Length == 0)
             {
-                return [md.ActingInstance];
+                return [];// md.ActingInstance
             }
 
-            object?[]? parameters = new object[types.Length];
+            object?[]? parameters = new object[md.ExplicitDatas.Length];
             var flowData = PreviousNode?.FlowData; // 当前传递的数据
             var previousDataType = flowData?.GetType();
 
-            for (int i = 0; i < types.Length; i++)
+            for (int i = 0; i < parameters.Length; i++)
             {
-                //if (flowData is null)
-                //{
-                //    parameters[i] = md.ExplicitDatas[i].DataType switch
-                //    {
-                //        Type t when t == typeof(IDynamicContext) => context, // 上下文
-                //        Type t when t == typeof(MethodDetails) => md, // 节点方法描述
-                //        Type t when t == typeof(NodeModelBase) => this, // 节点实体类
-                //        _ => null,
-                //    };
-                //    continue; // 上一节点数据为空，提前跳过
-                //}
-                object? inputParameter; // 
+
+                object? inputParameter; // 存放解析的临时参数
                 var ed = md.ExplicitDatas[i]; // 方法入参描述
 
-                
+
                 if (ed.IsExplicitData)
                 {
-                   
-                    if (ed.DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase))  
+
+                    if (ed.DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase))
                     {
                         // 执行表达式从上一节点获取对象
-                        inputParameter = SerinExpressionEvaluator.Evaluate(ed.DataValue, flowData, out _);  
+                        inputParameter = SerinExpressionEvaluator.Evaluate(ed.DataValue, flowData, out _);
                     }
-                    else 
+                    else
                     {
                         // 使用输入的固定值
-                        inputParameter = ed.DataValue;  
+                        inputParameter = ed.DataValue;
                     }
                 }
                 else
@@ -303,16 +349,26 @@ namespace Serein.NodeFlow.Base
                         Type t when t == typeof(MethodDetails) => md, // 节点方法描述
                         Type t when t == typeof(NodeModelBase) => this, // 节点实体类
                         Type t when t == typeof(Guid) => new Guid(inputParameter?.ToString()),
-                        Type t when t == typeof(decimal) => decimal.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(DateTime) => DateTime.Parse(inputParameter?.ToString()),
                         Type t when t == typeof(string) => inputParameter?.ToString(),
                         Type t when t == typeof(char) => char.Parse(inputParameter?.ToString()),
-                        Type t when t == typeof(bool) => bool.Parse(inputParameter?.ToString()),
-                        Type t when t == typeof(byte) => byte.Parse(inputParameter?.ToString()),
-                        Type t when t == typeof(int) => int.Parse(inputParameter?.ToString()),
-                        Type t when t == typeof(long) => long.Parse(inputParameter?.ToString()),
-                        Type t when t == typeof(DateTime) => DateTime.Parse(inputParameter?.ToString()),
-                        Type t when t == typeof(float) => float.Parse(inputParameter?.ToString()),
-                        Type t when t == typeof(double) => double.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(bool) => inputParameter is null ? false : bool.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(float) => inputParameter is null ? 0F : float.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(decimal) => inputParameter is null ? 0 : decimal.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(double) => inputParameter is null ? 0 : double.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(sbyte) => inputParameter is null ? 0 : sbyte.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(byte) => inputParameter is null ? 0 : byte.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(short) => inputParameter is null ? 0 : short.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(ushort) => inputParameter is null ? 0U : ushort.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(int) => inputParameter is null ? 0 : int.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(uint) => inputParameter is null ? 0U : uint.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(long) => inputParameter is null ? 0L : long.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(ulong) => inputParameter is null ? 0UL : ulong.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(nint) => inputParameter is null ? 0 : nint.Parse(inputParameter?.ToString()),
+                        Type t when t == typeof(nuint) => inputParameter is null ? 0 : nuint.Parse(inputParameter?.ToString()),
+
+
+
                         Type t when t.IsEnum => Enum.Parse(ed.DataType, ed.DataValue),// 需要枚举
                         Type t when t.IsArray => (inputParameter as Array)?.Cast<object>().ToList(),
                         Type t when t.IsGenericType && t.GetGenericTypeDefinition() == typeof(List<>) => inputParameter,
@@ -329,6 +385,10 @@ namespace Serein.NodeFlow.Base
             return parameters;
         }
 
+        #endregion
+
+
+
         /// <summary>
         /// json文本反序列化为对象
         /// </summary>