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

NodeFlow/Env/RemoteFlowEnvironment.cs

@@ -0,0 +1,578 @@
+using Serein.Library;
+using Serein.Library.Api;
+using Serein.Library.Utils;
+using Serein.NodeFlow.Tool;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Xml.Linq;
+
+namespace Serein.NodeFlow.Env
+{
+
+
+    /// <summary>
+    /// 远程流程环境
+    /// </summary>
+    public class RemoteFlowEnvironment : ChannelFlowTrigger<string>, IFlowEnvironment
+    {
+        /// <summary>
+        /// 连接到远程环境后切换到的环境接口实现
+        /// </summary>
+        /// <param name="webSocketClient">连接到远程环境的客户端</param>
+        public RemoteFlowEnvironment(RemoteEnvControl RemoteEnvControl)
+        {
+            remoteEnvControl = RemoteEnvControl;
+            msgClient = new MsgControllerOfClient(this, RemoteEnvControl.SendAsync);
+            RemoteEnvControl.EnvClient.MsgHandleHelper.AddModule(msgClient, (ex, send) =>
+            {
+                Console.WriteLine(ex);
+            });
+        }
+
+        //private readonly Func<string, object?, Task> SendCommandAsync; 
+        private readonly RemoteEnvControl remoteEnvControl;
+        private readonly MsgControllerOfClient msgClient;
+        private readonly ConcurrentDictionary<string, MethodDetails> MethodDetailss = [];
+
+
+       
+
+        /// <summary>
+        /// 环境加载的节点集合
+        /// Node Guid - Node Model
+        /// </summary>
+        private Dictionary<string, NodeModelBase> Nodes { get; } = [];
+
+        public event LoadDllHandler OnDllLoad;
+        public event ProjectLoadedHandler OnProjectLoaded;
+        public event NodeConnectChangeHandler OnNodeConnectChange;
+        public event NodeCreateHandler OnNodeCreate;
+        public event NodeRemoteHandler OnNodeRemote;
+        public event StartNodeChangeHandler OnStartNodeChange;
+        public event FlowRunCompleteHandler OnFlowRunComplete;
+        public event MonitorObjectChangeHandler OnMonitorObjectChange;
+        public event NodeInterruptStateChangeHandler OnNodeInterruptStateChange;
+        public event ExpInterruptTriggerHandler OnInterruptTrigger;
+        public event IOCMembersChangedHandler OnIOCMembersChanged;
+        public event NodeLocatedHandler OnNodeLocated;
+        public event NodeMovedHandler OnNodeMoved;
+        public event EnvOutHandler OnEnvOut;
+
+        public ISereinIOC IOC => throw new NotImplementedException();
+
+        public string EnvName => FlowEnvironment.SpaceName;
+
+        public bool IsGlobalInterrupt => false;
+
+        public bool IsLcR => true;
+
+        public bool IsRcL => false;
+
+        public RunState FlowState { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+        public RunState FlipFlopState { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        public IFlowEnvironment CurrentEnv => this;
+
+        public void SetConsoleOut()
+        {
+            var logTextWriter = new LogTextWriter(msg =>
+            {
+                OnEnvOut?.Invoke(msg);
+            });
+            Console.SetOut(logTextWriter);
+        }
+
+        public void WriteLineObjToJson(object obj)
+        {
+            Console.WriteLine("远程环境尚未实现的接口：WriteLineObjToJson");
+        }
+
+        public async Task StartRemoteServerAsync(int port = 7525)
+        {
+            await Console.Out.WriteLineAsync("远程环境尚未实现的接口：StartRemoteServerAsync");
+        }
+
+        public void StopRemoteServer()
+        {
+            Console.WriteLine("远程环境尚未实现的接口：StopRemoteServer");
+        }
+
+        public async Task<SereinProjectData> GetProjectInfoAsync()
+        {
+            var prjectInfo = await msgClient.SendAndWaitDataAsync<SereinProjectData>(EnvMsgTheme.GetProjectInfo); // 等待服务器返回项目信息
+            return prjectInfo;
+        }
+
+        public void LoadProject(FlowEnvInfo flowEnvInfo, string filePath)
+        {
+            Console.WriteLine("远程环境尚未实现的接口：LoadProject");
+
+            
+            // dll面板
+            var libmds = flowEnvInfo.LibraryMds;
+            foreach (var lib in libmds)
+            {
+                NodeLibrary nodeLibrary = new NodeLibrary
+                {
+                    FullName = lib.LibraryName,
+                    FilePath = "Remote",
+                };
+                var mdInfos = lib.Mds.ToList();
+                OnDllLoad?.Invoke(new LoadDllEventArgs(nodeLibrary, mdInfos)); // 通知UI创建dll面板显示
+
+                foreach (var mdInfo in mdInfos)
+                {
+                    MethodDetailss.TryAdd(mdInfo.MethodName, new MethodDetails(mdInfo)); // 从DLL读取时生成元数据
+                }
+            }
+            //flowSemaphore.
+
+            var projectData = flowEnvInfo.Project;
+
+
+            List<(NodeModelBase, string[])> regionChildNodes = new List<(NodeModelBase, string[])>();
+            List<(NodeModelBase, PositionOfUI)> ordinaryNodes = new List<(NodeModelBase, PositionOfUI)>();
+
+            // 加载节点
+            foreach (var nodeInfo in projectData.Nodes)
+            {
+                var controlType = FlowFunc.GetNodeControlType(nodeInfo);
+                if (controlType == NodeControlType.None)
+                {
+                    continue;
+                }
+                else
+                {
+                  
+                    MethodDetails? methodDetails;
+                    MethodDetailss.TryGetValue(nodeInfo.MethodName, out methodDetails);// 尝试获取方法信息
+
+                    var nodeModel = FlowFunc.CreateNode(this, controlType, methodDetails); // 加载远程项目时创建节点
+                    nodeModel.LoadInfo(nodeInfo); // 创建节点model
+
+
+                    if (nodeModel is null)
+                    {
+                        nodeInfo.Guid = string.Empty;
+                        continue;
+                    }
+                    TryAddNode(nodeModel); // 加载项目时将节点加载到环境中
+                    if (nodeInfo.ChildNodeGuids?.Length > 0)
+                    {
+                        regionChildNodes.Add((nodeModel, nodeInfo.ChildNodeGuids));
+                        OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeModel, nodeInfo.Position));
+                    }
+                    else
+                    {
+                        ordinaryNodes.Add((nodeModel, nodeInfo.Position));
+                    }
+                }
+            }
+
+            // 加载区域子项
+            foreach ((NodeModelBase region, string[] childNodeGuids) item in regionChildNodes)
+            {
+                foreach (var childNodeGuid in item.childNodeGuids)
+                {
+                    Nodes.TryGetValue(childNodeGuid, out NodeModelBase? childNode);
+                    if (childNode is null)
+                    {
+                        // 节点尚未加载
+                        continue;
+                    }
+                    // 存在节点
+                    OnNodeCreate?.Invoke(new NodeCreateEventArgs(childNode, true, item.region.Guid));
+                }
+            }
+
+            // 加载节点
+            foreach ((NodeModelBase nodeModel, PositionOfUI position) item in ordinaryNodes)
+            {
+                bool IsContinue = false;
+                foreach ((NodeModelBase region, string[] childNodeGuids) item2 in regionChildNodes)
+                {
+                    foreach (var childNodeGuid in item2.childNodeGuids)
+                    {
+                        if (item.nodeModel.Guid.Equals(childNodeGuid))
+                        {
+                            IsContinue = true;
+                        }
+                    }
+                }
+                if (IsContinue) continue;
+                OnNodeCreate?.Invoke(new NodeCreateEventArgs(item.nodeModel, item.position));
+            }
+
+
+
+            // 确定节点之间的连接关系
+            _ = Task.Run(async () =>
+            {
+                await Task.Delay(100);
+                foreach (var nodeInfo in projectData.Nodes)
+                {
+                    if (!Nodes.TryGetValue(nodeInfo.Guid, out NodeModelBase? fromNode))
+                    {
+                        // 不存在对应的起始节点
+                        continue;
+                    }
+
+
+                    List<(ConnectionType connectionType, string[] guids)> allToNodes = [(ConnectionType.IsSucceed,nodeInfo.TrueNodes),
+                                                                                    (ConnectionType.IsFail,   nodeInfo.FalseNodes),
+                                                                                    (ConnectionType.IsError,  nodeInfo.ErrorNodes),
+                                                                                    (ConnectionType.Upstream, nodeInfo.UpstreamNodes)];
+
+                    List<(ConnectionType, NodeModelBase[])> fromNodes = allToNodes.Where(info => info.guids.Length > 0)
+                                                                         .Select(info => (info.connectionType,
+                                                                                          info.guids.Where(guid => Nodes.ContainsKey(guid)).Select(guid => Nodes[guid])
+                                                                                            .ToArray()))
+                                                                         .ToList();
+                    // 遍历每种类型的节点分支（四种）
+                    foreach ((ConnectionType connectionType, NodeModelBase[] toNodes) item in fromNodes)
+                    {
+                        // 遍历当前类型分支的节点（确认连接关系）
+                        foreach (var toNode in item.toNodes)
+                        {
+                            OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(fromNode.Guid,
+                                                                            toNode.Guid,
+                                                                            item.connectionType,
+                                                                            NodeConnectChangeEventArgs.ConnectChangeType.Create)); // 通知UI创建节点
+
+                            //ConnectNode(fromNode, toNode, item.connectionType); // 加载时确定节点间的连接关系
+                        }
+                    }
+                }
+            });
+
+            SetStartNode(projectData.StartNode);
+            OnProjectLoaded?.Invoke(new ProjectLoadedEventArgs());
+
+        }
+        private bool TryAddNode(NodeModelBase nodeModel)
+        {
+            nodeModel.Guid ??= Guid.NewGuid().ToString();
+            Nodes[nodeModel.Guid] = nodeModel;
+
+            // 如果是触发器，则需要添加到专属集合中
+            //if (nodeModel is SingleFlipflopNode flipflopNode)
+            //{
+            //    var guid = flipflopNode.Guid;
+            //    if (!FlipflopNodes.Exists(it => it.Guid.Equals(guid)))
+            //    {
+            //        FlipflopNodes.Add(flipflopNode);
+            //    }
+            //}
+            return true;
+        }
+
+        private void ConnectNode(NodeModelBase fromNode, NodeModelBase toNode, ConnectionType connectionType)
+        {
+            if (fromNode is null || toNode is null || fromNode == toNode)
+            {
+                return;
+            }
+
+            var ToExistOnFrom = true;
+            var FromExistInTo = true;
+            ConnectionType[] ct = [ConnectionType.IsSucceed,
+                                   ConnectionType.IsFail,
+                                   ConnectionType.IsError,
+                                   ConnectionType.Upstream];
+
+
+            foreach (ConnectionType ctType in ct)
+            {
+                var FToTo = fromNode.SuccessorNodes[ctType].Where(it => it.Guid.Equals(toNode.Guid)).ToArray();
+                var ToOnF = toNode.PreviousNodes[ctType].Where(it => it.Guid.Equals(fromNode.Guid)).ToArray();
+                ToExistOnFrom = FToTo.Length > 0;
+                FromExistInTo = ToOnF.Length > 0;
+                if (ToExistOnFrom && FromExistInTo)
+                {
+                    Console.WriteLine("起始节点已与目标节点存在连接");
+                    
+                    //return;
+                }
+                else
+                {
+                    // 检查是否可能存在异常
+                    if (!ToExistOnFrom && FromExistInTo)
+                    {
+                        Console.WriteLine("目标节点不是起始节点的子节点，起始节点却是目标节点的父节点");
+                        return;
+                    }
+                    else if (ToExistOnFrom && !FromExistInTo)
+                    {
+                        //
+                        Console.WriteLine(" 起始节点不是目标节点的父节点，目标节点却是起始节点的子节点");
+                        return;
+                    }
+                    else // if (!ToExistOnFrom && !FromExistInTo)
+                    {
+                        // 可以正常连接
+                    }
+                }
+
+
+                fromNode.SuccessorNodes[connectionType].Add(toNode); // 添加到起始节点的子分支
+                toNode.PreviousNodes[connectionType].Add(fromNode); // 添加到目标节点的父分支
+                OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(fromNode.Guid,
+                                                                        toNode.Guid,
+                                                                        connectionType,
+                                                                        NodeConnectChangeEventArgs.ConnectChangeType.Create)); // 通知UI
+            }
+
+
+            
+        }
+
+
+
+        public async Task<FlowEnvInfo> GetEnvInfoAsync()
+        {
+
+            var envInfo = await msgClient.SendAndWaitDataAsync<FlowEnvInfo>(EnvMsgTheme.GetEnvInfo);
+
+            return envInfo;
+        }
+
+
+
+        public async Task<(bool, RemoteEnvControl)> ConnectRemoteEnv(string addres, int port, string token)
+        {
+            await Console.Out.WriteLineAsync("远程环境尚未实现的接口：ConnectRemoteEnv");
+            return (false, null);
+        }
+
+        public void ExitRemoteEnv()
+        {
+            Console.WriteLine("远程环境尚未实现的接口：ExitRemoteEnv");
+        }
+
+        public void LoadDll(string dllPath)
+        {
+            // 将dll文件发送到远程环境，由远程环境进行加载
+            Console.WriteLine("远程环境尚未实现的接口：LoadDll");
+        }
+
+        public bool RemoteDll(string assemblyFullName)
+        {
+            // 尝试移除远程环境中的加载了的依赖
+            Console.WriteLine("远程环境尚未实现的接口：RemoteDll");
+            return false;
+        }
+
+        public void ClearAll()
+        {
+            Console.WriteLine("远程环境尚未实现的接口：ClearAll");
+        }
+
+        public async Task StartAsync()
+        {
+            // 远程环境下不需要UI上下文
+            await msgClient.SendAsync(EnvMsgTheme.StartFlow);
+        }
+
+        public async Task StartAsyncInSelectNode(string startNodeGuid)
+        {
+            await msgClient.SendAsync(EnvMsgTheme.StartFlowInSelectNode, new
+            {
+                nodeGuid = startNodeGuid
+            });
+        }
+
+        public async void ExitFlow()
+        {
+            await msgClient.SendAsync(EnvMsgTheme.ExitFlow, null);
+        }
+
+        public void MoveNode(string nodeGuid, double x, double y)
+        {
+            OnNodeMoved.Invoke(new NodeMovedEventArgs(nodeGuid, x, y));
+            _ = msgClient.SendAsync(EnvMsgTheme.MoveNode,
+                    new
+                    {
+                        nodeGuid,
+                        x,
+                        y
+                    });
+        }
+
+        public void SetStartNode(string nodeGuid)
+        {
+            _ = msgClient.SendAsync(EnvMsgTheme.SetStartNode, new
+            {
+                nodeGuid
+            });
+        }
+
+        public async Task<bool> ConnectNodeAsync(string fromNodeGuid, string toNodeGuid, ConnectionType connectionType)
+        {
+            //_ = RemoteEnv.SendAsync(EnvMsgTheme.ConnectNode, new
+            //{
+            //    fromNodeGuid,
+            //    toNodeGuid,
+            //    connectionType = connectionType.ToString(),
+            //});
+            var result = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.ConnectNode, new
+            {
+                fromNodeGuid,
+                toNodeGuid,
+                connectionType = connectionType.ToString(),
+            });
+            return result;
+        }
+
+        public async Task<NodeInfo> CreateNodeAsync(NodeControlType nodeControlType, PositionOfUI position, MethodDetailsInfo methodDetailsInfo = null)
+        {
+            var nodeInfo = await msgClient.SendAndWaitDataAsync<NodeInfo>(EnvMsgTheme.CreateNode, new
+            {
+                nodeType = nodeControlType.ToString(),
+                position = position,
+                mdInfo = methodDetailsInfo,
+            });
+
+            MethodDetailss.TryGetValue(methodDetailsInfo.MethodName, out var methodDetails);// 加载项目时尝试获取方法信息
+            var nodeModel = FlowFunc.CreateNode(this, nodeControlType, methodDetails); // 远程环境下加载节点
+            TryAddNode(nodeModel);
+            nodeModel.LoadInfo(nodeInfo);
+
+            // 通知UI更改
+            OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeModel, position));
+            return nodeInfo;
+        }
+
+        public void RemoveConnect(string fromNodeGuid, string toNodeGuid, ConnectionType connectionType)
+        {
+            _ = msgClient.SendAsync(EnvMsgTheme.RemoveConnect, new
+            {
+                fromNodeGuid,
+                toNodeGuid,
+                connectionType = connectionType.ToString(),
+            });
+        }
+
+        public void RemoveNode(string nodeGuid)
+        {
+            _ = msgClient.SendAsync(EnvMsgTheme.RemoveNode, new
+            {
+                nodeGuid
+            });
+        }
+
+        public void ActivateFlipflopNode(string nodeGuid)
+        {
+            _ = msgClient.SendAsync(EnvMsgTheme.ActivateFlipflopNode, new
+            {
+                nodeGuid
+            });
+        }
+
+        public void TerminateFlipflopNode(string nodeGuid)
+        {
+            _ = msgClient.SendAsync(EnvMsgTheme.TerminateFlipflopNode, new
+            {
+                nodeGuid
+            });
+        }
+
+        public async Task<bool> SetNodeInterruptAsync(string nodeGuid, InterruptClass interruptClass)
+        {
+            var state = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.SetNodeInterrupt, // 设置节点中断
+                                                       new
+                                                       {
+                                                           nodeGuid,
+                                                           interruptClass = interruptClass.ToString(),
+                                                       });
+            return state;
+        }
+
+
+        public async Task<bool> AddInterruptExpressionAsync(string key, string expression)
+        {
+            var state = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.AddInterruptExpression,  // 设置节点/对象的中断表达式
+                                                       new
+                                                       {
+                                                           key,
+                                                           expression,
+                                                       });
+            return state;
+        }
+
+        public void SetMonitorObjState(string key, bool isMonitor)
+        {
+            Console.WriteLine("远程环境尚未实现的接口：SetMonitorObjState");
+        }
+
+        public async Task<(bool, string[])> CheckObjMonitorStateAsync(string key)
+        {
+            if (string.IsNullOrEmpty(key))
+            {
+                var exps = Array.Empty<string>();
+                return (false, exps);
+            }
+            else
+            {
+                var result = await msgClient.SendAndWaitDataAsync<(bool, string[])>(EnvMsgTheme.SetNodeInterrupt, // 检查并获取节点/对象是否正在监视、以及监视的表达式
+                                                                        new
+                                                                        {
+                                                                            key,
+                                                                        });
+                return result;
+            }
+
+        }
+
+
+        public async Task<ChannelFlowInterrupt.CancelType> GetOrCreateGlobalInterruptAsync()
+        {
+            await Console.Out.WriteLineAsync("远程环境尚未实现的接口：GetOrCreateGlobalInterruptAsync");
+            return ChannelFlowInterrupt.CancelType.Error;
+        }
+
+        public bool TryGetMethodDetailsInfo(string methodName, out MethodDetailsInfo mdInfo)
+        {
+            Console.WriteLine("远程环境尚未实现的接口：TryGetMethodDetailsInfo");
+            mdInfo = null;
+            return false;
+        }
+
+        public bool TryGetDelegateDetails(string methodName, out DelegateDetails del)
+        {
+            Console.WriteLine("远程环境尚未实现的接口：TryGetDelegateDetails");
+            del = null;
+            return false;
+        }
+
+
+
+        public void MonitorObjectNotification(string nodeGuid, object monitorData, MonitorObjectEventArgs.ObjSourceType sourceType)
+        {
+            Console.WriteLine("远程环境尚未实现的接口：MonitorObjectNotification");
+
+        }
+
+        public void TriggerInterrupt(string nodeGuid, string expression, InterruptTriggerEventArgs.InterruptTriggerType type)
+        {
+            Console.WriteLine("远程环境尚未实现的接口：TriggerInterrupt");
+        }
+
+        public void NodeLocated(string nodeGuid)
+        {
+            Console.WriteLine("远程环境尚未实现的接口：NodeLocated");
+        }
+
+        public async Task NotificationNodeValueChangeAsync(string nodeGuid, string path, object value)
+        {
+
+            //Console.WriteLine($"通知远程环境修改节点数据：{nodeGuid},name:{path},value:{value}");
+            _ = msgClient.SendAsync(EnvMsgTheme.ValueNotification, new
+            {
+                nodeGuid = nodeGuid,
+                path = path,
+                value = value.ToString(),
+            });
+
+        }
+    }
+}