移除了中断相关的后台代码与UI交互（待重写）；重写运行时节点获取参数的方法；重写了节点容器的互动；完善了WebSocket远程交互；完善了项目文件的加载；

Library.Core/FlipflopContext.cs

@@ -1,4 +1,5 @@
 using Serein.Library.Api;
+using Serein.Library.Utils;
 
 namespace Serein.Library.Core
 {

Library.Framework/FlipflopContext.cs

@@ -1,4 +1,5 @@
 using Serein.Library.Api;
+using Serein.Library.Utils;
 using System;
 using System.Threading.Tasks;
 

Library/Api/IFlipflopContext.cs

@@ -1,4 +1,5 @@
 using Serein.Library;
+using Serein.Library.Utils;
 
 
 namespace Serein.Library.Api

Library/Api/IFlowEnvironment.cs

@@ -6,7 +6,6 @@ using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using static Serein.Library.Utils.ChannelFlowInterrupt;
 
 namespace Serein.Library.Api
 {
@@ -203,7 +202,7 @@ namespace Serein.Library.Api
             /// <summary>
             /// 移除
             /// </summary>
-            Remote,
+            Remove,
         }
 
         /// <summary>
@@ -311,9 +310,9 @@ namespace Serein.Library.Api
         //}
 
         /// <summary>
-        /// 节点Model对象，目前需要手动转换对应的类型
+        /// 节点Model对象
         /// </summary>
-        public object NodeModel { get; private set; }
+        public NodeModelBase NodeModel { get; private set; }
         public PositionOfUI Position { get; private set; }
         //public bool IsAddInRegion { get; private set; }
         public string RegeionGuid { get; private set; }
@@ -934,13 +933,17 @@ namespace Serein.Library.Api
         void TerminateFlipflopNode(string nodeGuid);
 
 
-        /// <summary>
+
+        #region 节点中断、表达式
+#if false
+
+/// <summary>
         /// 设置节点中断
         /// </summary>
         /// <param name="nodeGuid">更改中断状态的节点Guid</param>
         /// <param name="isInterrup">是否中断</param>
         /// <returns></returns>
-        Task<bool> SetNodeInterruptAsync(string nodeGuid,bool isInterrup);
+        Task<bool> SetNodeInterruptAsync(string nodeGuid, bool isInterrup);
 
         /// <summary>
         /// 添加作用于某个对象的中断表达式
@@ -955,7 +958,7 @@ namespace Serein.Library.Api
         /// </summary>
         /// <param name="key">需要监视的对象</param>
         /// <param name="isMonitor">是否启用监视</param>
-        void SetMonitorObjState(string key,bool isMonitor);
+        void SetMonitorObjState(string key, bool isMonitor);
 
         /// <summary>
         /// 检查一个对象是否处于监听状态，如果是，则传出与该对象相关的表达式（用于中断），如果不是，则返回false。
@@ -971,7 +974,9 @@ namespace Serein.Library.Api
         /// <param name="signal"></param>
         /// <param name="interruptClass"></param>
         /// <returns></returns>
-        Task<CancelType> GetOrCreateGlobalInterruptAsync();
+        Task<CancelType> InterruptNode(); 
+#endif
+        #endregion
 
         /// <summary>
         /// （用于远程）通知节点属性变更

Library/Api/IFlowTrigger.cs

@@ -1,11 +1,15 @@
-using System;
+using Serein.Library.Utils;
-using System.Collections.Generic;
+using System;
-using System.Linq;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace Serein.Library.Api
 {
+
+
+
+
+
+
     /// <summary>
     /// 触发器接口
     /// </summary>

Library/Api/INodeContainer.cs

@@ -15,13 +15,13 @@ namespace Serein.Library.Api
         /// 放置一个节点
         /// </summary>
         /// <param name="nodeModel"></param>
-        void PlaceNode(NodeModelBase nodeModel);
+        bool PlaceNode(NodeModelBase nodeModel);
 
         /// <summary>
         /// 取出一个节点
         /// </summary>
         /// <param name="nodeModel"></param>
-        void TakeOutNode(NodeModelBase nodeModel);
+        bool TakeOutNode(NodeModelBase nodeModel);
 
         /// <summary>
         /// 取出所有节点（用于删除容器）

Library/FlowNode/NodeDebugSetting.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
-using static Serein.Library.Utils.ChannelFlowInterrupt;
 
 namespace Serein.Library
 {
@@ -42,7 +41,7 @@ namespace Serein.Library
         /// <summary>
         ///  中断级别，暂时停止继续执行后继分支。
         /// </summary>
-        [PropertyInfo(IsNotification = true, CustomCodeAtEnd = "NodeModel?.Env?.SetNodeInterruptAsync(NodeModel?.Guid, value);")] // CustomCode = "NodeModel?.Env?.SetNodeInterruptAsync(NodeModel?.Guid, value);"
+        [PropertyInfo(IsNotification = true, CustomCodeAtEnd = "// NodeModel?.Env?.SetNodeInterruptAsync(NodeModel?.Guid, value);")] // CustomCode = "NodeModel?.Env?.SetNodeInterruptAsync(NodeModel?.Guid, value);"
         private bool _isInterrupt = false;
 
         /// <summary>
@@ -55,7 +54,7 @@ namespace Serein.Library
         /// 中断Task（用来中断）
         /// </summary>
         [PropertyInfo]
-        private Func<Task<CancelType>> _getInterruptTask;
+        private Func<Task> _getInterruptTask;
 
     }
 

Library/FlowNode/NodeModelBaseFunc.cs

@@ -16,7 +16,6 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Xml.Linq;
-using static Serein.Library.Utils.ChannelFlowInterrupt;
 
 namespace Serein.Library
 {
@@ -366,16 +365,15 @@ namespace Serein.Library
         /// <returns>节点传回数据对象</returns>
         public virtual async Task<object> ExecutingAsync(IDynamicContext context)
         {
-            if(context.NextOrientation == ConnectionInvokeType.IsError)
+            //if(context.NextOrientation == ConnectionInvokeType.IsError)
-            {
+            //{
-                Console.WriteLine("");
+            //}
-            }
             #region 调试中断
 
             if (DebugSetting.IsInterrupt) // 执行触发检查是否需要中断
             {
-                var cancelType = await this.DebugSetting.GetInterruptTask(); // 等待中断结束
+                //var cancelType = await this.DebugSetting.GetInterruptTask(); // 等待中断结束
-                await Console.Out.WriteLineAsync($"[{this.MethodDetails?.MethodName}]中断已{cancelType}，开始执行后继分支");
+                await Console.Out.WriteLineAsync($"[{this.MethodDetails?.MethodName}]中断已取消，开始执行后继分支");
             }
 
             #endregion
@@ -394,7 +392,7 @@ namespace Serein.Library
                 md.ActingInstance = context.Env.IOC.Get(md.ActingInstanceType);
             }
 
-            object[] args = await GetParametersAsync(context, this);
+            object[] args = await GetParametersAsync(context);
             var result = await dd.InvokeAsync(md.ActingInstance, args);
             return result;
 
@@ -403,296 +401,50 @@ namespace Serein.Library
         /// <summary>
         /// 获取对应的参数数组
         /// </summary>
-        public static async Task<object[]> GetParametersAsync(IDynamicContext context,
+        public async Task<object[]> GetParametersAsync(IDynamicContext context)
-                                                              NodeModelBase nodeModel)
         {
-            // 用正确的大小初始化参数数组
+            if (MethodDetails.ParameterDetailss.Length == 0)
-            var md = nodeModel.MethodDetails;
-            if (md.ParameterDetailss.Length == 0)
             {
-                return null;// md.ActingInstance
+                return new object[0];// md.ActingInstance
             }
 
-            object[] parameters;
+            object[] args;
             Array paramsArgs = null; // 初始化可选参数
             int paramsArgIndex = 0; // 可选参数下标，与 object[] paramsArgs 一起使用
-            
+            if (MethodDetails.ParamsArgIndex >= 0) // 存在可变入参参数
-            if (md.ParamsArgIndex >= 0) 
             {
-                // 存在可变入参参数
+                var paramsArgType = MethodDetails.ParameterDetailss[MethodDetails.ParamsArgIndex].DataType; // 获取可变参数的参数类型
-                var paramsArgType = md.ParameterDetailss[md.ParamsArgIndex].DataType; // 获取可变参数的参数类型
+                int paramsLength = MethodDetails.ParameterDetailss.Length - MethodDetails.ParamsArgIndex;  // 可变参数数组长度 = 方法参数个数 - （ 可选入参下标 + 1 ）
-                // 可变参数数组长度 = 方法参数个数 - （ 可选入参下标 + 1 ）
-                int paramsLength = md.ParameterDetailss.Length - md.ParamsArgIndex;
                 paramsArgs = Array.CreateInstance(paramsArgType, paramsLength);// 可变参数
-                parameters = new object[md.ParamsArgIndex+1]; // 调用方法的入参数组
+                args = new object[MethodDetails.ParamsArgIndex + 1]; // 调用方法的入参数组
-                parameters[md.ParamsArgIndex] = paramsArgs; // 如果存在可选参数，入参参数最后一项则为可变参数
+                args[MethodDetails.ParamsArgIndex] = paramsArgs; // 如果存在可选参数，入参参数最后一项则为可变参数
             }
             else
             {
                 // 不存在可选参数
-                parameters = new object[md.ParameterDetailss.Length]; // 调用方法的入参数组
+                args = new object[MethodDetails.ParameterDetailss.Length]; // 调用方法的入参数组
             }
 
-            bool hasParams = false;
+            for (int i = 0; i < args.Length; i++) {
-            for (int i = 0; i < md.ParameterDetailss.Length; i++)
+                var pd = MethodDetails.ParameterDetailss[i];
+                args[i] = await pd.ToMethodArgData(context); // 获取数据
+            }
+
+            if(MethodDetails.ParamsArgIndex >= 0)
             {
-                var pd = md.ParameterDetailss[i]; // 方法入参描述
+                for (int i = 0; i < paramsArgs.Length; i++)
-                var argDataType = pd.DataType;
-
-                // 入参参数下标循环到可选参数时，开始写入到可选参数数组
-                if (paramsArgs != null && i >= md.ParamsArgIndex)
                 {
-                    // 控制参数赋值方向：
+                    var pd = MethodDetails.ParameterDetailss[paramsArgIndex + i];
-                    // true  => paramsArgs
+                    var data = await pd.ToMethodArgData(context); // 获取数据
-                    // false => parameters
+                    paramsArgs.SetValue(data, i);// 设置到数组中
-                    hasParams = true;
                 }
-
+                args[args.Length - 1] = paramsArgs;
-                #region 获取基础的上下文数据
-                if (argDataType == typeof(IFlowEnvironment)) // 获取流程上下文
-                {
-                    parameters[i] = nodeModel.Env;
-                    continue;
-                }
-                if (argDataType == typeof(IDynamicContext)) // 获取流程上下文
-                {
-                    parameters[i] = context;
-                    continue;
-                } 
-                #endregion
-
-                #region 确定[预入参]数据
-                object inputParameter; // 存放解析的临时参数
-                if (pd.IsExplicitData && !pd.DataValue.StartsWith("@", StringComparison.OrdinalIgnoreCase)) // 判断是否使用显示的输入参数
-                {
-                    // 使用输入的固定值
-                    inputParameter = pd.DataValue;
-                }
-                else
-                {
-                    #region （默认的）从运行时上游节点获取其返回值
-                    if (pd.ArgDataSourceType == ConnectionArgSourceType.GetPreviousNodeData)
-                    {
-                        var previousNode = context.GetPreviousNode(nodeModel);
-                        if (previousNode is null)
-                        {
-                            inputParameter = null;
-                        }
-                        else
-                        {
-                            inputParameter = context.GetFlowData(previousNode.Guid); // 当前传递的数据
-                        }
-                    }
-                    #endregion
-                    #region  从指定节点获取其返回值
-                    else if (pd.ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeData)
-                    {
-                        // 获取指定节点的数据
-                        // 如果指定节点没有被执行，会返回null
-                        // 如果执行过，会获取上一次执行结果作为预入参数据
-                        inputParameter = context.GetFlowData(pd.ArgDataSourceNodeGuid);
-                    }
-                    #endregion
-                    #region 立刻执行指定节点，然后获取返回值
-                    else if (pd.ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeDataOfInvoke)
-                    {
-                        // 立刻调用对应节点获取数据。
-                        try
-                        {
-                            var result = await context.Env.InvokeNodeAsync(context, pd.ArgDataSourceNodeGuid);
-                            inputParameter = result;
-                        }
-                        catch (Exception ex)
-                        {
-                            context.NextOrientation = ConnectionInvokeType.IsError;
-                            context.ExceptionOfRuning = ex;
-                            throw;
-                        }
-                    }
-                    #endregion
-                    #region 意料之外的参数
-                    else
-                    {
-                        throw new Exception("节点执行方法获取入参参数时，ConnectionArgSourceType枚举是意外的枚举值");
-                    } 
-                    #endregion
-                }
-
-                
-
-                #region 处理 @Get / @DTC 表达式 （Data type conversion） / @Data (全局数据)
-                if (pd.IsExplicitData)
-                {
-
-                    // @Get 表达式 （从上一节点获取对象）
-                    if (pd.DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase))
-                    {
-                        inputParameter = SerinExpressionEvaluator.Evaluate(pd.DataValue, inputParameter, out _);
-                    }
-
-                    // @DTC 表达式 （Data type conversion）
-                    if (pd.DataValue.StartsWith("@dtc", StringComparison.OrdinalIgnoreCase))
-                    {
-                        inputParameter = SerinExpressionEvaluator.Evaluate(pd.DataValue, inputParameter, out _);
-                    }
-
-                    // @Data 表达式 （获取全局数据）
-                    if (pd.DataValue.StartsWith("@data", StringComparison.OrdinalIgnoreCase))
-                    {
-                        inputParameter = SerinExpressionEvaluator.Evaluate(pd.DataValue, inputParameter, out _);
-                    }
-
-                }
-
-                #endregion
-
-                #region 对于非值类型的null检查
-                if (!argDataType.IsValueType && inputParameter is null)
-                {
-                    parameters[i] = null;
-                    throw new Exception($"[arg{pd.Index}][{pd.Name}][{argDataType}]参数不能为null");
-                    continue;
-                }
-                #endregion
-
-                #endregion
-
-                //#region 入参存在取值转换器，调用对应的转换器获取入参数据，如果获取成功（不为null）会跳过循环
-                //if (pd.ExplicitType.IsEnum && !(pd.Convertor is null))
-                //{
-                //    //var resultEnum = Enum.ToObject(ed.ExplicitType, ed.DataValue);
-                //    var resultEnum = Enum.Parse(pd.ExplicitType, pd.DataValue);
-                //    var value = pd.Convertor(resultEnum);
-                //    if (value is null)
-                //    {
-                //        throw new InvalidOperationException("转换器调用失败");
-
-                //    }
-                //    else
-                //    {
-                //        if (hasParams)
-                //        {
-                //            paramsArgs.SetValue(value, paramsArgIndex++);
-                //            // 处理可选参数
-                //            //paramsArgs[paramsArgIndex++] = value;
-                //        }
-                //        else
-                //        {
-                //            parameters[i] = value;
-                //        }
-                //        continue;
-                //    }
-                //}
-                //#endregion
-
-                #region  入参存在基于BinValue的类型转换器，获取枚举转换器中记录的类型，如果获取成功（不为null）会跳过循环
-                // 入参存在基于BinValue的类型转换器，获取枚举转换器中记录的类型
-                if (pd.ExplicitType.IsEnum && argDataType != pd.ExplicitType)
-                {
-                    var resultEnum = Enum.Parse(pd.ExplicitType, pd.DataValue);
-                    // 获取绑定的类型
-                    var type = EnumHelper.GetBoundValue(pd.ExplicitType, resultEnum, attr => attr.Value);
-                    if (type is Type enumBindType && !(enumBindType is null))
-                    {
-                        var value = nodeModel.Env.IOC.Instantiate(enumBindType);
-                        if (value is null)
-                        {
-
-                        }
-                        else
-                        {
-                            if (hasParams)
-                            {
-                                // 处理可选参数
-                                paramsArgs.SetValue(value, paramsArgIndex++);
-                                //paramsArgs[paramsArgIndex++] = value;
-                            }
-                            else
-                            {
-                                parameters[i] = value;
-                            }
-                            continue;
-                        }
-                    }
-                }
-
-                #endregion
-
-                #region 对入参数据尝试进行转换
-                object tmpVaue = null; // 临时存放数据，最后才判断是否放置可选参数数组
-                var inputParameterType = inputParameter.GetType();
-                if (inputParameterType == argDataType)
-                {
-                    tmpVaue = inputParameter; // 类型一致无需转换，直接装入入参数组
-                }
-                else if (argDataType.IsValueType) 
-                {
-                    // 值类型
-                    var valueStr = inputParameter?.ToString();
-                    tmpVaue = valueStr.ToValueData(argDataType); // 类型不一致，尝试进行转换，如果转换失败返回类型对应的默认值
-                }
-                else 
-                {
-                    // 引用类型
-                    if (argDataType == typeof(string)) // 转为字符串
-                    {
-                        var valueStr = inputParameter?.ToString();
-                        tmpVaue = valueStr;
-                    }
-                    else if(argDataType.IsSubclassOf(inputParameterType)) // 入参类型 是 预入参数据类型 的 子类/实现类 
-                    {
-                        // 方法入参中，父类不能隐式转为子类，这里需要进行强制转换
-                        tmpVaue =  ObjectConvertHelper.ConvertParentToChild(inputParameter, argDataType);
-                    }
-                    else if(argDataType.IsAssignableFrom(inputParameterType))  // 入参类型 是 预入参数据类型 的 父类/接口
-                    {
-                        tmpVaue = inputParameter;
-                    }
-                    // 集合类型
-                    //else if(inputParameter is IEnumerable collection)
-                    //{
-                    //    var enumerableMethods = typeof(Enumerable).GetMethods();   // 获取所有的 Enumerable 扩展方法
-                    //    MethodInfo conversionMethod;
-                    //    if (argDataType.IsArray) // 转为数组
-                    //    {
-                    //        parameters[i] = inputParameter;
-                    //        conversionMethod = enumerableMethods.FirstOrDefault(m => m.Name == "ToArray" && m.IsGenericMethodDefinition);
-                    //    }
-                    //    else if (argDataType.GetGenericTypeDefinition() == typeof(List<>)) // 转为集合
-                    //    {
-                    //         conversionMethod = enumerableMethods.FirstOrDefault(m => m.Name == "ToList" && m.IsGenericMethodDefinition);
-                    //    }
-                    //    else
-                    //    {
-                    //        throw new InvalidOperationException("输入对象不是集合或目标类型不支持（目前仅支持Array、List的自动转换）");
-                    //    }
-                    //    var genericMethod = conversionMethod.MakeGenericMethod(argDataType);
-                    //    var result = genericMethod.Invoke(null, new object[] { collection });
-                    //    parameters[i] = result;
-                    //}
-                   
-                }
-
-
-                if (hasParams)
-                {
-                    // 处理可选参数
-                    paramsArgs.SetValue(tmpVaue, paramsArgIndex++);
-                    //paramsArgs[paramsArgIndex++] = tmpVaue;
-                }
-                else
-                {
-                    parameters[i] = tmpVaue;
-                }
-                #endregion
-
             }
+           
 
-
+            return args;
-            return parameters;
         }
 
-
         /// <summary>
         /// 更新节点数据，并检查监视表达式是否生效
         /// </summary>
@@ -733,37 +485,37 @@ namespace Serein.Library
             {
                 return;
             }
-            (var isMonitor, var exps) = await context.Env.CheckObjMonitorStateAsync(key);
+            //(var isMonitor, var exps) = await context.Env.CheckObjMonitorStateAsync(key);
-            if (isMonitor) // 如果新的数据处于查看状态，通知UI进行更新？交给运行环境判断？
+            //if (isMonitor) // 如果新的数据处于查看状态，通知UI进行更新？交给运行环境判断？
-            {
+            //{
-                context.Env.MonitorObjectNotification(nodeModel.Guid, data, sourceType); // 对象处于监视状态，通知UI更新数据显示
+            //    context.Env.MonitorObjectNotification(nodeModel.Guid, data, sourceType); // 对象处于监视状态，通知UI更新数据显示
-                if (exps.Length > 0)
+            //    if (exps.Length > 0)
-                {
+            //    {
-                    // 表达式环境下判断是否需要执行中断
+            //        // 表达式环境下判断是否需要执行中断
-                    bool isExpInterrupt = false;
+            //        bool isExpInterrupt = false;
-                    string exp = "";
+            //        string exp = "";
-                    // 判断执行监视表达式，直到为 true 时退出
+            //        // 判断执行监视表达式，直到为 true 时退出
-                    for (int i = 0; i < exps.Length && !isExpInterrupt; i++)
+            //        for (int i = 0; i < exps.Length && !isExpInterrupt; i++)
-                    {
+            //        {
-                        exp = exps[i];
+            //            exp = exps[i];
-                        if (string.IsNullOrEmpty(exp)) continue;
+            //            if (string.IsNullOrEmpty(exp)) continue;
-                        // isExpInterrupt = SereinConditionParser.To(data, exp);
+            //            // isExpInterrupt = SereinConditionParser.To(data, exp);
-                    }
+            //        }
 
-                    if (isExpInterrupt) // 触发中断
+            //        if (isExpInterrupt) // 触发中断
-                    {
+            //        {
-                        nodeModel.DebugSetting.IsInterrupt = true;
+            //            nodeModel.DebugSetting.IsInterrupt = true;
-                        if (await context.Env.SetNodeInterruptAsync(nodeModel.Guid,true))
+            //            if (await context.Env.SetNodeInterruptAsync(nodeModel.Guid,true))
-                        {
+            //            {
-                            context.Env.TriggerInterrupt(nodeModel.Guid, exp, InterruptTriggerEventArgs.InterruptTriggerType.Exp);
+            //                context.Env.TriggerInterrupt(nodeModel.Guid, exp, InterruptTriggerEventArgs.InterruptTriggerType.Exp);
-                            var cancelType = await nodeModel.DebugSetting.GetInterruptTask();
+            //                var cancelType = await nodeModel.DebugSetting.GetInterruptTask();
-                            await Console.Out.WriteLineAsync($"[{data}]中断已{cancelType}，开始执行后继分支");
+            //                await Console.Out.WriteLineAsync($"[{data}]中断已{cancelType}，开始执行后继分支");
-                            nodeModel.DebugSetting.IsInterrupt = false;
+            //                nodeModel.DebugSetting.IsInterrupt = false;
-                        }
+            //            }
-                    }
+            //        }
-                }
+            //    }
 
-            }
+            //}
         }
 
         ///// <summary>

Library/FlowNode/ParameterDetails.cs

@@ -1,8 +1,11 @@
 using Serein.Library.Api;
 using Serein.Library.Utils;
+using Serein.Library.Utils.SereinExpression;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
 
 namespace Serein.Library
 {
@@ -111,7 +114,6 @@ namespace Serein.Library
         {
 
         }
- 
 
         /// <summary>
         /// 为节点实例化新的入参描述
@@ -178,6 +180,141 @@ namespace Serein.Library
             return pd;
         }
 
+        /// <summary>
+        /// 转为方法入参数据
+        /// </summary>
+        /// <returns></returns>
+        public async ValueTask<object> ToMethodArgData(IDynamicContext context)
+        {
+            var nodeModel = NodeModel;
+            var env = nodeModel.Env;
+            #region 显然的流程基本类型
+            // 返回运行环境
+            if (DataType == typeof(IFlowEnvironment))
+            {
+                return env;
+            }
+            // 返回流程上下文
+            if (DataType == typeof(IDynamicContext))
+            {
+                return context;
+            }
+            // 显式设置的参数
+            if (IsExplicitData && !DataValue.StartsWith("@", StringComparison.OrdinalIgnoreCase))
+            {
+                return DataValue.ToConvert(DataType); // 并非表达式，同时是显式设置的参数
+            } 
+            #endregion
+            #region “枚举-类型”转换器
+            if (ExplicitType.IsEnum && DataType != ExplicitType)
+            {
+                var resultEnum = Enum.Parse(ExplicitType, DataValue);
+                // 获取绑定的类型
+                var type = EnumHelper.GetBoundValue(ExplicitType, resultEnum, attr => attr.Value);
+                if (type is Type enumBindType && !(enumBindType is null))
+                {
+                    var value = nodeModel.Env.IOC.Instantiate(enumBindType);
+                    return value;
+                }
+            } 
+            #endregion
+
+            // 需要获取预入参数据
+            object inputParameter;
+            #region （默认的）从运行时上游节点获取其返回值
+            if (ArgDataSourceType == ConnectionArgSourceType.GetPreviousNodeData)
+            {
+                var previousNode = context.GetPreviousNode(nodeModel);
+                if (previousNode is null)
+                {
+                    inputParameter = null;
+                }
+                else
+                {
+                    inputParameter = context.GetFlowData(previousNode.Guid); // 当前传递的数据
+                }
+            }
+            #endregion
+            #region  从指定节点获取其返回值
+            else if (ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeData)
+            {
+                // 获取指定节点的数据
+                // 如果指定节点没有被执行，会返回null
+                // 如果执行过，会获取上一次执行结果作为预入参数据
+                inputParameter = context.GetFlowData(ArgDataSourceNodeGuid);
+            }
+            #endregion
+            #region 立刻执行指定节点，然后获取返回值
+            else if (ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeDataOfInvoke)
+            {
+                // 立刻调用对应节点获取数据。
+                try
+                {
+                    var result = await env.InvokeNodeAsync(context, ArgDataSourceNodeGuid);
+                    inputParameter = result;
+                }
+                catch (Exception ex)
+                {
+                    context.NextOrientation = ConnectionInvokeType.IsError;
+                    context.ExceptionOfRuning = ex;
+                    throw;
+                }
+            }
+            #endregion
+            #region 意料之外的参数
+            else
+            {
+                throw new Exception("节点执行方法获取入参参数时，ConnectionArgSourceType枚举是意外的枚举值");
+            }
+            #endregion
+            #region 判断是否执行表达式
+            if (IsExplicitData)
+            {
+                // @Get 表达式 （从上一节点获取对象）
+                if (DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase))
+                {
+                    inputParameter = SerinExpressionEvaluator.Evaluate(DataValue, inputParameter, out _);
+                }
+
+                // @DTC 表达式 （Data type conversion）
+                else if (DataValue.StartsWith("@dtc", StringComparison.OrdinalIgnoreCase))
+                {
+                    inputParameter = SerinExpressionEvaluator.Evaluate(DataValue, inputParameter, out _);
+                }
+
+                // @Data 表达式 （获取全局数据）
+                else if (DataValue.StartsWith("@data", StringComparison.OrdinalIgnoreCase))
+                {
+                    inputParameter = SerinExpressionEvaluator.Evaluate(DataValue, inputParameter, out _);
+                }
+
+            }
+
+            #endregion
+
+            // 对引用类型检查 null
+            if (!DataType.IsValueType && inputParameter is null)
+            {
+                throw new Exception($"[arg{Index}][{Name}][{DataType}]参数不能为null");
+            }
+            if (DataType == typeof(string)) // 转为字符串
+            {
+                return inputParameter.ToString();
+            }
+            var inputParameterType = inputParameter.GetType();
+            if (DataType.IsSubclassOf(inputParameterType)) // 入参类型 是 预入参数据类型 的 子类/实现类 
+            {
+                // 方法入参中，父类不能隐式转为子类，这里需要进行强制转换
+                return ObjectConvertHelper.ConvertParentToChild(inputParameter, DataType);
+            }
+            if (DataType.IsAssignableFrom(inputParameterType))  // 入参类型 是 预入参数据类型 的 父类/接口
+            {
+                return inputParameter;
+            }
+
+            throw new Exception($"[arg{Index}][{Name}][{DataType}]入参类型不符合，当前预入参类型为{inputParameterType}");
+        }
+
         public override string ToString()
         {
             return $"[{this.Index}] {this.Name} : {this.ExplicitType?.FullName} -> {this.DataType?.FullName}";

Library/Network/WebSocket/Handle/Attribute.cs

@@ -9,7 +9,7 @@ using System.Threading.Tasks;
 namespace Serein.Library.Network.WebSocketCommunication.Handle
 {
     /// <summary>
-    /// 表示参数可以为空(Net462不能使用NutNull的情况）
+    /// 表示参数不能为空(Net462不能使用NutNull的情况）
     /// </summary>
     public sealed class NeedfulAttribute : Attribute
     {

Library/Serein.Library.csproj

@@ -38,6 +38,8 @@
 
   <ItemGroup>
 
+    <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.0" />
+
     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageReference Include="System.Reactive" Version="6.0.1" />
     <PackageReference Include="System.Threading.Channels" Version="8.0.0" />

Library/Utils/ChannelFlowInterrupt.cs

@@ -1,353 +0,0 @@
-#region plan 2
-using System;
-using System.Collections.Concurrent;
-using System.Threading;
-using System.Threading.Channels;
-using System.Threading.Tasks;
-
-namespace Serein.Library.Utils
-{
-    /// <summary>
-    /// 流程中断管理
-    /// </summary>
-    public class ChannelFlowInterrupt
-    {
-        /// <summary>
-        /// 中断取消类型
-        /// </summary>
-        public enum CancelType
-        {
-            Manual,
-            Error,
-            Overtime
-        }
-
-        // 使用并发字典管理每个信号对应的 Channel
-        private readonly ConcurrentDictionary<string, Channel<CancelType>> _channels = new ConcurrentDictionary<string, Channel<CancelType>>();
-
-        /// <summary>
-        /// 创建信号并指定超时时间，到期后自动触发（异步方法）
-        /// </summary>
-        /// <param name="signal">信号标识符</param>
-        /// <param name="outTime">超时时间</param>
-        /// <returns>等待任务</returns>
-        public async Task<CancelType> GetCreateChannelWithTimeoutAsync(string signal, TimeSpan outTime)
-        {
-            var channel = GetOrCreateChannel(signal);
-            var cts = new CancellationTokenSource();
-
-            // 异步任务：超时后自动触发信号
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    await Task.Delay(outTime, cts.Token);
-                    if (!cts.Token.IsCancellationRequested)
-                    {
-                        await channel.Writer.WriteAsync(CancelType.Overtime);
-                    }
-                }
-                catch (OperationCanceledException)
-                {
-                    // 超时任务被取消
-                }
-                finally
-                {
-                    cts?.Dispose();
-                }
-            }, cts.Token);
-
-            // 等待信号传入（超时或手动触发）
-            try
-            {
-                var result = await channel.Reader.ReadAsync();
-                return result;
-            }
-            catch
-            {
-                return CancelType.Error;
-            }
-
-        }
-
-
-        /// <summary>
-        /// 创建信号，直到手动触发（异步方法）
-        /// </summary>
-        /// <param name="signal">信号标识符</param>
-        /// <returns>等待任务</returns>
-        public async Task<CancelType> GetOrCreateChannelAsync(string signal)
-        {
-            try
-            {
-                var channel = GetOrCreateChannel(signal);
-                // 等待信号传入（超时或手动触发）
-                var result = await channel.Reader.ReadAsync();
-                return result;
-            }
-            catch
-            {
-                return CancelType.Manual;
-            }
-        }
-
-        /// <summary>
-        /// 创建信号并指定超时时间，到期后自动触发（同步阻塞方法）
-        /// </summary>
-        /// <param name="signal">信号标识符</param>
-        /// <param name="timeout">超时时间</param>
-        public async Task<CancelType> CreateChannelWithTimeoutSync(string signal, TimeSpan timeout)
-        {
-            var channel = GetOrCreateChannel(signal);
-            var cts = new CancellationTokenSource();
-            CancellationToken token = cts.Token;
-
-            // 异步任务：超时后自动触发信号
-            _ = Task.Run(async () =>
-            {
-                try
-                {
-                    await Task.Delay(timeout, token);
-                    await channel.Writer.WriteAsync(CancelType.Overtime);
-                }
-                catch (OperationCanceledException ex)
-                {
-                    // 任务被取消
-                    await Console.Out.WriteLineAsync(ex.Message);
-                }
-            });
-
-            // 同步阻塞直到信号触发或超时
-            var result = await channel.Reader.ReadAsync();
-            return result;
-
-        }
-
-        /// <summary>
-        /// 触发信号
-        /// </summary>
-        /// <param name="signal">信号字符串</param>
-        /// <returns>是否成功触发</returns>
-        public bool TriggerSignal(string signal)
-        {
-            //if (_channels.TryGetValue(signal, out var channel))
-            //{
-            //    // 手动触发信号
-            //    channel.Writer.TryWrite(CancelType.Manual);
-            //    return true;
-            //}
-            //return false;
-
-
-            try
-            {
-                if (_channels.TryGetValue(signal, out var channel))
-                {
-                    // 手动触发信号
-                    channel.Writer.TryWrite(CancelType.Manual);
-
-                    // 完成写入，标记该信号通道不再接受新写入
-                    channel.Writer.Complete();
-
-                    // 触发后移除信号
-                    _channels.TryRemove(signal, out _);
-
-                    return true;
-                }
-                return false;
-            }
-            catch
-            {
-
-                return false;
-            }
-
-        }
-
-        /// <summary>
-        /// 取消所有任务
-        /// </summary>
-        public void CancelAllTasks()
-        {
-            foreach (var channel in _channels.Values)
-            {
-                try
-                {
-                    channel.Writer.Complete();
-                }
-                finally
-                {
-
-                }
-            }
-            _channels.Clear();
-        }
-
-        /// <summary>
-        /// 获取或创建指定信号的 Channel
-        /// </summary>
-        /// <param name="signal">信号字符串</param>
-        /// <returns>对应的 Channel</returns>
-        private Channel<CancelType> GetOrCreateChannel(string signal)
-        {
-            return _channels.GetOrAdd(signal, _ => Channel.CreateUnbounded<CancelType>());
-        }
-    }
-}
-
-#endregion
-
-#region plan 3
-
-//using System;
-//using System.Collections.Concurrent;
-//using System.Threading;
-//using System.Threading.Channels;
-//using System.Threading.Tasks;
-
-//namespace Serein.Library.Utils
-//{
-//    /// <summary>
-//    /// 流程中断管理类，提供了基于 Channel 的异步中断机制
-//    /// </summary>
-//    public class ChannelFlowInterrupt
-//    {
-//        /// <summary>
-//        /// 中断取消类型
-//        /// </summary>
-//        public enum CancelType
-//        {
-//            Manual,   // 手动触发
-//            Overtime, // 超时触发
-//            Discard   // 丢弃触发
-//        }
-
-//        // 使用并发字典管理每个信号对应的 Channel 和状态
-//        private readonly ConcurrentDictionary<string, (Channel<CancelType> Channel, bool IsCancelled, bool IsDiscardMode)> _channels
-//            = new ConcurrentDictionary<string, (Channel<CancelType>, bool, bool)>();
-
-//        // 锁对象，用于保护并发访问
-//        private readonly object _lock = new object();
-
-//        /// <summary>
-//        /// 创建带有超时功能的信号，超时后自动触发
-//        /// </summary>
-//        public async Task<CancelType> GetCreateChannelWithTimeoutAsync(string signal, TimeSpan outTime)
-//        {
-//            var (channel, isCancelled, isDiscardMode) = GetOrCreateChannel(signal);
-
-//            // 如果信号已取消或在丢弃模式下，立即返回丢弃类型
-//            if (isCancelled || isDiscardMode) return CancelType.Discard;
-
-//            var cts = new CancellationTokenSource();
-
-//            _ = Task.Run(async () =>
-//            {
-//                try
-//                {
-//                    await Task.Delay(outTime, cts.Token);
-//                    if (!cts.Token.IsCancellationRequested && !isCancelled)
-//                    {
-//                        await channel.Writer.WriteAsync(CancelType.Overtime);
-//                    }
-//                }
-//                catch (OperationCanceledException)
-//                {
-//                    // 处理任务取消的情况
-//                }
-//                finally
-//                {
-//                    cts.Dispose();
-//                }
-//            }, cts.Token);
-
-//            return await channel.Reader.ReadAsync();
-//        }
-
-//        /// <summary>
-//        /// 创建或获取现有信号，等待手动触发
-//        /// </summary>
-//        public async Task<CancelType> GetOrCreateChannelAsync(string signal)
-//        {
-//            var (channel, isCancelled, isDiscardMode) = GetOrCreateChannel(signal);
-
-//            // 如果信号已取消或在丢弃模式下，立即返回丢弃类型
-//            if (isCancelled || isDiscardMode) return CancelType.Discard;
-
-//            return await channel.Reader.ReadAsync();
-//        }
-
-//        /// <summary>
-//        /// 触发信号并将其移除
-//        /// </summary>
-//        public bool TriggerSignal(string signal)
-//        {
-//            lock (_lock)
-//            {
-//                if (_channels.TryGetValue(signal, out var channelInfo))
-//                {
-//                    var (channel, isCancelled, isDiscardMode) = channelInfo;
-
-//                    // 如果信号未被取消，则触发并标记为已取消
-//                    if (!isCancelled)
-//                    {
-//                        channel.Writer.TryWrite(CancelType.Manual);
-//                        _channels[signal] = (channel, true, false); // 标记为已取消
-//                        _channels.TryRemove(signal, out _); // 从字典中移除信号
-//                        return true;
-//                    }
-//                }
-//            }
-//            return false;
-//        }
-
-//        /// <summary>
-//        /// 启用丢弃模式，所有后续获取的信号将直接返回丢弃类型
-//        /// </summary>
-//        /// <param name="signal">信号标识符</param>
-//        public void EnableDiscardMode(string signal,bool state = true)
-//        {
-//            lock (_lock)
-//            {
-//                if (_channels.TryGetValue(signal, out var channelInfo))
-//                {
-//                    var (channel, isCancelled, _) = channelInfo;
-//                    _channels[signal] = (channel, isCancelled, state); // 标记为丢弃模式
-//                }
-//            }
-//        }
-
-//        /// <summary>
-//        /// 取消所有任务
-//        /// </summary>
-//        public void CancelAllTasks()
-//        {
-//            foreach (var (channel, _, _) in _channels.Values)
-//            {
-//                try
-//                {
-//                    channel.Writer.Complete();
-//                }
-//                catch
-//                {
-//                    // 忽略完成时的异常
-//                }
-//            }
-//            _channels.Clear();
-//        }
-
-//        /// <summary>
-//        /// 获取或创建指定信号的 Channel 通道
-//        /// </summary>
-//        private (Channel<CancelType>, bool, bool) GetOrCreateChannel(string signal)
-//        {
-//            lock (_lock)
-//            {
-//                return _channels.GetOrAdd(signal, _ => (Channel.CreateUnbounded<CancelType>(), false, false));
-//            }
-//        }
-//    }
-//}
-
-
-#endregion

