尝试使用源生成器规范NodeModel代码逻辑

Library/FlowNode/Attribute.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library
+{
+    [AttributeUsage(AttributeTargets.Class, Inherited = true)]
+    internal sealed class AutoPropertyAttribute : Attribute
+    {
+        public string ValuePath = string.Empty;
+    }
+
+    /// <summary>
+    /// 自动生成环境的属性
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field, Inherited = true)]
+    internal sealed class PropertyInfoAttribute : Attribute
+    {
+        public bool IsNotification = false;
+        public bool IsPrint = false;
+    }
+
+}

Library/FlowNode/MethodDetails.cs

@@ -0,0 +1,210 @@
+using Serein.Library.Api;
+using Serein.Library.Utils;
+using System;
+using System.Linq;
+
+namespace Serein.Library
+{
+
+    /// <summary>
+    /// 每个节点有独自的MethodDetails实例
+    /// </summary>
+    [AutoProperty(ValuePath = nameof(MethodDetails))]
+    public partial class MethodDetails
+    {
+        private readonly IFlowEnvironment env;
+        private readonly NodeModelBase nodeModel;
+        /// <summary>
+        /// 是否保护参数（目前仅视觉效果参数，不影响运行实现，后续将设置作用在运行逻辑中）
+        /// </summary>
+        [PropertyInfo(IsNotification = true)]
+        private bool _isProtectionParameter;
+
+        /// <summary>
+        /// 作用实例的类型（多个相同的节点将拥有相同的类型）
+        /// </summary>
+        [PropertyInfo]
+        private Type _actingInstanceType;
+
+        /// <summary>
+        /// 作用实例（多个相同的节点将会共享同一个实例）
+        /// </summary>
+        [PropertyInfo]
+        private object _actingInstance;
+
+        /// <summary>
+        /// 方法名称
+        /// </summary>
+        [PropertyInfo]
+        private string _methodName;
+
+        /// <summary>
+        /// 节点类型
+        /// </summary>
+        [PropertyInfo]
+        private NodeType _methodDynamicType;
+
+        /// <summary>
+        /// 锁名称（暂未实现）
+        /// </summary>
+        [PropertyInfo]
+        private string _methodLockName;
+
+
+        /// <summary>
+        /// 方法说明
+        /// </summary>
+        [PropertyInfo]
+        private string _methodTips;
+
+
+        /// <summary>
+        /// 参数描述
+        /// </summary>
+        [PropertyInfo]
+        private ParameterDetails[] _parameterDetailss;
+
+        /// <summary>
+        /// 出参类型
+        /// </summary>
+        [PropertyInfo]
+        private Type _returnType;
+    }
+
+
+    public partial class MethodDetails
+    {
+        /// <summary>
+        /// 不包含方法信息的基础节点（后续可能要改为DLL引入基础节点）
+        /// </summary>
+        public MethodDetails()
+        {
+            
+        }
+        /// <summary>
+        /// 生成元数据
+        /// </summary>
+        /// <param name="env">节点运行的环境</param>
+        /// <param name="nodeModel">标识属于哪个节点</param>
+        public MethodDetails(IFlowEnvironment env, NodeModelBase nodeModel)
+        {
+            this.nodeModel = nodeModel;
+        }
+
+       
+        /// <summary>
+        /// 从方法信息中读取
+        /// </summary>
+        /// <param name="Info"></param>
+        public MethodDetails(MethodDetailsInfo Info)
+        {
+            if (!Info.NodeType.TryConvertEnum<NodeType>(out var nodeType))
+            {
+                throw new ArgumentException("无效的节点类型");
+            }
+            MethodName = Info.MethodName;
+            MethodTips = Info.MethodTips;
+            MethodDynamicType = nodeType;
+            ReturnType = Type.GetType(Info.ReturnTypeFullName);
+            ParameterDetailss = Info.ParameterDetailsInfos.Select(pinfo => new ParameterDetails(pinfo)).ToArray();
+        }
+
+        /// <summary>
+        /// 转为信息
+        /// </summary>
+        /// <returns></returns>
+        public MethodDetailsInfo ToInfo()
+        {
+            return new MethodDetailsInfo
+            {
+                MethodName = MethodName,
+                MethodTips = MethodTips,
+                NodeType = MethodDynamicType.ToString(),
+                ParameterDetailsInfos = ParameterDetailss.Select(p => p.ToInfo()).ToArray(),
+                ReturnTypeFullName = ReturnType.FullName,
+            };
+        }
+
+        /// <summary>
+        /// 从DLL拖动出来时拷贝属于节点的实例
+        /// </summary>
+        /// <returns></returns>
+        public MethodDetails CloneOfNode(IFlowEnvironment env, NodeModelBase nodeModel)
+        {
+            var md = new MethodDetails(env, nodeModel) // 创建新节点时拷贝实例
+            {
+                ActingInstance = this.ActingInstance,
+                ActingInstanceType = this.ActingInstanceType,
+                MethodDynamicType = this.MethodDynamicType,
+                MethodTips = this.MethodTips,
+                ReturnType = this.ReturnType,
+                MethodName = this.MethodName,
+                MethodLockName = this.MethodLockName,
+                IsProtectionParameter = this.IsProtectionParameter,
+            };
+            md.ParameterDetailss = this.ParameterDetailss.Select(p => p.CloneOfClone(env, nodeModel)).ToArray(); // 拷贝属于节点方法的新入参描述
+            return md;
+        }
+
+
+
+
+
+        ///// <summary>
+        ///// 每个节点有独自的MethodDetails实例
+        ///// </summary>
+        //public partial class TmpMethodDetails
+        //{
+        //    /// <summary>
+        //    /// 是否保护参数（目前仅视觉效果参数，不影响运行实现，后续将设置作用在运行逻辑中）
+        //    /// </summary>
+        //    public bool IsProtectionParameter { get; set; } = false;
+
+        //    /// <summary>
+        //    /// 作用实例的类型（多个相同的节点将拥有相同的类型）
+        //    /// </summary>
+        //    public Type ActingInstanceType { get; set; }
+
+        //    /// <summary>
+        //    /// 作用实例（多个相同的节点将会共享同一个实例）
+        //    /// </summary>
+        //    public object ActingInstance { get; set; }
+
+        //    /// <summary>
+        //    /// 方法名称
+        //    /// </summary>
+        //    public string MethodName { get; set; }
+
+        //    /// <summary>
+        //    /// 节点类型
+        //    /// </summary>
+        //    public NodeType MethodDynamicType { get; set; }
+
+        //    /// <summary>
+        //    /// 锁名称（暂未实现）
+        //    /// </summary>
+        //    public string MethodLockName { get; set; }
+
+
+        //    /// <summary>
+        //    /// 方法说明
+        //    /// </summary>
+        //    public string MethodTips { get; set; }
+
+
+        //    /// <summary>
+        //    /// 参数描述
+        //    /// </summary>
+
+        //    public ParameterDetails[] ParameterDetailss { get; set; }
+
+        //    /// <summary>
+        //    /// 出参类型
+        //    /// </summary>
+
+        //    public Type ReturnType { get; set; }
+        //}
+
+    }
+
+}