Library/Utils/FlowTrigger/ChannelFlowInterrupt.cs

@@ -10,41 +10,15 @@ using System.Threading.Channels;
 using System.Threading.Tasks;
 using System.Transactions;
 
-namespace Serein.Library
+namespace Serein.Library.Utils
 {
 
 
-    /// <summary>
-    /// 触发类型
-    /// </summary>
-    public enum TriggerDescription
-    {
-        /// <summary>
-        /// 外部触发
-        /// </summary>
-        External,
-        /// <summary>
-        /// 超时触发
-        /// </summary>
-        Overtime,
-        /// <summary>
-        /// 触发了，但类型不一致
-        /// </summary>
-        TypeInconsistency
-    }
-
-
-    public class TriggerResult<TResult>
-    {
-        public TriggerDescription Type { get; set; }
-        public TResult Value { get; set; }
-    }
-
     /// <summary>
     /// 信号触发器类，带有消息广播功能。
     /// 使用枚举作为标记，创建
     /// </summary>
-    public class TaskFlowTrigger<TSignal> : IFlowTrigger<TSignal> where TSignal : struct, Enum
+    public class ValueTaskFlowTrigger<TSignal>
     {
         // 使用并发字典管理每个信号对应的广播列表
         private readonly ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>> _subscribers = new ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>>();
@@ -73,7 +47,7 @@ namespace Serein.Library
         }
 
 
-       
+
         /// <summary>
         /// 等待触发器并指定超时的时间
         /// </summary>
@@ -81,7 +55,7 @@ namespace Serein.Library
         /// <param name="signal">等待信号</param>
         /// <param name="outTime">超时时间</param>
         /// <returns></returns>
-        public async Task<TriggerResult<TResult>> WaitTriggerWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime)
+        public async ValueTask<TriggerResult<TResult>> WaitTriggerWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime)
         {
             var subject = GetOrCreateSubject(signal);
             var cts = new CancellationTokenSource();
@@ -121,13 +95,14 @@ namespace Serein.Library
         /// <typeparam name="TResult"></typeparam>
         /// <param name="signal"></param>
         /// <returns></returns>
-        public async Task<TriggerResult<TResult>> WaitTriggerAsync<TResult>(TSignal signal)
+        public async ValueTask<TriggerResult<TResult>> WaitTriggerAsync<TResult>(TSignal signal)
         {
+
             var taskCompletionSource = new TaskCompletionSource<TriggerResult<object>>();
             var subscription = Subscribe<TResult>(signal, taskCompletionSource.SetResult);
             var result = await taskCompletionSource.Task;
             subscription.Dispose(); // 取消订阅
-            if(result.Value is TResult data)
+            if (result.Value is TResult data)
             {
                 return new TriggerResult<TResult>()
                 {
@@ -184,23 +159,5 @@ namespace Serein.Library
 
 
 
-    /// <summary>
-    /// 观察者类，用于包装 Action
-    /// </summary>
-    public class Observer<T> : IObserver<T>
-    {
-        private readonly Action<T> _onNext;
 
-        public Observer(Action<T> onNext)
-        {
-            _onNext = onNext;
-        }
-
-        public void OnCompleted() { }
-        public void OnError(Exception error) { }
-        public void OnNext(T value)
-        {
-            _onNext?.Invoke(value);
-        }
-    }
 }

Library/Utils/FlowTrigger/ChannelFlowTrigger.cs

@@ -1,6 +1,4 @@
-
+using Serein.Library.Api;
-
-using Serein.Library.Api;
 using System;
 using System.Collections.Concurrent;
 using System.Threading;
@@ -13,7 +11,7 @@ namespace Serein.Library.Utils
 
 
 
-    public class ChannelFlowTrigger<TSignal> : IFlowTrigger<TSignal> 
+    public class ChannelFlowTrigger<TSignal> : IFlowTrigger<TSignal>
     {
         // 使用并发字典管理每个枚举信号对应的 Channel
         private readonly ConcurrentDictionary<TSignal, Channel<TriggerResult<object>>> _channels = new ConcurrentDictionary<TSignal, Channel<TriggerResult<object>>>();

Library/Utils/FlowTrigger/TaskFlowTrigger.cs

@@ -0,0 +1,160 @@
+using Microsoft.Extensions.ObjectPool;
+using Newtonsoft.Json.Linq;
+using Serein.Library.Api;
+using Serein.Library.Utils;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using System.Transactions;
+
+namespace Serein.Library.Utils
+{
+
+    /// <summary>
+    /// 信号触发器类，带有消息广播功能。
+    /// 使用枚举作为标记，创建
+    /// </summary>
+    public class TaskFlowTrigger<TSignal> : IFlowTrigger<TSignal>
+    {
+        // 使用并发字典管理每个信号对应的广播列表
+        private readonly ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>> _subscribers = new ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>>();
+        private readonly TriggerResultPool _triggerResultPool = new TriggerResultPool();
+        /// <summary>
+        /// 获取或创建指定信号的 Subject（消息广播者）
+        /// </summary>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <returns>对应的 Subject</returns>
+        private Subject<TriggerResult<object>> GetOrCreateSubject(TSignal signal)
+        {
+            return _subscribers.GetOrAdd(signal, _ => new Subject<TriggerResult<object>>());
+        }
+
+        /// <summary>
+        /// 订阅指定信号的消息
+        /// </summary>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <param name="action">订阅者</param>
+        /// <returns>取消订阅的句柄</returns>
+        private IDisposable Subscribe<TResult>(TSignal signal, Action<TriggerResult<object>> action)
+        {
+            IObserver<TriggerResult<object>> observer = new Observer<TriggerResult<object>>(action);
+            var subject = GetOrCreateSubject(signal);
+            return subject.Subscribe(observer); // 返回取消订阅的句柄
+        }
+
+
+
+        /// <summary>
+        /// 等待触发器并指定超时的时间
+        /// </summary>
+        /// <typeparam name="TResult">返回值类型</typeparam>
+        /// <param name="signal">等待信号</param>
+        /// <param name="outTime">超时时间</param>
+        /// <returns></returns>
+        public async Task<TriggerResult<TResult>> WaitTriggerWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime)
+        {
+            var subject = GetOrCreateSubject(signal);
+            var cts = new CancellationTokenSource();
+
+            // 超时任务：延迟后触发超时信号
+            var timeoutTask = Task.Delay(outTime, cts.Token).ContinueWith(t =>
+            {
+                if (!cts.Token.IsCancellationRequested)
+                {
+                    var outResult = _triggerResultPool.Get();
+                    outResult.Type = TriggerDescription.Overtime;
+                    subject.OnNext(outResult);
+                    subject.OnCompleted();
+                }
+            }, cts.Token, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Default);
+
+            var result = await WaitTriggerAsync<TResult>(signal); // 获取触发的结果
+            cts.Cancel();  // 取消超时任务
+            await timeoutTask; // 确保超时任务完成
+            cts.Dispose();
+            return result;
+
+        }
+
+        /// <summary>
+        /// 等待触发
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="signal"></param>
+        /// <returns></returns>
+        public async Task<TriggerResult<TResult>> WaitTriggerAsync<TResult>(TSignal signal)
+        {
+            var taskCompletionSource = new TaskCompletionSource<TriggerResult<object>>();
+            var subscription = Subscribe<TResult>(signal, taskCompletionSource.SetResult);
+            var result = await taskCompletionSource.Task;
+            subscription.Dispose(); // 取消订阅
+            var result2 = result.Value is TResult data
+                ? new TriggerResult<TResult> { Value = data, Type = TriggerDescription.External }
+                : new TriggerResult<TResult> { Type = TriggerDescription.TypeInconsistency };
+            _triggerResultPool.Return(result); // 将结果归还池中
+            return result2;
+        }
+
+
+        /// <summary>
+        /// 手动触发信号，并广播给所有订阅者
+        /// </summary>
+        /// <typeparam name="TResult">触发类型</typeparam>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <param name="value">传递的数据</param>
+        /// <returns>是否成功触发</returns>
+        public Task<bool> InvokeTriggerAsync<TResult>(TSignal signal, TResult value)
+        {
+            if (_subscribers.TryGetValue(signal, out var subject))
+            {
+                var result = _triggerResultPool.Get();
+                result.Type = TriggerDescription.External;
+                result.Value = value;
+                subject.OnNext(result); // 广播给所有订阅者
+                subject.OnCompleted(); // 通知订阅结束
+                return Task.FromResult(true);
+            }
+            return Task.FromResult(false);
+        }
+        /// <summary>
+        /// 取消所有任务
+        /// </summary>
+
+        public void CancelAllTrigger()
+        {
+            foreach (var subject in _subscribers.Values)
+            {
+                subject.OnCompleted(); // 通知所有订阅者结束
+            }
+            _subscribers.Clear();
+        }
+    }
+
+
+
+
+    /// <summary>
+    /// 观察者类，用于包装 Action
+    /// </summary>
+    public class Observer<T> : IObserver<T>
+    {
+        private readonly Action<T> _onNext;
+
+        public Observer(Action<T> onNext)
+        {
+            _onNext = onNext;
+        }
+
+        public void OnCompleted() { }
+        public void OnError(Exception error) { }
+        public void OnNext(T value)
+        {
+            _onNext?.Invoke(value);
+        }
+    }
+}

Library/Utils/FlowTrigger/TriggerResult.cs

@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library.Utils
+{
+    public class TriggerResult<TResult>
+    {
+        public TriggerDescription Type { get; set; }
+        public TResult Value { get; set; }
+    }
+
+    /// <summary>
+    /// 对象池队列
+    /// </summary>
+    public class ConcurrentExpandingObjectPool<T> where T : class, new()
+    {
+        private readonly ConcurrentQueue<T> _pool; // 存储池中对象的队列
+
+        public ConcurrentExpandingObjectPool(int initialCapacity)
+        {
+            // 初始化对象池，初始容量为 initialCapacity
+            _pool = new ConcurrentQueue<T>();
+
+            // 填充初始对象
+            for (int i = 0; i < initialCapacity; i++)
+            {
+                _pool.Enqueue(new T());
+            }
+        }
+
+        /// <summary>
+        /// 获取一个对象，如果池中没有对象，则动态创建新的对象
+        /// </summary>
+        /// <returns>池中的一个对象</returns>
+        public T Get()
+        {
+            // 尝试从池中获取一个对象
+            if (!_pool.TryDequeue(out var item))
+            {
+                // 如果池为空，则创建一个新的对象
+                item = new T();
+            }
+
+            return item;
+        }
+
+        /// <summary>
+        /// 将一个对象归还到池中
+        /// </summary>
+        /// <param name="item">需要归还的对象</param>
+        public void Return(T item)
+        {
+            // 将对象归还到池中
+            _pool.Enqueue(item);
+        }
+
+        /// <summary>
+        /// 获取当前池中的对象数
+        /// </summary>
+        public int CurrentSize => _pool.Count;
+
+        /// <summary>
+        /// 清空池中的所有对象
+        /// </summary>
+        public void Clear()
+        {
+            while (_pool.TryDequeue(out _)) { } // 清空队列
+        }
+    }
+
+    /// <summary>
+    /// 使用 ObjectPool 来复用 TriggerResult 对象
+    /// </summary>
+      // 示例 TriggerResult 对象池
+    public class TriggerResultPool
+    {
+        private readonly ConcurrentExpandingObjectPool<TriggerResult<object>> _objectPool;
+
+        public TriggerResultPool(int defaultCapacity = 30)
+        {
+            _objectPool = new ConcurrentExpandingObjectPool<TriggerResult<object>>(defaultCapacity);
+        }
+
+        public TriggerResult<object> Get() => _objectPool.Get();
+
+        public void Return(TriggerResult<object> result) => _objectPool.Return(result);
+    }
+
+
+    /// <summary>
+    /// 触发类型
+    /// </summary>
+    public enum TriggerDescription
+    {
+        /// <summary>
+        /// 外部触发
+        /// </summary>
+        External,
+        /// <summary>
+        /// 超时触发
+        /// </summary>
+        Overtime,
+        /// <summary>
+        /// 触发了，但类型不一致
+        /// </summary>
+        TypeInconsistency
+    }
+}

Net462DllTest/Trigger/PrakingDevice.cs

@@ -1,5 +1,6 @@
 using Net462DllTest.LogicControl;
 using Serein.Library;
+using Serein.Library.Utils.FlowTrigger;
 
 namespace Net462DllTest.Trigger
 {

Net462DllTest/Trigger/SiemensPlcDevice.cs

@@ -8,6 +8,7 @@ using Net462DllTest.Signal;
 using Net462DllTest.Utils;
 using Serein.Library;
 using Serein.Library.Utils;
+using Serein.Library.Utils.FlowTrigger;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;

Net462DllTest/Trigger/ViewManagement.cs

@@ -9,6 +9,7 @@ using System.Threading;
 using System.Windows.Forms;
 using System.Windows.Threading;
 using Serein.Library.Utils;
+using Serein.Library.Utils.FlowTrigger;
 
 namespace Net462DllTest.Trigger
 {

NodeFlow/Env/FlowEnvironment.cs

@@ -14,13 +14,13 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Numerics;
+using System.Reactive;
 using System.Reflection;
 using System.Reflection.Metadata.Ecma335;
 using System.Runtime.Loader;
 using System.Security.AccessControl;
 using System.Text;
 using System.Xml.Linq;
-using static Serein.Library.Utils.ChannelFlowInterrupt;
 
 namespace Serein.NodeFlow.Env
 {
@@ -31,7 +31,7 @@ namespace Serein.NodeFlow.Env
     /// <summary>
     /// 运行环境
     /// </summary>
-    public class FlowEnvironment : IFlowEnvironment, ISereinIOC
+    public class FlowEnvironment : IFlowEnvironment, ISereinIOC 
     {
         /// <summary>
         /// 节点的命名空间
@@ -47,7 +47,6 @@ namespace Serein.NodeFlow.Env
         public FlowEnvironment(UIContextOperation uiContextOperation)
         {
             this.sereinIOC = new SereinIOC();
-            this.ChannelFlowInterrupt = new ChannelFlowInterrupt();
             this.IsGlobalInterrupt = false;
             this.flowStarter = null;
             this.sereinIOC.OnIOCMembersChanged += e =>
@@ -244,10 +243,10 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         public bool IsGlobalInterrupt { get; set; }
 
-        /// <summary>
+        ///// <summary>
-        /// 流程中断器
+        ///// 流程中断器
-        /// </summary>
+        ///// </summary>
-        public ChannelFlowInterrupt ChannelFlowInterrupt { get; set; }
+        //public ChannelFlowInterrupt ChannelFlowInterrupt { get; set; }
 
         /// <summary>
         /// <para>单例模式IOC容器，内部维护了一个实例字典，默认使用类型的FullName作为Key，如果以“接口-实现类”的方式注册，那么将使用接口类型的FullName作为Key。</para>
@@ -377,7 +376,6 @@ namespace Serein.NodeFlow.Env
         /// <returns></returns>
         public async Task<bool> StartFlowAsync()
         {
-            ChannelFlowInterrupt?.CancelAllTasks();
             flowStarter = new FlowStarter();
             var nodes = NodeModels.Values.ToList();
 
@@ -453,7 +451,7 @@ namespace Serein.NodeFlow.Env
         /// <returns></returns>
         public async Task<object> InvokeNodeAsync(IDynamicContext context, string nodeGuid)
         {
-            object result = true;
+            object result = new Unit();
             if (this.NodeModels.TryGetValue(nodeGuid, out var model))
             {
                 result =  await model.ExecutingAsync(context);
@@ -466,7 +464,6 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         public Task<bool> ExitFlowAsync()
         {
-            ChannelFlowInterrupt?.CancelAllTasks();
             flowStarter?.Exit();
             UIContextOperation?.Invoke(() => OnFlowRunComplete?.Invoke(new FlowEventArgs()));
             flowStarter = null;
@@ -555,8 +552,11 @@ namespace Serein.NodeFlow.Env
                 LoadLibrary(dllFilePath);  // 加载项目文件时加载对应的程序集
             }
 
-            _ = LoadNodeInfosAsync(projectData.Nodes.ToList());
+            _ = Task.Run( async () =>
-            SetStartNodeAsync(projectData.StartNode);
+            {
+                await LoadNodeInfosAsync(projectData.Nodes.ToList());
+                await SetStartNodeAsync(projectData.StartNode);
+            });
 
         }
 
@@ -745,7 +745,7 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         /// <param name="List<NodeInfo>">节点信息</param>
         /// <returns></returns>
-        public Task LoadNodeInfosAsync(List<NodeInfo> nodeInfos)
+        public async Task LoadNodeInfosAsync(List<NodeInfo> nodeInfos)
         {
             #region 从NodeInfo创建NodeModel
             foreach (NodeInfo? nodeInfo in nodeInfos)
@@ -779,7 +779,7 @@ namespace Serein.NodeFlow.Env
                 nodeModel.LoadInfo(nodeInfo); // 创建节点model
                 TryAddNode(nodeModel); // 加载项目时将节点加载到环境中
                 
-                UIContextOperation?.Invoke(() => 
+                await UIContextOperation.InvokeAsync(() => 
                     OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeModel, nodeInfo.Position))); // 添加到UI上
             }
             #endregion
@@ -798,77 +798,92 @@ namespace Serein.NodeFlow.Env
 
             foreach (NodeInfo nodeInfo in needPlaceNodeInfos)
             {
-                if (NodeModels.TryGetValue(nodeInfo.Guid, out var nodeMoel) &&
+                if (NodeModels.TryGetValue(nodeInfo.Guid, out var nodeModel) &&
                     NodeModels.TryGetValue(nodeInfo.ParentNodeGuid, out var containerNode)
                     && containerNode is INodeContainer nodeContainer)
                 {
-                    nodeMoel.ContainerNode = containerNode;  // 放置节点
+                    var result = nodeContainer.PlaceNode(nodeModel);
-                    containerNode.ChildrenNode.Add(nodeMoel);
+                    if (result)
-                    nodeContainer.PlaceNode(nodeMoel);
+                    {
-
+                        await UIContextOperation.InvokeAsync(() => OnNodePlace?.Invoke(
-                    UIContextOperation?.Invoke(() => OnNodePlace?.Invoke(
+                            new NodePlaceEventArgs(nodeModel.Guid, containerNode.Guid)));
-                        new NodePlaceEventArgs(nodeMoel.Guid, containerNode.Guid)));
+                    }
+                    
 
                 }
             }
             #endregion
 
-            _ = Task.Run(async () =>
+            #region 确定节点之间的方法调用关系
+            foreach (var nodeInfo in nodeInfos)
             {
-                await Task.Delay(100);
+                var fromNodeModel = GuidToModel(nodeInfo.Guid);
-                #region 确定节点之间的方法调用关系
+                if (fromNodeModel is null) continue;
-                foreach (var nodeInfo in nodeInfos)
+                List<(ConnectionInvokeType connectionType, string[] guids)> allToNodes = [(ConnectionInvokeType.IsSucceed,nodeInfo.TrueNodes),
-                {
-                    if (!NodeModels.TryGetValue(nodeInfo.Guid, out NodeModelBase? fromNode))
-                    {
-                        // 不存在对应的起始节点
-                        continue;
-                    }
-                    List<(ConnectionInvokeType connectionType, string[] guids)> allToNodes = [(ConnectionInvokeType.IsSucceed,nodeInfo.TrueNodes),
                                                                                     (ConnectionInvokeType.IsFail,   nodeInfo.FalseNodes),
                                                                                     (ConnectionInvokeType.IsError,  nodeInfo.ErrorNodes),
                                                                                     (ConnectionInvokeType.Upstream, nodeInfo.UpstreamNodes)];
-
+                foreach ((ConnectionInvokeType connectionType, string[] toNodeGuids) item in allToNodes)
-                    List<(ConnectionInvokeType, NodeModelBase[])> fromNodes = allToNodes.Where(info => info.guids.Length > 0)
-                                                                         .Select(info => (info.connectionType,
-                                                                                          info.guids.Where(guid => NodeModels.ContainsKey(guid)).Select(guid => NodeModels[guid])
-                                                                                            .ToArray()))
-                                                                         .ToList();
-                    // 遍历每种类型的节点分支（四种）
-                    foreach ((ConnectionInvokeType connectionType, NodeModelBase[] toNodes) item in fromNodes)
-                    {
-                        // 遍历当前类型分支的节点（确认连接关系）
-                        foreach (var toNode in item.toNodes)
-                        {
-                            _ = ConnectInvokeOfNode(fromNode, toNode, item.connectionType); // 加载时确定节点间的连接关系
-                        }
-                    }
-                }
-                #endregion
-
-                #region 确定节点之间的参数调用关系
-                foreach (var toNode in NodeModels.Values)
                 {
-                    if (toNode.MethodDetails.ParameterDetailss == null)
+                    // 遍历当前类型分支的节点（确认连接关系）
+                    foreach (var toNodeGuid in item.toNodeGuids)
                     {
-                        continue;
+                        var toNodeModel = GuidToModel(toNodeGuid);
-                    }
+                        if (toNodeModel is null) continue;
-                    for (var i = 0; i < toNode.MethodDetails.ParameterDetailss.Length; i++)
+                        var isSuccessful = ConnectInvokeOfNode(fromNodeModel, toNodeModel, item.connectionType); // 加载时确定节点间的连接关系
-                    {
-                        var pd = toNode.MethodDetails.ParameterDetailss[i];
-                        if (!string.IsNullOrEmpty(pd.ArgDataSourceNodeGuid)
-                            && NodeModels.TryGetValue(pd.ArgDataSourceNodeGuid, out var fromNode))
-                        {
-
-                            _ = ConnectArgSourceOfNodeAsync(fromNode, toNode, pd.ArgDataSourceType, pd.Index);
-                        }
                     }
                 }
-                #endregion
-            });
-            UIContextOperation?.Invoke(() => OnProjectLoaded?.Invoke(new ProjectLoadedEventArgs()));
 
-            return Task.CompletedTask;
+
+                //List<(ConnectionInvokeType connectionType, string[] guids)> allToNodes = [(ConnectionInvokeType.IsSucceed,nodeInfo.TrueNodes),
+                //                                                                (ConnectionInvokeType.IsFail,   nodeInfo.FalseNodes),
+                //                                                                (ConnectionInvokeType.IsError,  nodeInfo.ErrorNodes),
+                //                                                                (ConnectionInvokeType.Upstream, nodeInfo.UpstreamNodes)];
+
+                //List<(ConnectionInvokeType, NodeModelBase[])> fromNodes = allToNodes.Where(info => info.guids.Length > 0)
+                //                                                     .Select(info => (info.connectionType,
+                //                                                                      info.guids.Where(guid => NodeModels.ContainsKey(guid)).Select(guid => NodeModels[guid])
+                //                                                                        .ToArray()))
+                //                                                     .ToList();
+                // 遍历每种类型的节点分支（四种）
+                //foreach ((ConnectionInvokeType connectionType, NodeModelBase[] toNodes) item in nodeInfo)
+                //{
+                //    // 遍历当前类型分支的节点（确认连接关系）
+                //    foreach (var toNode in item.toNodes)
+                //    {
+                //        _ = ConnectInvokeOfNode(fromNode, toNode, item.connectionType); // 加载时确定节点间的连接关系
+                //    }
+                //}
+            }
+            #endregion
+
+            #region 确定节点之间的参数调用关系
+            foreach (var toNode in NodeModels.Values)
+            {
+                if (toNode.MethodDetails.ParameterDetailss == null)
+                {
+                    continue;
+                }
+                for (var i = 0; i < toNode.MethodDetails.ParameterDetailss.Length; i++)
+                {
+                    var pd = toNode.MethodDetails.ParameterDetailss[i];
+                    if (!string.IsNullOrEmpty(pd.ArgDataSourceNodeGuid)
+                        && NodeModels.TryGetValue(pd.ArgDataSourceNodeGuid, out var fromNode))
+                    {
+
+                        _ = ConnectArgSourceOfNodeAsync(fromNode, toNode, pd.ArgDataSourceType, pd.Index);
+                    }
+                }
+            }
+            #endregion
+
+
+            await UIContextOperation.InvokeAsync(() =>
+            {
+                UIContextOperation?.Invoke(() => OnProjectLoaded?.Invoke(new ProjectLoadedEventArgs()));
+            });
+
+            return;
         }
 
         /// <summary>
@@ -925,24 +940,28 @@ namespace Serein.NodeFlow.Env
         public async Task<bool> PlaceNodeToContainerAsync(string nodeGuid, string containerNodeGuid)
         {
             // 获取目标节点与容器节点
-            var nodeMoel = GuidToModel(nodeGuid);
+            var nodeModel = GuidToModel(nodeGuid);
-            if (nodeMoel is null ) return false;
+            if (nodeModel is null ) return false;
 
-            if(nodeMoel.ContainerNode is INodeContainer tmpContainer)
+            if(nodeModel.ContainerNode is INodeContainer tmpContainer)
             {
                 SereinEnv.WriteLine(InfoType.WARN, $"节点放置失败，节点[{nodeGuid}]已经放置于容器节点[{((NodeModelBase)tmpContainer).Guid}]");
                 return false; 
             }
 
-            var containerNode = GuidToModel(containerNodeGuid);
+            var containerNode = GuidToModel(containerNodeGuid); // 获取容器节点
             if (containerNode is not INodeContainer nodeContainer) return false;
 
-            nodeMoel.ContainerNode = containerNode;  // 放置节点
+            var result = nodeContainer.PlaceNode(nodeModel); // 放置在容器节点
-            containerNode.ChildrenNode.Add(nodeMoel);
+            if (result)
-            nodeContainer.PlaceNode(nodeMoel);
+            {
-            OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
+                _ = UIContextOperation?.InvokeAsync(() =>
-            return true;
+                {
-            
+                    OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
+                });
+            }
+            return result;
+
         }
 
         /// <summary>
@@ -952,18 +971,24 @@ namespace Serein.NodeFlow.Env
         public async Task<bool> TakeOutNodeToContainerAsync(string nodeGuid)
         {
             // 获取目标节点与容器节点
-            var nodeMoel = GuidToModel(nodeGuid);
+            var nodeModel = GuidToModel(nodeGuid);
-            if (nodeMoel is null) return false;
+            if (nodeModel is null) return false;
 
-            if(nodeMoel.ContainerNode is not INodeContainer nodeContainer)
+            if(nodeModel.ContainerNode is not INodeContainer nodeContainer)
             {
                 return false;
             }
-            nodeContainer.TakeOutNode(nodeMoel); // 从容器节点取出
+            var result = nodeContainer.TakeOutNode(nodeModel); // 从容器节点取出
-            nodeMoel.ContainerNode = null; // 取消映射关系
+            if (result)
-            
+            {
-            OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
+                _ = UIContextOperation?.InvokeAsync(() =>
-            return true;
+                {
+                    OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
+                });
+            }
+            return result;
+
+
         }
 
 
@@ -1000,7 +1025,7 @@ namespace Serein.NodeFlow.Env
                                                                     remoteNode.Guid,
                                                                     JunctionOfConnectionType.Invoke,
                                                                     pCType, // 对应的连接关系
-                                                                    NodeConnectChangeEventArgs.ConnectChangeType.Remote))); // 通知UI
+                                                                    NodeConnectChangeEventArgs.ConnectChangeType.Remove))); // 通知UI
 
                 }
             }
@@ -1240,149 +1265,6 @@ namespace Serein.NodeFlow.Env
             return Task.FromResult(StartNode?.Guid ?? string.Empty);
         }
 