Library/FlowNode/MethodDetailsInfo.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library
+{
+    /// <summary>
+    /// 方法描述信息
+    /// </summary>
+    public class MethodDetailsInfo
+    {
+        /// <summary>
+        /// 属于哪个DLL文件
+        /// </summary>
+        public string LibraryName { get; set; }
+
+        /// <summary>
+        /// 方法名称
+        /// </summary>
+        public string MethodName { get; set; }
+
+        /// <summary>
+        /// 节点类型
+        /// </summary>
+        public string NodeType { get; set; }
+
+        /// <summary>
+        /// 方法说明
+        /// </summary>
+        public string MethodTips { get; set; }
+
+        /// <summary>
+        /// 参数内容
+        /// </summary>
+
+        public ParameterDetailsInfo[] ParameterDetailsInfos { get; set; }
+
+        /// <summary>
+        /// 出参类型
+        /// </summary>
+        public string ReturnTypeFullName { get; set; }
+    }
+
+}

Library/FlowNode/NodeModelBaseData.cs

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

Library/FlowNode/NodeModelBaseFunc.cs

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

Library/FlowNode/ParameterDetails.cs

@@ -0,0 +1,220 @@
+using Serein.Library.Api;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Text;
+
+namespace Serein.Library
+{
+
+    /// <summary>
+    /// 节点入参参数详情
+    /// </summary>
+    [AutoProperty(ValuePath = nameof(ParameterDetails))]
+    public partial class ParameterDetails
+    {
+        private readonly IFlowEnvironment env;
+        private readonly NodeModelBase nodeModel;
+        /// <summary>
+        /// 参数索引
+        /// </summary>
+        [PropertyInfo] 
+        private int _index;
+
+        /// <summary>
+        /// 是否为显式参数（固定值/表达式）
+        /// </summary>
+        [PropertyInfo(IsNotification = true)] 
+        private bool _isExplicitData ;
+
+        /// <summary>
+        /// 转换器 IEnumConvertor&lt;,&gt;
+        /// </summary>
+        [PropertyInfo] 
+        private Func<object, object> _convertor ;
+
+        /// <summary>
+        /// 显式类型
+        /// </summary>
+        [PropertyInfo]
+        private Type _explicitType ;
+
+        /// <summary>
+        /// 目前存在三种状态：Select/Bool/Value
+        /// <para>Select : 枚举值</para>
+        /// <para>Bool   : 布尔类型</para>
+        /// <para>Value  ： 除以上类型之外的任意参数</para>
+        /// </summary>
+        [PropertyInfo] 
+        private string _explicitTypeName ;
+
+        /// <summary>
+        /// 方法需要的类型
+        /// </summary>
+        [PropertyInfo] 
+        private Type _dataType ;
+
+        /// <summary>
+        /// 方法入参参数名称
+        /// </summary>
+        [PropertyInfo] 
+        private string _name ;
+
+        /// <summary>
+        /// 自定义的方法入参数据
+        /// </summary>
+        [PropertyInfo(IsNotification = true)] // IsPrint = true
+        private string _dataValue;
+
+        /// <summary>
+        /// 如果是引用类型，拷贝时不会发生改变。
+        /// </summary>
+        [PropertyInfo(IsNotification = true)] 
+        private string[] _items ;
+    }
+
+
+    public partial class ParameterDetails
+    {
+        /// <summary>
+        /// 为节点实例化新的入参描述
+        /// </summary>
+        public ParameterDetails(IFlowEnvironment env, NodeModelBase nodeModel)
+        {
+            this.env = env;
+            this.nodeModel = nodeModel;
+        }
+        /// <summary>
+        /// 通过参数信息加载实体，用于加载项目文件、远程连接的场景
+        /// </summary>
+        /// <param name="info">参数信息</param>
+        public ParameterDetails(ParameterDetailsInfo info)
+        {
+            //this.env = env;
+            Index = info.Index;
+            Name = info.Name;
+            DataType = Type.GetType(info.DataTypeFullName);
+            ExplicitType = Type.GetType(info.ExplicitTypeFullName);
+            ExplicitTypeName = info.ExplicitTypeName;
+            Items = info.Items;
+        }
+
+        /// <summary>
+        /// 用于创建元数据
+        /// </summary>
+        /// <param name="info">方法参数信息</param>
+        public ParameterDetails()
+        {
+            
+        }
+
+        /// <summary>
+        /// 转为描述
+        /// </summary>
+        /// <returns></returns>
+        public ParameterDetailsInfo ToInfo()
+        {
+            return new ParameterDetailsInfo
+            {
+                Index = Index,
+                DataTypeFullName = DataType.FullName,
+                Name = Name,
+                ExplicitTypeFullName = ExplicitType.FullName,
+                ExplicitTypeName = ExplicitTypeName,
+                Items = Items,
+            };
+        }
+
+        /// <summary>
+        /// 为某个节点拷贝方法描述的入参描述
+        /// </summary>
+        /// <param name="env">运行环境</param>
+        /// <param name="nodeGuid">运行环境</param>
+        /// <returns></returns>
+        public ParameterDetails CloneOfClone(IFlowEnvironment env, NodeModelBase nodeModel)
+        {
+            var pd = new ParameterDetails(env, nodeModel)
+            {
+                Index = this.Index,
+                IsExplicitData = this.IsExplicitData,
+                ExplicitType = this.ExplicitType,
+                ExplicitTypeName = this.ExplicitTypeName,
+                Convertor = this.Convertor,
+                DataType = this.DataType,
+                Name = this.Name,
+                DataValue = string.IsNullOrEmpty(DataValue) ? string.Empty : DataValue,
+                Items = this.Items?.Select(it => it).ToArray(),
+            };
+            return pd;
+        }
+    }
+
+
+
+
+    ///// <summary>
+    ///// 节点入参参数详情
+    ///// </summary>
+
+    //public partial class TempParameterDetails
+    //{
+    //    private readonly MethodDetails methodDetails;
+
+    //    /// <summary>
+    //    /// 参数索引
+    //    /// </summary>
+    //    public int Index { get; set; }
+    //    /// <summary>
+    //    /// 是否为显式参数（固定值/表达式）
+    //    /// </summary>
+    //    public bool IsExplicitData { get; set; }
+    //    /// <summary>
+    //    /// 转换器 IEnumConvertor&lt;,&gt;
+    //    /// </summary>
+    //    public Func<object, object> Convertor { get; set; }
+    //    /// <summary>
+    //    /// 显式类型
+    //    /// </summary>
+    //    public Type ExplicitType { get; set; }
+
+    //    /// <summary>
+    //    /// 目前存在三种状态：Select/Bool/Value
+    //    /// <para>Select : 枚举值</para>
+    //    /// <para>Bool   : 布尔类型</para>
+    //    /// <para>Value  ： 除以上类型之外的任意参数</para>
+    //    /// </summary>
+    //    public string ExplicitTypeName { get; set; }
+
+    //    /// <summary>
+    //    /// 方法需要的类型
+    //    /// </summary>
+    //    public Type DataType { get; set; }
+
+    //    /// <summary>
+    //    /// 方法入参参数名称
+    //    /// </summary>
+    //    public string Name { get; set; }
+
+
+    //    private string _dataValue;
+    //    /// <summary>
+    //    /// 入参值（在UI上输入的文本内容）
+    //    /// </summary>
+
+    //    public string DataValue
+    //    {
+    //        get => _dataValue; set
+    //        {
+    //            _dataValue = value;
+    //            Console.WriteLine($"更改了{value}");
+    //        }
+    //    }
+
+    //    /// <summary>
+    //    /// 如果是引用类型，拷贝时不会发生改变。
+    //    /// </summary>
+    //    public string[] Items { get; set; }
+    //}
+
+}