-        /// <summary>
-        /// 中断指定节点，并指定中断等级。
-        /// </summary>
-        /// <param name="nodeGuid">被中断的目标节点Guid</param>
-        /// <param name="interruptClass">中断级别</param>
-        /// <returns>操作是否成功</returns>
-        public Task<bool> SetNodeInterruptAsync(string nodeGuid, bool isInterrupt)
-        {
-           
-
-            var nodeModel = GuidToModel(nodeGuid);
-            if (nodeModel is null) 
-                return Task.FromResult(false);
-            if (!isInterrupt)
-            {
-                nodeModel.CancelInterrupt();
-            }
-            else if (isInterrupt)
-            {
-                nodeModel.DebugSetting.CancelInterruptCallback?.Invoke();
-                nodeModel.DebugSetting.GetInterruptTask = async () =>
-                {
-                    TriggerInterrupt(nodeGuid, "", InterruptTriggerEventArgs.InterruptTriggerType.Monitor);
-                    var result = await ChannelFlowInterrupt.GetOrCreateChannelAsync(nodeGuid);
-                    return result;
-                };
-                nodeModel.DebugSetting.CancelInterruptCallback = () =>
-                {
-                    //nodeModel.DebugSetting.IsInterrupt = false;
-                    ChannelFlowInterrupt.TriggerSignal(nodeGuid);
-                };
-
-            }
-            
-            //nodeModel.DebugSetting.IsInterrupt = true; 
-            if (OperatingSystem.IsWindows())
-            {
-
-                UIContextOperation?.Invoke(() => OnNodeInterruptStateChange?.Invoke(new NodeInterruptStateChangeEventArgs(nodeGuid, isInterrupt))); 
-            }
-            
-            return Task.FromResult(true);
-        }
-
-
-        /// <summary>
-        /// 添加表达式中断
-        /// </summary>
-        /// <param name="key">如果是节点，传入Guid；如果是对象，传入类型FullName</param>
-        /// <param name="expression">合法的条件表达式</param>
-        /// <returns></returns>
-        public Task<bool> AddInterruptExpressionAsync(string key, string expression)
-        {
-            if (string.IsNullOrEmpty(expression)) return Task.FromResult(false);
-            if (dictMonitorObjExpInterrupt.TryGetValue(key, out var condition))
-            {
-                condition.Clear(); // 暂时
-                condition.Add(expression);// 暂时
-            }
-            else
-            {
-                var exps = new List<string>();
-                exps.Add(expression);
-                dictMonitorObjExpInterrupt.TryAdd(key, exps);
-            }
-            return Task.FromResult(true);
-        }
-
-        /// <summary>
-        /// 要监视的对象，以及与其关联的表达式
-        /// </summary>
-        private ConcurrentDictionary<string, List<string>> dictMonitorObjExpInterrupt = [];
-
-        /// <summary>
-        /// 设置对象的监视状态
-        /// </summary>
-        /// <param name="key">如果是节点，传入Guid；如果是对象，传入类型FullName</param>
-        /// <param name="isMonitor">ture监视对象；false取消对象监视</param>
-        /// <returns></returns>
-        public void SetMonitorObjState(string key, bool isMonitor)
-        {
-            if (string.IsNullOrEmpty(key)) { return; }
-            var isExist = dictMonitorObjExpInterrupt.ContainsKey(key);
-            if (isExist)
-            {
-                if (!isMonitor) // 对象存在且需要不监视
-                {
-                    dictMonitorObjExpInterrupt.Remove(key, out _);
-                }
-            }
-            else
-            {
-                if (isMonitor) // 对象不存在且需要监视，添加在集合中。
-                {
-                    dictMonitorObjExpInterrupt.TryAdd(key, new List<string>()); ;
-                }
-            }
-        }
-
-        /// <summary>
-        /// 检查一个对象是否处于监听状态，如果是，则传出与该对象相关的表达式（用于中断），如果不是，则返回false。
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="exps"></param>
-        /// <returns></returns>
-        public Task<(bool, string[])> CheckObjMonitorStateAsync(string key)
-        {
-            if (string.IsNullOrEmpty(key))
-            {
-                var data = (false, Array.Empty<string>());
-                return Task.FromResult(data);
-            }
-            else
-            {
-                var isMonitor = dictMonitorObjExpInterrupt.TryGetValue(key, out var exps);
-
-                if (exps is null)
-                {
-                    var data = (isMonitor, Array.Empty<string>());
-                    return Task.FromResult(data);
-                }
-                else
-                {
-                    var data = (isMonitor, exps.ToArray());
-                    return Task.FromResult(data);
-                }
-
-
-            }
-            
-            //if (exps is null)
-            //{
-            //    var data = (isMonitor, Array.Empty<string>());
-            //    return Task.FromResult(data);
-            //}
-            //else
-            //{
-            //    var data = (isMonitor, exps.ToArray());
-            //    return Task.FromResult(data);
-            //}
-
-        }
-
         /// <summary>
         /// 启动器调用，运行到某个节点时触发了监视对象的更新（对象预览视图将会自动更新）
         /// </summary>
@@ -1406,16 +1288,16 @@ namespace Serein.NodeFlow.Env
         }
 
 
-        /// <summary>
+        ///// <summary>
-        /// 环境执行中断
+        ///// 环境执行中断
-        /// </summary>
+        ///// </summary>
-        /// <returns></returns>
+        ///// <returns></returns>
-        public async Task<CancelType> GetOrCreateGlobalInterruptAsync()
+        //public async Task InterruptNode()
-        {
+        //{
-            IsGlobalInterrupt = true;
+        //    IsGlobalInterrupt = true;
-            var result = await ChannelFlowInterrupt.GetOrCreateChannelAsync(EnvName);
+        //    var result = await ChannelFlowInterrupt.GetOrCreateChannelAsync(EnvName);
-            return result;
+        //    return result;
-        }
+        //}
 
         /// <summary>
         /// 记录节点更改数据，防止重复更改
@@ -1642,7 +1524,7 @@ namespace Serein.NodeFlow.Env
                                                                           toNode.Guid,
                                                                           JunctionOfConnectionType.Invoke,
                                                                           connectionType,
-                                                                          NodeConnectChangeEventArgs.ConnectChangeType.Remote)));
+                                                                          NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
             }
             return true;
         }
@@ -1670,7 +1552,7 @@ namespace Serein.NodeFlow.Env
                                                                           JunctionOfConnectionType.Arg,
                                                                           argIndex,
                                                                           ConnectionArgSourceType.GetPreviousNodeData,