Library/FlowNode/ParameterDetailsInfo.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library
+{
+
+    /// <summary>
+    /// 方法入参描述
+    /// </summary>
+    public class ParameterDetailsInfo
+    {
+        /// <summary>
+        /// 参数索引
+        /// </summary>
+        public int Index { get; set; }
+
+        /// <summary>
+        /// 方法需要的类型
+        /// </summary>
+        public string DataTypeFullName { get; set; }
+
+        /// <summary>
+        /// 方法入参参数名称
+        /// </summary>
+        public string Name { get; set; }
+        /// <summary>
+        /// 显式类型
+        /// </summary>
+        public string ExplicitTypeFullName { get; set; }
+
+        /// <summary>
+        /// 目前存在三种状态：Select/Bool/Value
+        /// <para>Select : 枚举值</para>
+        /// <para>Bool   : 布尔类型</para>
+        /// <para>Value  ： 除以上类型之外的任意参数</para>
+        /// </summary>
+        public string ExplicitTypeName { get; set; }
+
+        /// <summary>
+        /// 参数选择器
+        /// </summary>
+        public string[] Items { get; set; }
+    }
+}

Library/FlowNode/SereinProjectData.cs

@@ -0,0 +1,263 @@
+using Serein.Library.Api;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library
+{
+
+    /// <summary>
+    /// 环境信息（远程控制用）
+    /// </summary>
+    public class FlowEnvInfo
+    {
+        /// <summary>
+        /// 环境方法信息
+        /// </summary>
+        public LibraryMds[] LibraryMds { get; set; }
+        /// <summary>
+        /// 项目信息
+        /// </summary>
+        public SereinProjectData Project { get; set; }
+
+        // IOC节点对象信息
+    }
+
+    public class LibraryMds
+    {
+        public string LibraryName { get; set; }
+
+        public MethodDetailsInfo[] Mds { get; set; }
+
+    }
+
+
+
+
+    /// <summary>
+    /// 项目保存文件
+    /// </summary>
+    public class SereinProjectData
+    {
+        /// <summary>
+        /// 基础
+        /// </summary>
+
+        public Basic Basic { get; set; }
+
+        /// <summary>
+        /// 依赖的DLL
+        /// </summary>
+
+        public Library[] Librarys { get; set; }
+
+        /// <summary>
+        /// 起始节点GUID
+        /// </summary>
+
+        public string StartNode { get; set; }
+
+        /// <summary>
+        /// 节点集合
+        /// </summary>
+
+        public NodeInfo[] Nodes { get; set; }
+
+    }
+
+    /// <summary>
+    /// 基础
+    /// </summary>
+    public class Basic
+    {
+        /// <summary>
+        /// 画布
+        /// </summary>
+
+        public FlowCanvas Canvas { get; set; }
+
+        /// <summary>
+        /// 版本
+        /// </summary>
+
+        public string Versions { get; set; }
+    }
+    /// <summary>
+    /// 画布
+    /// </summary>
+    public class FlowCanvas
+    {
+        /// <summary>
+        /// 宽度
+        /// </summary>
+        public double Width { get; set; }
+        /// <summary>
+        /// 高度
+        /// </summary>
+        public double Height { get; set; }
+
+        /// <summary>
+        /// 预览位置X
+        /// </summary>
+        public double ViewX { get; set; }
+
+        /// <summary>
+        /// 预览位置Y
+        /// </summary>
+        public double ViewY { get; set; }
+
+        /// <summary>
+        /// 缩放比例X
+        /// </summary>
+        public double ScaleX { get; set; }
+
+        /// <summary>
+        /// 缩放比例Y
+        /// </summary>
+        public double ScaleY { get; set; }
+    }
+
+    /// <summary>
+    /// DLL
+    /// </summary>
+    public class Library
+    {
+        /// <summary>
+        /// 文件名称
+        /// </summary>
+
+        public string FileName { get; set; }
+
+        /// <summary>
+        /// 文件路径
+        /// </summary>
+        public string FilePath { get; set; }
+
+        /// <summary>
+        /// 程序集名称
+        /// </summary>
+        public string AssemblyName { get; set; }
+    }
+
+    /// <summary>
+    /// 节点
+    /// </summary>
+    public class NodeInfo
+    {
+        /// <summary>
+        /// GUID
+        /// </summary>
+
+        public string Guid { get; set; }
+
+        /// <summary>
+        /// 名称
+        /// </summary>
+
+        public string MethodName { get; set; }
+
+        /// <summary>
+        /// 显示标签
+        /// </summary>
+
+        public string Label { get; set; }
+
+        /// <summary>
+        /// 类型
+        /// </summary>
+        public string Type { get; set; }
+
+        /// <summary>
+        /// 真分支节点GUID
+        /// </summary>
+
+        public string[] TrueNodes { get; set; }
+
+        /// <summary>
+        /// 假分支节点
+        /// </summary>
+
+        public string[] FalseNodes { get; set; }
+        /// <summary>
+        /// 上游分支
+        /// </summary>
+        public string[] UpstreamNodes { get; set; }
+        /// <summary>
+        /// 异常分支
+        /// </summary>
+        public string[] ErrorNodes { get; set; }
+
+        /// <summary>
+        /// 参数
+        /// </summary>
+        public Parameterdata[] ParameterData { get; set; }
+
+        /// <summary>
+        /// 如果是区域控件，则会存在子项。
+        /// </summary>
+        public string[] ChildNodeGuids { get; set; }
+
+
+        /// <summary>
+        /// 于画布中的位置
+        /// </summary>
+
+        public PositionOfUI Position { get; set; }
+
+        /// <summary>
+        /// 是否选中（暂时无效）
+        /// </summary>
+        public bool IsSelect { get; set; }
+    }
+
+    /// <summary>
+    /// 显示参数
+    /// </summary>
+    public class Parameterdata
+    {
+        /// <summary>
+        /// 参数类型，true时使用自定义的入参，false时由运行环境自动传参
+        /// </summary>
+        public bool State { get; set; }
+        /// <summary>
+        /// 自定义入参
+        /// </summary>
+        public string Value { get; set; }
+        /// <summary>
+        /// 表达式相关节点的表达式内容
+        /// </summary>
+        public string Expression { get; set; }
+
+    }
+
+
+    /// <summary>
+    /// 节点于画布中的位置
+    /// </summary>
+    public class PositionOfUI
+    { /// <summary>
+      /// 构造一个坐标
+      /// </summary>
+        public PositionOfUI()
+        {
+
+        }
+        /// <summary>
+        /// 构造一个坐标
+        /// </summary>
+        public PositionOfUI(double x, double y)
+        {
+            X = x; Y = y;
+        }
+
+        public double X { get; set; } = 0;
+        public double Y { get; set; } = 0;
+    }
+
+
+
+}