-                                                                          NodeConnectChangeEventArgs.ConnectChangeType.Remote)));
+                                                                          NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
             }
             return true;
         }

NodeFlow/Env/FlowEnvironmentDecorator.cs

@@ -196,16 +196,7 @@ namespace Serein.NodeFlow.Env
             currentFlowEnvironment.ActivateFlipflopNode(nodeGuid);
         }
 
-        public async Task<bool> AddInterruptExpressionAsync(string key, string expression)
+        
-        {
-            return await currentFlowEnvironment.AddInterruptExpressionAsync(key, expression);
-        }
-
-
-        public async Task<(bool, string[])> CheckObjMonitorStateAsync(string key)
-        {
-            return await currentFlowEnvironment.CheckObjMonitorStateAsync(key);
-        }
 
 
         /// <summary>
@@ -329,11 +320,7 @@ namespace Serein.NodeFlow.Env
             return await currentFlowEnvironment.GetEnvInfoAsync();
         }
 
-        public async Task<ChannelFlowInterrupt.CancelType> GetOrCreateGlobalInterruptAsync()
+        
-        {
-            return await currentFlowEnvironment.GetOrCreateGlobalInterruptAsync();
-        }
-
         public async Task<SereinProjectData> GetProjectInfoAsync()
         {
             return await currentFlowEnvironment.GetProjectInfoAsync();
@@ -439,6 +426,24 @@ namespace Serein.NodeFlow.Env
             currentFlowEnvironment.WriteLine(type,  message,  @class);
         }
 
+
+        #region MyRegion
+#if false
+        public async Task<bool> AddInterruptExpressionAsync(string key, string expression)
+        {
+            return await currentFlowEnvironment.AddInterruptExpressionAsync(key, expression);
+        }
+
+
+        public async Task<(bool, string[])> CheckObjMonitorStateAsync(string key)
+        {
+            return await currentFlowEnvironment.CheckObjMonitorStateAsync(key);
+        }
+        public async Task<ChannelFlowInterrupt.CancelType> GetOrCreateGlobalInterruptAsync()
+        {
+            return await currentFlowEnvironment.InterruptNode();
+        }
+
         public void SetMonitorObjState(string key, bool isMonitor)
         {
             currentFlowEnvironment.SetMonitorObjState(key, isMonitor);
@@ -447,8 +452,10 @@ namespace Serein.NodeFlow.Env
         public async Task<bool> SetNodeInterruptAsync(string nodeGuid, bool isInterrupt)
         {
             return await currentFlowEnvironment.SetNodeInterruptAsync(nodeGuid, isInterrupt);
-        }
+        } 
+#endif
 
+        #endregion
         public async Task<string> SetStartNodeAsync(string nodeGuid)
         {
             return await currentFlowEnvironment.SetStartNodeAsync(nodeGuid);

NodeFlow/Env/MsgControllerOfClient.cs

@@ -188,6 +188,27 @@ namespace Serein.NodeFlow.Env
         {
             _ = remoteFlowEnvironment.InvokeTriggerAsync(msgId, state);
         }
+        /// <summary>
+        /// 放置节点
+        /// </summary>
+        /// <param name="msgId"></param>
+        /// <param name="state"></param>
+        [AutoSocketHandle(ThemeValue = EnvMsgTheme.PlaceNode, IsReturnValue = false)]
+        public void PlaceNode([UseMsgId] string msgId, bool state)
+        {
+            _ = remoteFlowEnvironment.InvokeTriggerAsync(msgId, state);
+        }
+        /// <summary>
+        /// 取出节点
+        /// </summary>
+        /// <param name="msgId"></param>
+        /// <param name="state"></param>
+        [AutoSocketHandle(ThemeValue = EnvMsgTheme.TakeOutNode, IsReturnValue = false)]
+        public void TakeOutNode([UseMsgId] string msgId, bool state)
+        {
+            _ = remoteFlowEnvironment.InvokeTriggerAsync(msgId, state);
+        }
+
 
         /// <summary>
         /// 创建节点之间的调用关系

NodeFlow/Env/MsgControllerOfServer.cs

@@ -4,6 +4,7 @@ using Serein.Library.Api;
 using Serein.Library.Network.WebSocketCommunication;
 using Serein.Library.Network.WebSocketCommunication.Handle;
 using Serein.Library.Utils;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Serein.NodeFlow.Env
 {
@@ -267,7 +268,6 @@ namespace Serein.NodeFlow.Env
         }
 
 
-
         /// <summary>
         /// 退出远程环境
         /// </summary>
@@ -298,6 +298,7 @@ namespace Serein.NodeFlow.Env
         public void LoadDll(string dllPath)
         {
         }
+
         /// <summary>
         /// 移除DLL
         /// </summary>
@@ -334,9 +335,30 @@ namespace Serein.NodeFlow.Env
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.RemoveNode)]
         public async Task<object> RemoveNode(string nodeGuid)
         {
-            //var result = environment.RemoveNodeAsync(nodeGuid).GetAwaiter().GetResult();
             var result = await environment.RemoveNodeAsync(nodeGuid);
-            //return result;
+            return new { state = result };
+        }
+        /// <summary>
+        /// 远程从远程环境移除节点
+        /// </summary>
+        /// <param name="nodeGuid"></param>
+        /// <param name="containerNodeGuid"></param>
+        /// <exception cref="NotImplementedException"></exception>
+        [AutoSocketHandle(ThemeValue = EnvMsgTheme.PlaceNode)]
+        public async Task<object> PlaceNode(string nodeGuid, string containerNodeGuid)
+        {
+            var result = await environment.PlaceNodeToContainerAsync(nodeGuid, containerNodeGuid);
+            return new { state = result };
+        }
+        /// <summary>
+        /// 远程从远程环境移除节点
+        /// </summary>
+        /// <param name="nodeGuid"></param>
+        /// <exception cref="NotImplementedException"></exception>
+        [AutoSocketHandle(ThemeValue = EnvMsgTheme.TakeOutNode)]
+        public async Task<object> TakeOutNode(string nodeGuid)
+        {
+            var result = await environment.TakeOutNodeToContainerAsync(nodeGuid);
             return new { state = result };
         }
 
@@ -528,12 +550,13 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         /// <param name="nodeGuid"></param>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.SetStartNode)]
-        public void SetStartNode(string nodeGuid)
+        public async Task<string> SetStartNode([NotNull]string nodeGuid)
         {
-            environment.SetStartNodeAsync(nodeGuid);
+            return await environment.SetStartNodeAsync(nodeGuid);
         }
 
 
+#if false
 
         /// <summary>
         /// 中断指定节点，并指定中断等级。
@@ -544,10 +567,9 @@ namespace Serein.NodeFlow.Env
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.SetNodeInterrupt)]
         public async Task<bool> SetNodeInterruptAsync(string nodeGuid, bool isInterrupt)
         {
-            
+            return false;
-           
+            // return await this.environment.SetNodeInterruptAsync(nodeGuid, isInterrupt);
-            return await this.environment.SetNodeInterruptAsync(nodeGuid, isInterrupt);
+
-            
         }
 
 
@@ -573,7 +595,8 @@ namespace Serein.NodeFlow.Env
         public void SetMonitorObjState(string key, bool isMonitor)
         {
             environment.SetMonitorObjState(key, isMonitor);
-        }
+        } 
+#endif
 
 
         /// <summary>

NodeFlow/Env/RemoteFlowEnvironment.cs

@@ -12,8 +12,6 @@ using System.Threading.Channels;
 
 namespace Serein.NodeFlow.Env
 {
-
-
     /// <summary>
     /// 远程流程环境
     /// </summary>
@@ -638,7 +636,7 @@ namespace Serein.NodeFlow.Env
                                                                             toNodeGuid,
                                                                             JunctionOfConnectionType.Invoke,
                                                                             invokeType,
-                                                                            NodeConnectChangeEventArgs.ConnectChangeType.Remote));
+                                                                            NodeConnectChangeEventArgs.ConnectChangeType.Remove));
                 });
             }
             return result;
@@ -667,7 +665,7 @@ namespace Serein.NodeFlow.Env
                                                                                JunctionOfConnectionType.Arg,
                                                                                argIndex,
                                                                                ConnectionArgSourceType.GetPreviousNodeData,
-                                                                               NodeConnectChangeEventArgs.ConnectChangeType.Remote)); // 通知UI
+                                                                               NodeConnectChangeEventArgs.ConnectChangeType.Remove)); // 通知UI
                 });
             }
             return result;
@@ -819,7 +817,20 @@ namespace Serein.NodeFlow.Env
             });
             if (isSuuccess)
             {
-                OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
+                var nodeModel = GuidToModel(nodeGuid); // 获取目标节点
+                if (nodeModel is null) return false; 
+                var containerNode = GuidToModel(containerNodeGuid); // 获取容器节点
+                if (containerNode is not INodeContainer nodeContainer) return false;
+                var result = nodeContainer.PlaceNode(nodeModel);
+                if (result)
+                {
+                    // 通知UI更改
+                    UIContextOperation.Invoke(() =>
+                    {
+                        OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
+                    });
+                }
+                return result;
             }
             return isSuuccess;
         }
@@ -836,7 +847,22 @@ namespace Serein.NodeFlow.Env
             });
             if (isSuuccess) 
             {
-                OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
+                var nodeModel = GuidToModel(nodeGuid); // 获取目标节点
+                if (nodeModel is null) return false;
+                if (nodeModel.ContainerNode is not INodeContainer nodeContainer)
+                {
+                    return false;
+                }
+                var result = nodeContainer.TakeOutNode(nodeModel); // 从容器节点取出
+                if (result)
+                {
+                    // 通知UI更改
+                    UIContextOperation.Invoke(() =>
+                    {
+                        OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
+                    });
+                }
+                return result;
             }
             return isSuuccess;
         }
@@ -1027,7 +1053,20 @@ namespace Serein.NodeFlow.Env
 
         #region 私有方法
 
-
+        private NodeModelBase? GuidToModel(string nodeGuid)
+        {
+            if (string.IsNullOrEmpty(nodeGuid))
+            {
+                //throw new ArgumentNullException("not contains - Guid没有对应节点:" + (nodeGuid));
+                return null;
+            }
+            if (!NodeModels.TryGetValue(nodeGuid, out NodeModelBase? nodeModel) || nodeModel is null)
+            {
+                //throw new ArgumentNullException("null - Guid存在对应节点,但节点为null:" + (nodeGuid));
+                return null;
+            }
+            return nodeModel;
+        }
         private bool TryAddNode(NodeModelBase nodeModel)
         {
             NodeModels[nodeModel.Guid] = nodeModel;
@@ -1190,11 +1229,7 @@ namespace Serein.NodeFlow.Env
             return null;
         }
 
-        public async Task<ChannelFlowInterrupt.CancelType> GetOrCreateGlobalInterruptAsync()
+       
-        {
-            this.WriteLine(InfoType.INFO, "远程环境尚未实现的接口：GetOrCreateGlobalInterruptAsync");
-            return ChannelFlowInterrupt.CancelType.Error;
-        }
 
         public bool TryGetMethodDetailsInfo(string libraryName, string methodName, out MethodDetailsInfo mdInfo)
         {

NodeFlow/FlowStarter.cs

@@ -403,8 +403,8 @@ namespace Serein.NodeFlow
                             context.SetPreviousNode(nextNodes[i], singleFlipFlopNode);
                             if (nextNodes[i].DebugSetting.IsInterrupt) // 执行触发前
                             {
-                                var cancelType = await nextNodes[i].DebugSetting.GetInterruptTask();
+                                await nextNodes[i].DebugSetting.GetInterruptTask();
-                                await Console.Out.WriteLineAsync($"[{nextNodes[i].MethodDetails.MethodName}]中断已{cancelType}，开始执行后继分支");
+                                await Console.Out.WriteLineAsync($"[{nextNodes[i].MethodDetails.MethodName}]中断已取消，开始执行后继分支");
                             }
                             await nextNodes[i].StartFlowAsync(context); // 启动执行触发器后继分支的节点
                         }
@@ -421,8 +421,8 @@ namespace Serein.NodeFlow
                             context.SetPreviousNode(nextNodes[i], singleFlipFlopNode);
                             if (nextNodes[i].DebugSetting.IsInterrupt) // 执行触发前
                             {
-                                var cancelType = await nextNodes[i].DebugSetting.GetInterruptTask();
+                                await nextNodes[i].DebugSetting.GetInterruptTask();
-                                await Console.Out.WriteLineAsync($"[{nextNodes[i].MethodDetails.MethodName}]中断已{cancelType}，开始执行后继分支");
+                                await Console.Out.WriteLineAsync($"[{nextNodes[i].MethodDetails.MethodName}]中断已取消，开始执行后继分支");
                             }
                             await nextNodes[i].StartFlowAsync(context); // 启动执行触发器后继分支的节点
                         }
@@ -442,7 +442,7 @@ namespace Serein.NodeFlow
                 catch (Exception ex)
                 {
                     SereinEnv.WriteLine(InfoType.ERROR, $"触发器[{singleFlipFlopNode.Guid}]异常。"+ ex.Message);
-                    await Task.Delay(100);
+                    await Task.Delay(1000);
                 }
             }
 

NodeFlow/Model/SingleActionNode.cs

@@ -14,14 +14,5 @@ namespace Serein.NodeFlow.Model
             
         }
 
-        /// <summary>
-        /// 执行方法
-        /// </summary>
-        /// <param name="context"></param>
-        /// <returns></returns>
-        public override Task<object> ExecutingAsync(IDynamicContext context)
-        {
-            return base.ExecutingAsync(context);
-        }
     }
 }

NodeFlow/Model/SingleFlipflopNode.cs

@@ -1,7 +1,6 @@
 using Serein.Library.Api;
 using Serein.Library;
 using Serein.Library.Utils;
-using static Serein.Library.Utils.ChannelFlowInterrupt;
 
 namespace Serein.NodeFlow.Model
 {
@@ -28,8 +27,8 @@ namespace Serein.NodeFlow.Model
             if (DebugSetting.IsInterrupt) // 执行触发前
             {
                 string guid = this.Guid.ToString();
-                var cancelType = await this.DebugSetting.GetInterruptTask();
+                await this.DebugSetting.GetInterruptTask();
-                await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已{cancelType}，开始执行后继分支");
+                await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已取消，开始执行后继分支");
             }
             #endregion
 
@@ -40,7 +39,7 @@ namespace Serein.NodeFlow.Model
             }
             object instance = md.ActingInstance;
 
-            var args = await GetParametersAsync(context, this);
+            var args = await GetParametersAsync(context);
             // 因为这里会返回不确定的泛型 IFlipflopContext<TRsult>
             // 而我们只需要获取到 State 和 Value（返回的数据）
             // 所以使用 dynamic 类型接收

NodeFlow/Model/SingleGlobalDataNode.cs

@@ -23,7 +23,7 @@ namespace Serein.NodeFlow.Model
         /// <summary>
         /// 表达式
         /// </summary>
-        [PropertyInfo(IsNotification = true, CustomCodeAtStart = "ChangeName(value);")] 
+        [PropertyInfo(IsNotification = true, CustomCodeAtStart = "// ChangeName(value);")] 
         private string _keyName;
 
     }
@@ -52,42 +52,51 @@ namespace Serein.NodeFlow.Model
         private NodeModelBase? DataNode;
 
 
-        public void PlaceNode(NodeModelBase nodeModel)
+        public bool PlaceNode(NodeModelBase nodeModel)
         {
-            // 全局数据节点只有一个子控件
+            if(DataNode is null)
-            if (DataNode is not null)
             {
-                _ = Task.Run(async () =>
+                // 放置节点
-                {
+                nodeModel.ContainerNode = this;  
-                    await this.Env.RemoveNodeAsync(DataNode?.Guid);
+                ChildrenNode.Add(nodeModel);
-                    DataNode = nodeModel;
+                DataNode = nodeModel;
-                });
+                return true;
             }
             else
             {
-                DataNode = nodeModel;
+                // 全局数据节点只有一个子控件
+                return false;
             }
+
+            
         }
 
-        public void TakeOutAll()
+
+        public bool TakeOutNode(NodeModelBase nodeModel)
         {
+            if (ChildrenNode.Contains(nodeModel))
+            {
+                ChildrenNode.Remove(nodeModel);
+                nodeModel.ContainerNode = null;
+                DataNode = null;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+            
+        }
+
+        public async void TakeOutAll()
+        {
+            foreach (var nodeModel in ChildrenNode) 
+            {
+                await nodeModel.Env.TakeOutNodeToContainerAsync(nodeModel.Guid);
+            }
             DataNode = null;
         }
 
-        public void TakeOutNode(NodeModelBase nodeModel)
-        {
-            DataNode = null;
-        }
-
-        /// <summary>
-        /// 设置数据节点
-        /// </summary>
-        /// <param name="dataNode"></param>
-        //public void SetDataNode(NodeModelBase dataNode)
-        //{
-        //    DataNodeGuid = dataNode.Guid;
-        //}
-
         private void ChangeName(string newName)
         {
             if(SereinEnv.GetFlowGlobalData(_keyName) == null)

NodeFlow/Model/SingleScriptNode.cs

@@ -140,7 +140,7 @@ namespace Serein.NodeFlow.Model
         /// <returns></returns>
         public override async Task<object?> ExecutingAsync(IDynamicContext context)
         {
-            var @params =  await NodeModelBase.GetParametersAsync(context, this);
+            var @params =  await GetParametersAsync(context);
             ScriptFlowApi.Context= context; 
             context.AddOrUpdate($"{context.Guid}_{this.Guid}_Params", @params[0]); // 后面再改
 

Serein.Library.MyGenerator/ParameterDetailsPropertyGenerator.cs

@@ -125,7 +125,7 @@ namespace Serein.Library.NodeGenerator
             sb.AppendLine($"using System.Collections.Generic;");
             sb.AppendLine($"using Serein.Library;");
             sb.AppendLine($"using Serein.Library.Api;");
-            sb.AppendLine($"using static Serein.Library.Utils.ChannelFlowInterrupt;");
+            //sb.AppendLine($"using static Serein.Library.Utils.ChannelFlowInterrupt;");
             sb.AppendLine($"");
             sb.AppendLine($"namespace {namespaceName}");
             sb.AppendLine("{");

WorkBench/App.xaml.cs

@@ -24,7 +24,7 @@ namespace Serein.Workbench
         void LoadLocalProject()
         {
 #if DEBUG 
-            if (1 == 11)
+            if (1 == 1)
             {
                 // 这里是我自己的测试代码，你可以删除
                 string filePath;

WorkBench/MainWindow.xaml.cs

@@ -198,7 +198,7 @@ namespace Serein.Workbench
             EnvDecorator.OnStartNodeChange += FlowEnvironment_StartNodeChangeEvent;
             EnvDecorator.OnNodeConnectChange += FlowEnvironment_NodeConnectChangeEvemt;
             EnvDecorator.OnNodeCreate += FlowEnvironment_NodeCreateEvent;
-            EnvDecorator.OnNodeRemove += FlowEnvironment_NodeRemoteEvent;
+            EnvDecorator.OnNodeRemove += FlowEnvironment_NodeRemoveEvent;
             EnvDecorator.OnNodePlace += EnvDecorator_OnNodePlaceEvent;
             EnvDecorator.OnNodeTakeOut += EnvDecorator_OnNodeTakeOutEvent; 
             EnvDecorator.OnFlowRunComplete += FlowEnvironment_OnFlowRunCompleteEvent;
@@ -228,7 +228,7 @@ namespace Serein.Workbench
             EnvDecorator.OnStartNodeChange -= FlowEnvironment_StartNodeChangeEvent;
             EnvDecorator.OnNodeConnectChange -= FlowEnvironment_NodeConnectChangeEvemt;
             EnvDecorator.OnNodeCreate -= FlowEnvironment_NodeCreateEvent;
-            EnvDecorator.OnNodeRemove -= FlowEnvironment_NodeRemoteEvent;
+            EnvDecorator.OnNodeRemove -= FlowEnvironment_NodeRemoveEvent;
             EnvDecorator.OnNodePlace -= EnvDecorator_OnNodePlaceEvent;
             EnvDecorator.OnNodeTakeOut -= EnvDecorator_OnNodeTakeOutEvent;
             EnvDecorator.OnFlowRunComplete -= FlowEnvironment_OnFlowRunCompleteEvent;
@@ -247,7 +247,7 @@ namespace Serein.Workbench
         }
 
         #region 窗体加载方法
-        private void Window_Loaded(object sender, RoutedEventArgs e)
+        private async void Window_Loaded(object sender, RoutedEventArgs e)
         {
             var currentPath = System.IO.Directory.GetCurrentDirectory(); // 当前目录
             var baseLibraryFilePath = Path.Combine(currentPath, FlowLibraryManagement.SereinBaseLibrary);
@@ -260,7 +260,7 @@ namespace Serein.Workbench
             {
                 try
                 { 
-                    _ = Task.Run(() =>
+                    await Task.Run(() =>
                     {
                         EnvDecorator.LoadProject(new FlowEnvInfo { Project = App.FlowProjectData }, App.FileDataPath); // 加载项目
                     });
@@ -553,7 +553,7 @@ namespace Serein.Workbench
                     if (toNodeControl is FlipflopNodeControl flipflopControl
                         && flipflopControl?.ViewModel?.NodeModel is NodeModelBase nodeModel) // 某个节点连接到了触发器，尝试从全局触发器视图中移除该触发器
                     {
-                        NodeTreeViewer.RemoteGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
+                        NodeTreeViewer.RemoveGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
                     }
                     Connections.Add(connection);
                     fromNodeControl.AddCnnection(connection);
@@ -563,7 +563,7 @@ namespace Serein.Workbench
                 }
                 #endregion
                 #region 移除连接
-                else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remote) // 移除连接
+                else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remove) // 移除连接
                 {
                     // 需要移除连接
                     var removeConnections = Connections.Where(c => 
@@ -639,7 +639,7 @@ namespace Serein.Workbench
                 }
                 #endregion
                 #region 移除连接
-                else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remote) // 移除连接
+                else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remove) // 移除连接
                 {
                     // 需要移除连接
                     var removeConnections = Connections.Where(c => c.Start.MyNode.Guid.Equals(fromNodeGuid)
@@ -674,7 +674,7 @@ namespace Serein.Workbench
         /// 节点移除事件
         /// </summary>
         /// <param name="eventArgs"></param>
-        private void FlowEnvironment_NodeRemoteEvent(NodeRemoveEventArgs eventArgs)
+        private void FlowEnvironment_NodeRemoveEvent(NodeRemoveEventArgs eventArgs)
         {
             var nodeGuid = eventArgs.NodeGuid;
             if (!TryGetControl(nodeGuid, out var nodeControl))
@@ -696,7 +696,7 @@ namespace Serein.Workbench
                 var node = flipflopControl?.ViewModel?.NodeModel;
                 if (node is not null)
                 {
-                    NodeTreeViewer.RemoteGlobalFlipFlop(node); // 从全局触发器树树视图中移除
+                    NodeTreeViewer.RemoveGlobalFlipFlop(node); // 从全局触发器树树视图中移除
                 }
             }
 
@@ -714,23 +714,24 @@ namespace Serein.Workbench
         /// <exception cref="NotImplementedException"></exception>
         private void FlowEnvironment_NodeCreateEvent(NodeCreateEventArgs eventArgs)
         {
-            if (eventArgs.NodeModel is not NodeModelBase nodeModelBase)
+            var nodeModel = eventArgs.NodeModel;
+            if (NodeControls.ContainsKey(nodeModel.Guid))
             {
-                SereinEnv.WriteLine(InfoType.WARN, "OnNodeCreateEvent事件接收到意外的返回值");
+                SereinEnv.WriteLine(InfoType.WARN, $"OnNodeCreateEvent 事件接收到意外的返回值：节点Guid重复 - {nodeModel.Guid}");
                 return;
             }
 
             PositionOfUI position = eventArgs.Position;
 
-            if(!NodeMVVMManagement.TryGetType(nodeModelBase.ControlType, out var nodeMVVM))
+            if(!NodeMVVMManagement.TryGetType(nodeModel.ControlType, out var nodeMVVM))
             {
-                SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModelBase.ControlType}节点，节点类型尚未注册。");
+                SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModel.ControlType}节点，节点类型尚未注册。");
                 return;
             }
             if(nodeMVVM.ControlType == null
                 || nodeMVVM.ViewModelType == null)
             {
-                SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModelBase.ControlType}节点，UI类型尚未注册（请通过 NodeMVVMManagement.RegisterUI() 方法进行注册）。");
+                SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModel.ControlType}节点，UI类型尚未注册（请通过 NodeMVVMManagement.RegisterUI() 方法进行注册）。");
                 return;
             }
 
@@ -740,7 +741,7 @@ namespace Serein.Workbench
             {
                 nodeControl = CreateNodeControl(nodeMVVM.ControlType, // 控件UI类型
                                                                     nodeMVVM.ViewModelType, // 控件VIewModel类型
-                                                                    nodeModelBase,  // 控件数据实体
+                                                                    nodeModel,  // 控件数据实体
                                                                     nodeCanvas); // 所在画布
             }
             catch (Exception ex)
@@ -749,7 +750,7 @@ namespace Serein.Workbench
                 return;
             }
 
-            NodeControls.TryAdd(nodeModelBase.Guid, nodeControl); // 添加到
+            NodeControls.TryAdd(nodeModel.Guid, nodeControl); // 添加到
             if (TryPlaceNodeInRegion(nodeControl, position, out var regionControl)) // 判断添加到区域容器
             {
                 // 通知运行环境调用加载节点子项的方法
@@ -764,7 +765,7 @@ namespace Serein.Workbench
 
 
             #region 节点树视图
-            if (nodeModelBase.ControlType == NodeControlType.Flipflop)
+            if (nodeModel.ControlType == NodeControlType.Flipflop)
             {
                 var node = nodeControl?.ViewModel?.NodeModel;
                 if (node is not null)
@@ -779,7 +780,7 @@ namespace Serein.Workbench
         }
 
         /// <summary>
-        /// 节点父子关系发生改变
+        /// 放置一个节点
         /// </summary>
         /// <param name="eventArgs"></param>
         /// <exception cref="NotImplementedException"></exception>
@@ -802,6 +803,10 @@ namespace Serein.Workbench
             nodeControl.PlaceToContainer(containerControl); // 放置在容器节点中
         }
 
+        /// <summary>
+        /// 取出一个节点
+        /// </summary>
+        /// <param name="eventArgs"></param>
         private void EnvDecorator_OnNodeTakeOutEvent(NodeTakeOutEventArgs eventArgs)
         {
             string nodeGuid = eventArgs.NodeGuid;
@@ -1170,34 +1175,13 @@ namespace Serein.Workbench
                 }));
             }
 
-            #region 右键菜单功能 - 中断
+            
-
-            contextMenu.Items.Add(CreateMenuItem("在此中断", async (s, e) =>
-            {
-                if ((s is MenuItem menuItem) && menuItem is not null)
-                {
-                    if (nodeControl?.ViewModel?.NodeModel?.DebugSetting?.IsInterrupt == true)
-                    {
-                        await EnvDecorator.SetNodeInterruptAsync(nodeGuid,false);
-                        nodeControl.ViewModel.IsInterrupt = false;
-
-                        menuItem.Header = "取消中断";
-                    }
-                    else
-                    {
-                        nodeControl!.ViewModel!.IsInterrupt = true;
-                        await EnvDecorator.SetNodeInterruptAsync(nodeGuid, true);
-                        menuItem.Header = "在此中断";
-
-                    }
-                }
-            }));
-
-            #endregion
-
            
             contextMenu.Items.Add(CreateMenuItem("设为起点", (s, e) => EnvDecorator.SetStartNodeAsync(nodeGuid)));
-            contextMenu.Items.Add(CreateMenuItem("删除", (s, e) => EnvDecorator.RemoveNodeAsync(nodeGuid)));
+            contextMenu.Items.Add(CreateMenuItem("删除", async (s, e) =>
+            {
+                var result = await EnvDecorator.RemoveNodeAsync(nodeGuid);
+            }));
 
             #region 右键菜单功能 - 控件对齐
 
@@ -1642,7 +1626,7 @@ namespace Serein.Workbench
         {
             if (ViewObjectViewer.MonitorObj is null)
             {
-                EnvDecorator.SetMonitorObjState(key, true); // 通知环境，该节点的数据更新后需要传到UI
+                // EnvDecorator.SetMonitorObjState(key, true); // 通知环境，该节点的数据更新后需要传到UI
                 return;
             }
             if (instance is null)
@@ -1656,8 +1640,8 @@ namespace Serein.Workbench
             }
             else
             {
-                EnvDecorator.SetMonitorObjState(ViewObjectViewer.MonitorKey,false); // 取消对旧节点的监视
+                //EnvDecorator.SetMonitorObjState(ViewObjectViewer.MonitorKey,false); // 取消对旧节点的监视
-                EnvDecorator.SetMonitorObjState(key, true); // 通知环境，该节点的数据更新后需要传到UI
+                //EnvDecorator.SetMonitorObjState(key, true); // 通知环境，该节点的数据更新后需要传到UI
             }
         }
         #endregion
@@ -2499,7 +2483,7 @@ namespace Serein.Workbench
                 }
                 else
                 {
-                    NodeTreeViewer.RemoteGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
+                    NodeTreeViewer.RemoveGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
                 }
             }
         }

WorkBench/Themes/NodeTreeViewControl.xaml.cs

@@ -42,7 +42,7 @@ namespace Serein.Workbench.Themes
                 viewer.RefreshTree();
             }
         }
-        public void RemoteGlobalFlipFlop(NodeModelBase nodeModel)
+        public void RemoveGlobalFlipFlop(NodeModelBase nodeModel)
         {
             if (globalFlipflopNodes.TryGetValue(nodeModel.Guid, out var viewer))
             {

WorkBench/Themes/ObjectViewerControl.xaml.cs

@@ -132,17 +132,17 @@ namespace Serein.Workbench.Themes
         /// <param name="e"></param>
         private async void UpMonitorExpressionButton_Click(object sender, RoutedEventArgs e)
         {
-            if (FlowEnvironment is not null && await FlowEnvironment.AddInterruptExpressionAsync(monitorKey, MonitorExpression)) // 对象预览器尝试添加中断表达式
+            //if (FlowEnvironment is not null && await FlowEnvironment.AddInterruptExpressionAsync(monitorKey, MonitorExpression)) // 对象预览器尝试添加中断表达式
-            {
+            //{
-                if (string.IsNullOrEmpty(MonitorExpression))
+            //    if (string.IsNullOrEmpty(MonitorExpression))
-                {
+            //    {
-                    ExpressionTextBox.Text = "表达式已清空";
+            //        ExpressionTextBox.Text = "表达式已清空";
-                }
+            //    }
-                else
+            //    else
-                {
+            //    {
-                    UpMonitorExpressionButton.Content = "更新监视表达式";
+            //        UpMonitorExpressionButton.Content = "更新监视表达式";
-                }
+            //    }
-            }
+            //}
         }
 
         private TreeViewItem? LoadTree(object? obj)

Workbench/Node/INodeContainerControl.cs

@@ -17,13 +17,13 @@ namespace Serein.Workbench.Node
         /// 放置一个节点
         /// </summary>
         /// <param name="nodeControl"></param>
-        void PlaceNode(NodeControlBase nodeControl);
+        bool PlaceNode(NodeControlBase nodeControl);
 
         /// <summary>
         /// 取出一个节点
         /// </summary>
         /// <param name="nodeControl"></param>
-        void TakeOutNode(NodeControlBase nodeControl);
+        bool TakeOutNode(NodeControlBase nodeControl);
 
         /// <summary>
         /// 取出所有节点（用于删除容器）

Workbench/Node/NodeControlBase.cs

@@ -53,8 +53,13 @@ namespace Serein.Workbench.Node.View
         public void PlaceToContainer(INodeContainerControl nodeContainerControl)
         {
             this.nodeContainerControl = nodeContainerControl;
-            NodeCanvas.Children.Remove(this); // 从画布上移除
+            NodeCanvas.Children.Remove(this); // 临时从画布上移除
-            nodeContainerControl.PlaceNode(this);
+            var result = nodeContainerControl.PlaceNode(this);
+            if (!result) // 检查是否放置成功，如果不成功，需要重新添加回来
+            {
+                NodeCanvas.Children.Add(this); // 从画布上移除
+
+            }
         }
 
         /// <summary>
@@ -62,8 +67,17 @@ namespace Serein.Workbench.Node.View
         /// </summary>
         public void TakeOutContainer()
         {
-            nodeContainerControl.TakeOutNode(this);
+            var result = nodeContainerControl.TakeOutNode(this); // 从控件取出
-            NodeCanvas.Children.Add(this); // 重新添加到画布上
+            if (result) // 移除成功时才添加到画布上
+            {
+                NodeCanvas.Children.Add(this); // 重新添加到画布上
+                if (nodeContainerControl is NodeControlBase containerControl)
+                {
+                    this.ViewModel.NodeModel.Position.X = containerControl.ViewModel.NodeModel.Position.X + containerControl.Width + 10;
+                    this.ViewModel.NodeModel.Position.Y = containerControl.ViewModel.NodeModel.Position.Y;
+                }
+            }
+            
         }
 
         /// <summary>

Workbench/Node/View/GlobalDataControl.xaml.cs

@@ -58,15 +58,24 @@ namespace Serein.Workbench.Node.View
         JunctionControlBase[] INodeJunction.ArgDataJunction => throw new NotImplementedException();
 
 
-        public void PlaceNode(NodeControlBase nodeControl)
+        public bool PlaceNode(NodeControlBase nodeControl)
         {
-            //GlobalDataPanel.Children.Clear();
+            if (GlobalDataPanel.Children.Contains(nodeControl))
+            {
+                return false;
+            }
             GlobalDataPanel.Children.Add(nodeControl);
+            return true;
         }
 
-        public void TakeOutNode(NodeControlBase nodeControl)
+        public bool TakeOutNode(NodeControlBase nodeControl)
         {
+            if (!GlobalDataPanel.Children.Contains(nodeControl))
+            {
+                return false;
+            }
             GlobalDataPanel.Children.Remove(nodeControl);
+            return true;
         }
 
         public void TakeOutAll()