运行环境新增了画布相关的属性

NodeFlow/Env/EnvMsgTheme.cs

@@ -22,6 +22,14 @@
         /// </summary>
         public const string ExitFlow = nameof(ExitFlow);
         /// <summary>
+        /// 尝试新增画布
+        /// </summary>
+        public const string CreateCanvas = nameof(CreateCanvas);
+        /// <summary>
+        /// 尝试移除画布
+        /// </summary>
+        public const string RemoveCanvas = nameof(RemoveCanvas);
+        /// <summary>
         /// 尝试移动某个节点
         /// </summary>
         public const string MoveNode = nameof(MoveNode);

NodeFlow/Env/FlowEnvironment.cs

@@ -1,5 +1,6 @@
 using Serein.Library;
 using Serein.Library.Api;
+using Serein.Library.FlowNode;
 using Serein.Library.Utils;
 using Serein.Library.Utils.SereinExpression;
 using Serein.NodeFlow.Model;
@@ -201,6 +202,16 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         public event EnvOutHandler? OnEnvOut;
 
+        /// <summary>
+        /// 本地环境添加了画布
+        /// </summary>
+        public event CanvasCreateHandler OnCanvasCreate;
+
+        /// <summary>
+        /// 本地环境移除了画布
+        /// </summary>
+        public event CanvasRemoveHandler OnCanvasRemove;
+
         #endregion
 
         #region 属性
@@ -271,40 +282,6 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         private readonly FlowLibraryManagement FlowLibraryManagement;
 
-#if false
-
-        /// <summary>
-        /// Library 与 MethodDetailss的依赖关系
-        /// </summary>
-        public ConcurrentDictionary<NodeLibraryInfo, List<MethodDetails>> MethodDetailsOfLibraryInfos { get; } = [];
-
-
-        /// <summary>
-        /// <para>存储已加载的程序集</para>
-        /// <para>Key：程序集的FullName </para>
-        /// <para>Value：构造的方法信息</para>
-        /// </summary>
-        public ConcurrentDictionary<string, NodeLibraryInfo> LibraryInfos { get; } = [];
-
-        /// <summary>
-        /// <para>存储已加载的方法信息。描述所有DLL中NodeAction特性的方法的原始副本</para>
-        /// <para>Key：反射时获取的MethodInfo.MehtodName</para>
-        /// <para>Value：构造的方法信息</para>
-        /// </summary>
-        public ConcurrentDictionary<string, MethodDetails> MethodDetailss { get; } = [];
-
-        /// <summary>
-        /// 从dll中加载的类的注册类型
-        /// </summary>
-        private Dictionary<RegisterSequence, List<Type>> AutoRegisterTypes { get; } = [];
-
-        /// <summary>
-        /// 存放所有通过Emit加载的委托
-        /// md.Methodname - delegate
-        /// </summary>
-        private ConcurrentDictionary<string, DelegateDetails> MethodDelegates { get; } = []; 
-#endif
-
         /// <summary>
         /// IOC对象容器管理
         /// </summary>
@@ -321,6 +298,11 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         private Dictionary<string, NodeModelBase> NodeModels { get; } = [];
 
+        /// <summary>
+        /// 运行环境加载的画布集合
+        /// </summary>
+        private Dictionary<string, FlowCanvasModel> FlowCanvass { get; } = [];
+
         /// <summary>
         /// 存放触发器节点（运行时全部调用）
         /// </summary>
@@ -382,7 +364,6 @@ namespace Serein.NodeFlow.Env
             
         }
 
-        
         /// <summary>
         /// 异步运行
         /// </summary>
@@ -581,7 +562,7 @@ namespace Serein.NodeFlow.Env
             _ = Task.Run( async () =>
             {
                 await LoadNodeInfosAsync(projectData.Nodes.ToList()); // 加载节点信息
-                await SetStartNodeAsync(projectData.StartNode); // 设置起始节点
+                await SetStartNodeAsync("", projectData.StartNode); // 设置起始节点
             });
 
         }
@@ -786,7 +767,46 @@ namespace Serein.NodeFlow.Env
             //}
         }
 
- 
+        /// <summary>
+        /// 增加画布
+        /// </summary>
+        /// <param name="canvasName">画布名称</param>
+        /// <param name="width">宽度</param>
+        /// <param name="height">高度</param>
+        /// <returns></returns>
+        public Task<FlowCanvasInfo> CreateCanvasAsync(string canvasName, int width, int height)
+        {
+            var model = new FlowCanvasModel(this)
+            {
+                Guid = Guid.NewGuid().ToString(),
+                Height = height,
+                Name = canvasName,
+                Width = height,
+            };
+            var info = model.ToInfo();
+            FlowCanvass.Add(model.Guid, model);
+            OnCanvasCreate.Invoke(new CanvasCreateEventArgs(info));
+            return Task.FromResult(info);
+        }
+
+        /// <summary>
+        /// 删除画布
+        /// </summary>
+        /// <param name="canvasGuid">画布Guid</param>
+        /// <returns></returns>
+        public Task<bool> RemoteCanvasAsync(string canvasGuid)
+        {
+
+            if (!FlowCanvass.TryGetValue(canvasGuid, out var model))
+            {
+                return Task.FromResult(false);
+            }
+            var count = NodeModels.Values.Count(node => node.CanvasGuid.Equals(canvasGuid));
+            return Task.FromResult(count == 0);
+        }
+
+
+
         /// <summary>
         /// 从节点信息集合批量加载节点控件
         /// </summary>
@@ -827,7 +847,7 @@ namespace Serein.NodeFlow.Env
                 TryAddNode(nodeModel); // 加载项目时将节点加载到环境中
                 
                 await UIContextOperation.InvokeAsync(() => 
-                    OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeModel, nodeInfo.Position))); // 添加到UI上
+                    OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeInfo.CanvasGuid, nodeModel, nodeInfo.Position))); // 添加到UI上
             }
             #endregion
 
@@ -853,7 +873,7 @@ namespace Serein.NodeFlow.Env
                     if (result)
                     {
                         await UIContextOperation.InvokeAsync(() => OnNodePlace?.Invoke(
-                            new NodePlaceEventArgs(nodeModel.Guid, containerNode.Guid)));
+                            new NodePlaceEventArgs(nodeInfo.CanvasGuid, nodeModel.Guid, containerNode.Guid)));
                     }
                     
 
@@ -864,6 +884,7 @@ namespace Serein.NodeFlow.Env
             #region 确定节点之间的方法调用关系
             foreach (var nodeInfo in nodeInfos)
             {
+                var canvasGuid = nodeInfo.CanvasGuid;
                 if (!TryGetNodeModel(nodeInfo.Guid, out var fromNodeModel))
                 {
                     return;
@@ -886,7 +907,7 @@ namespace Serein.NodeFlow.Env
                             // 防御性代码，加载正常保存的项目文件不会进入这里
                             continue;
                         };
-                        var isSuccessful = ConnectInvokeOfNode(fromNodeModel, toNodeModel, item.connectionType); // 加载时确定节点间的连接关系
+                        var isSuccessful = ConnectInvokeOfNode(canvasGuid, fromNodeModel, toNodeModel, item.connectionType); // 加载时确定节点间的连接关系
                     }
                 }
 
@@ -916,6 +937,7 @@ namespace Serein.NodeFlow.Env
             #region 确定节点之间的参数调用关系
             foreach (var toNode in NodeModels.Values)
             {
+                var canvasGuid = toNode.Guid;
                 if (toNode.MethodDetails.ParameterDetailss == null)
                 {
                     continue;
@@ -927,7 +949,7 @@ namespace Serein.NodeFlow.Env
                         && NodeModels.TryGetValue(pd.ArgDataSourceNodeGuid, out var fromNode))
                     {
 
-                        await ConnectArgSourceOfNodeAsync(fromNode, toNode, pd.ArgDataSourceType, pd.Index);
+                        await ConnectArgSourceOfNodeAsync(canvasGuid, fromNode, toNode, pd.ArgDataSourceType, pd.Index);
                     }
                 }
             }
@@ -945,14 +967,19 @@ namespace Serein.NodeFlow.Env
         /// <summary>
         /// 流程正在运行时创建节点
         /// </summary>
-        /// <param name="nodeControlType"></param>
-        /// <param name="position"></param>
+        /// <param name="canvasGuid">所属画布</param>
+        /// <param name="nodeControlType">所属类型</param>
+        /// <param name="position">所处位置</param>
         /// <param name="methodDetailsInfo">如果是表达式节点条件节点，该项为null</param>
-        public Task<NodeInfo> CreateNodeAsync(NodeControlType nodeControlType, 
+        public Task<NodeInfo> CreateNodeAsync(string canvasGuid, 
+                                              NodeControlType nodeControlType, 
                                               PositionOfUI position,
                                               MethodDetailsInfo? methodDetailsInfo = null)
         {
-            
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return Task.FromResult<NodeInfo>(null);
+            }
             NodeModelBase? nodeModel;
             if (methodDetailsInfo is null)
             {
@@ -976,13 +1003,13 @@ namespace Serein.NodeFlow.Env
             nodeModel.Position = position;
 
             // 通知UI更改
-            UIContextOperation?.Invoke(() => OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeModel, position)));
+            UIContextOperation?.Invoke(() => OnNodeCreate?.Invoke(new NodeCreateEventArgs(canvasGuid, nodeModel, position)));
 
             // 因为需要UI先布置了元素，才能通知UI变更特效
             // 如果不存在流程起始控件，默认设置为流程起始控件
             if (StartNode is null)
             {
-                SetStartNode(nodeModel);
+                SetStartNode(canvasGuid, nodeModel);
             }
             var nodeInfo = nodeModel.ToInfo();
             return Task.FromResult(nodeInfo);
@@ -993,8 +1020,13 @@ namespace Serein.NodeFlow.Env
         /// 将节点放置在容器中
         /// </summary>
         /// <returns></returns>
-        public Task<bool> PlaceNodeToContainerAsync(string nodeGuid, string containerNodeGuid)
+        public Task<bool> PlaceNodeToContainerAsync(string canvasGuid,
+                                              string nodeGuid, string containerNodeGuid)
         {
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return Task.FromResult<bool>(false);
+            }
             // 获取目标节点与容器节点
             if (!TryGetNodeModel(nodeGuid, out var nodeModel))
             {
@@ -1017,7 +1049,7 @@ namespace Serein.NodeFlow.Env
             {
                 _ = UIContextOperation?.InvokeAsync(() =>
                 {
-                    OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
+                    OnNodePlace?.Invoke(new NodePlaceEventArgs(canvasGuid, nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
                 });
             }
             return Task.FromResult(result);
@@ -1028,8 +1060,13 @@ namespace Serein.NodeFlow.Env
         /// 将节点从容器节点中脱离
         /// </summary>
         /// <returns></returns>
-        public Task<bool> TakeOutNodeToContainerAsync(string nodeGuid)
+        public Task<bool> TakeOutNodeToContainerAsync(string canvasGuid,
+                                              string nodeGuid)
         {
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return Task.FromResult<bool>(false);
+            }
             // 获取目标节点与容器节点
             if (!TryGetNodeModel(nodeGuid, out var nodeModel))
             {
@@ -1044,7 +1081,7 @@ namespace Serein.NodeFlow.Env
             {
                 _ = UIContextOperation?.InvokeAsync(() =>
                 {
-                    OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
+                    OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(canvasGuid, nodeGuid)); // 重新放置在画布上
                 });
             }
             return Task.FromResult(result);
@@ -1059,8 +1096,12 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         /// <param name="nodeGuid"></param>
         /// <exception cref="NotImplementedException"></exception>
-        public async Task<bool> RemoveNodeAsync(string nodeGuid)
+        public async Task<bool> RemoveNodeAsync(string canvasGuid, string nodeGuid)
         {
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return false;
+            }
             if (!TryGetNodeModel(nodeGuid, out var remoteNode))
             {
                 return false;
@@ -1083,6 +1124,7 @@ namespace Serein.NodeFlow.Env
                     pNode.SuccessorNodes[pCType].Remove(remoteNode);
 
                     UIContextOperation?.Invoke(() => OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(
+                                                                    canvasGuid,
                                                                     pNode.Guid,
                                                                     remoteNode.Guid,
                                                                     JunctionOfConnectionType.Invoke,
@@ -1100,7 +1142,7 @@ namespace Serein.NodeFlow.Env
                 {
                     NodeModelBase? toNode = snc.Value[i];
 
-                    await RemoteConnectAsync(remoteNode, toNode, connectionType);
+                    await RemoteConnectAsync(canvasGuid, remoteNode, toNode, connectionType);
 
                 }
             }
@@ -1109,7 +1151,7 @@ namespace Serein.NodeFlow.Env
 
             // 从集合中移除节点
             NodeModels.Remove(nodeGuid);
-            UIContextOperation?.Invoke(() => OnNodeRemove?.Invoke(new NodeRemoveEventArgs(nodeGuid)));
+            UIContextOperation?.Invoke(() => OnNodeRemove?.Invoke(new NodeRemoveEventArgs(canvasGuid, nodeGuid)));
             return true;
         }
 
@@ -1121,15 +1163,16 @@ namespace Serein.NodeFlow.Env
         /// <param name="fromNodeJunctionType">起始节点控制点</param>
         /// <param name="toNodeJunctionType">目标节点控制点</param>
         /// <param name="invokeType">连接关系</param>
-        public Task<bool> ConnectInvokeNodeAsync(string fromNodeGuid,
+        public Task<bool> ConnectInvokeNodeAsync(string canvasGuid,
+                                                 string fromNodeGuid,
                                                  string toNodeGuid,
                                                  JunctionType fromNodeJunctionType,
                                                  JunctionType toNodeJunctionType,
                                                  ConnectionInvokeType invokeType)
         {
-
+   
             // 获取起始节点与目标节点
-            if (!TryGetNodeModel(fromNodeGuid, out var fromNode) || !TryGetNodeModel(toNodeGuid, out var toNode))
+            if (!FlowCanvass.ContainsKey(canvasGuid) || !TryGetNodeModel(fromNodeGuid, out var fromNode) || !TryGetNodeModel(toNodeGuid, out var toNode))
             {
                 return Task.FromResult(false);
             }
@@ -1150,7 +1193,7 @@ namespace Serein.NodeFlow.Env
                     (fromNode, toNode) = (toNode, fromNode);
                 }
                 // 从起始节点“下一个方法”控制点，连接到目标节点“方法调用”控制点
-                state = ConnectInvokeOfNode(fromNode, toNode, invokeType); // 本地环境进行连接
+                state = ConnectInvokeOfNode(canvasGuid, fromNode, toNode, invokeType); // 本地环境进行连接
             }
             return Task.FromResult(state); 
 
@@ -1192,16 +1235,16 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeGuid">目标节点Guid</param>
         /// <param name="connectionType">连接关系</param>
         /// <exception cref="NotImplementedException"></exception>
-        public async Task<bool> RemoveConnectInvokeAsync(string fromNodeGuid, string toNodeGuid, ConnectionInvokeType connectionType)
+        public async Task<bool> RemoveConnectInvokeAsync(string canvasGuid, string fromNodeGuid, string toNodeGuid, ConnectionInvokeType connectionType)
         {
             // 获取起始节点与目标节点
-            if (!TryGetNodeModel(fromNodeGuid, out var fromNode) || !TryGetNodeModel(toNodeGuid, out var toNode))
+            if (!FlowCanvass.ContainsKey(canvasGuid) || !TryGetNodeModel(fromNodeGuid, out var fromNode) || !TryGetNodeModel(toNodeGuid, out var toNode))
             {
                 return false;
             }
             if (fromNode is null || toNode is null) return false;
 
-            var result = await RemoteConnectAsync(fromNode, toNode, connectionType);
+            var result = await RemoteConnectAsync(canvasGuid, fromNode, toNode, connectionType);
             return result;
         }
 
@@ -1215,7 +1258,8 @@ namespace Serein.NodeFlow.Env
         /// <param name="argIndex">目标节点的第几个参数</param>
         /// <param name="connectionArgSourceType">调用目标节点对应方法时，对应参数来源类型</param>
         /// <returns></returns>
-        public async Task<bool> ConnectArgSourceNodeAsync(string fromNodeGuid,
+        public async Task<bool> ConnectArgSourceNodeAsync(string canvasGuid, 
+                                                string fromNodeGuid,
                                                  string toNodeGuid,
                                                  JunctionType fromNodeJunctionType,
                                                  JunctionType toNodeJunctionType,
@@ -1224,7 +1268,7 @@ namespace Serein.NodeFlow.Env
         {
 
             // 获取起始节点与目标节点
-            if (!TryGetNodeModel(fromNodeGuid, out var fromNode) || !TryGetNodeModel(toNodeGuid, out var toNode))
+            if (!FlowCanvass.ContainsKey(canvasGuid) || !TryGetNodeModel(fromNodeGuid, out var fromNode) || !TryGetNodeModel(toNodeGuid, out var toNode))
             {
                 return false;
             }
@@ -1246,7 +1290,7 @@ namespace Serein.NodeFlow.Env
                 }
 
                 // 确定方法入参关系
-                state = await ConnectArgSourceOfNodeAsync(fromNode, toNode, connectionArgSourceType, argIndex);  // 本地环境进行连接
+                state = await ConnectArgSourceOfNodeAsync(canvasGuid, fromNode, toNode, connectionArgSourceType, argIndex);  // 本地环境进行连接
             }
             return state;
 
@@ -1259,15 +1303,15 @@ namespace Serein.NodeFlow.Env
         /// <param name="fromNodeGuid">起始节点Guid</param>
         /// <param name="toNodeGuid">目标节点Guid</param>
         /// <param name="argIndex">连接到第几个参数</param>
-        public async Task<bool> RemoveConnectArgSourceAsync(string fromNodeGuid, string toNodeGuid, int argIndex)
+        public async Task<bool> RemoveConnectArgSourceAsync(string canvasGuid, string fromNodeGuid, string toNodeGuid, int argIndex)
         {
             // 获取起始节点与目标节点
-            if (!TryGetNodeModel(fromNodeGuid, out var fromNode) || !TryGetNodeModel(toNodeGuid, out var toNode))
+            if (!FlowCanvass.ContainsKey(canvasGuid) || !TryGetNodeModel(fromNodeGuid, out var fromNode) || !TryGetNodeModel(toNodeGuid, out var toNode))
             {
                 return false;
             }
             if (fromNode is null || toNode is null) return false;
-            var result = await RemoteConnectAsync(fromNode, toNode, argIndex);
+            var result = await RemoteConnectAsync(canvasGuid, fromNode, toNode, argIndex);
             return result;
         }
 
@@ -1328,9 +1372,9 @@ namespace Serein.NodeFlow.Env
         /// <param name="nodeGuid"></param>
         /// <param name="x"></param>
         /// <param name="y"></param>
-        public void MoveNode(string nodeGuid, double x, double y)
+        public void MoveNode(string canvasGuid, string nodeGuid, double x, double y)
         {
-            if (!TryGetNodeModel(nodeGuid, out var nodeModel))
+            if (!FlowCanvass.ContainsKey(canvasGuid) || !TryGetNodeModel(nodeGuid, out var nodeModel))
             {
                 return;
             }
@@ -1344,13 +1388,13 @@ namespace Serein.NodeFlow.Env
         /// 设置起点控件
         /// </summary>
         /// <param name="newNodeGuid"></param>
-        public Task<string> SetStartNodeAsync(string newNodeGuid)
+        public Task<string> SetStartNodeAsync(string canvasGuid, string newNodeGuid)
         {
-            if (!TryGetNodeModel(newNodeGuid, out var newStartNodeModel))
+            if (!FlowCanvass.ContainsKey(canvasGuid) || !TryGetNodeModel(newNodeGuid, out var newStartNodeModel))
             {
                 return Task.FromResult(StartNode?.Guid ?? string.Empty);
             }
-            SetStartNode(newStartNodeModel);
+            SetStartNode(canvasGuid, newStartNodeModel);
             return Task.FromResult(StartNode?.Guid ?? string.Empty);
         }
 
@@ -1483,7 +1527,6 @@ namespace Serein.NodeFlow.Env
 
         #endregion
 
-
         #region 流程依赖类库的接口
 
 
@@ -1580,21 +1623,27 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeGuid">目标节点Model</param>
         /// <param name="connectionType">连接关系</param>
         /// <exception cref="NotImplementedException"></exception>
-        private async Task<bool> RemoteConnectAsync(NodeModelBase fromNode, NodeModelBase toNode, ConnectionInvokeType connectionType)
+        private async Task<bool> RemoteConnectAsync(string canvasGuid, NodeModelBase fromNode, NodeModelBase toNode, ConnectionInvokeType connectionType)
         {
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return false;
+            }
             fromNode.SuccessorNodes[connectionType].Remove(toNode);
             toNode.PreviousNodes[connectionType].Remove(fromNode);
 
 
             if (OperatingSystem.IsWindows())
             {
-                await UIContextOperation.InvokeAsync(() => OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(
-                                                                          fromNode.Guid,
-                                                                          toNode.Guid,
-                                                                          JunctionOfConnectionType.Invoke,
-                                                                          connectionType,
-                                                                          NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
-            }
+                await UIContextOperation.InvokeAsync(() => OnNodeConnectChange?.Invoke(
+                    new NodeConnectChangeEventArgs(
+                        canvasGuid,
+                        fromNode.Guid,
+                        toNode.Guid,
+                        JunctionOfConnectionType.Invoke,
+                        connectionType,
+                        NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
+                    }
             return true;
         }
          /// <summary>
@@ -1604,8 +1653,12 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeGuid">目标节点Model</param>
         /// <param name="connectionType">连接关系</param>
         /// <exception cref="NotImplementedException"></exception>
-        private async Task<bool> RemoteConnectAsync(NodeModelBase fromNode, NodeModelBase toNode, int argIndex)
+        private async Task<bool> RemoteConnectAsync(string canvasGuid, NodeModelBase fromNode, NodeModelBase toNode, int argIndex)
         {
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return false;
+            }
             if (string.IsNullOrEmpty(toNode.MethodDetails.ParameterDetailss[argIndex].ArgDataSourceNodeGuid))
             {
                 return false;
@@ -1615,14 +1668,16 @@ namespace Serein.NodeFlow.Env
 
             if (OperatingSystem.IsWindows())
             {
-                await UIContextOperation.InvokeAsync(() => OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(
-                                                                          fromNode.Guid,
-                                                                          toNode.Guid,
-                                                                          JunctionOfConnectionType.Arg,
-                                                                          argIndex,
-                                                                          ConnectionArgSourceType.GetPreviousNodeData,
-                                                                          NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
-            }
+                await UIContextOperation.InvokeAsync(() => OnNodeConnectChange?.Invoke(
+                    new NodeConnectChangeEventArgs(
+                        canvasGuid,                                             
+                        fromNode.Guid,
+                        toNode.Guid,
+                        JunctionOfConnectionType.Arg,
+                        argIndex,
+                        ConnectionArgSourceType.GetPreviousNodeData,
+                        NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
+                    }
             return true;
         }
 
@@ -1721,8 +1776,12 @@ namespace Serein.NodeFlow.Env
         /// <param name="fromNode">起始节点</param>
         /// <param name="toNode">目标节点</param>
         /// <param name="invokeType">连接关系</param>
-        private bool ConnectInvokeOfNode(NodeModelBase fromNode, NodeModelBase toNode, ConnectionInvokeType invokeType)
+        private bool ConnectInvokeOfNode(string canvasGuid, NodeModelBase fromNode, NodeModelBase toNode, ConnectionInvokeType invokeType)
         {
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return false;
+            }
             if (fromNode is null || toNode is null || fromNode == toNode)
             {
                 return false;
@@ -1783,6 +1842,7 @@ namespace Serein.NodeFlow.Env
                     UIContextOperation?.Invoke(() => 
                         OnNodeConnectChange?.Invoke(
                                 new NodeConnectChangeEventArgs(
+                                     canvasGuid,
                                     fromNode.Guid, // 从哪个节点开始
                                     toNode.Guid, // 连接到那个节点
                                     JunctionOfConnectionType.Invoke, 
@@ -1810,21 +1870,28 @@ namespace Serein.NodeFlow.Env
         /// <param name="connectionArgSourceType"></param>
         /// <param name="argIndex"></param>
         /// <returns></returns>
-        private async Task<bool> ConnectArgSourceOfNodeAsync(NodeModelBase fromNode,
+        private async Task<bool> ConnectArgSourceOfNodeAsync(string canvasGuid,
+                                                            NodeModelBase fromNode,
                                                              NodeModelBase toNode,
                                                              ConnectionArgSourceType connectionArgSourceType,
                                                              int argIndex)
         {
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return false;
+            }
+
             var toNodeArgSourceGuid = toNode.MethodDetails.ParameterDetailss[argIndex].ArgDataSourceNodeGuid;
             if (!string.IsNullOrEmpty(toNodeArgSourceGuid))
             {
-                await RemoteConnectAsync(fromNode, toNode, argIndex);
+                await RemoteConnectAsync(canvasGuid, fromNode, toNode, argIndex);
             }
             toNode.MethodDetails.ParameterDetailss[argIndex].ArgDataSourceNodeGuid = fromNode.Guid;
             toNode.MethodDetails.ParameterDetailss[argIndex].ArgDataSourceType = connectionArgSourceType;
             await UIContextOperation.InvokeAsync(() =>
                         OnNodeConnectChange?.Invoke(
                                 new NodeConnectChangeEventArgs(
+                                    canvasGuid,
                                     fromNode.Guid, // 从哪个节点开始
                                     toNode.Guid, // 连接到那个节点
                                     JunctionOfConnectionType.Arg,
@@ -1841,11 +1908,15 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         /// <param name="newStartNode"></param>
         /// <param name="oldStartNode"></param>
-        private void SetStartNode(NodeModelBase newStartNode)
+        private void SetStartNode(string canvasGuid, NodeModelBase newStartNode)
         {
+            if (!FlowCanvass.ContainsKey(canvasGuid))
+            {
+                return;
+            }
             var oldNodeGuid = StartNode?.Guid;
             StartNode = newStartNode;
-            UIContextOperation?.Invoke(() => OnStartNodeChange?.Invoke(new StartNodeChangeEventArgs(oldNodeGuid, StartNode.Guid)));
+            UIContextOperation?.Invoke(() => OnStartNodeChange?.Invoke(new StartNodeChangeEventArgs(canvasGuid, oldNodeGuid, StartNode.Guid)));
 
             //if (OperatingSystem.IsWindows())
             //{

NodeFlow/Env/FlowEnvironmentDecorator.cs

@@ -56,6 +56,8 @@ namespace Serein.NodeFlow.Env
 
 
         private int _loadingProjectFlag = 0; // 使用原子自增代替锁
+
+
         /// <summary>
         /// 传入false时，将停止数据通知。传入true时，
         /// </summary>
@@ -131,6 +133,18 @@ namespace Serein.NodeFlow.Env
             remove { currentFlowEnvironmentEvent.OnNodeConnectChange -= value; }
         }
 
+
+        public event CanvasCreateHandler OnCanvasCreate
+        {
+            add { currentFlowEnvironmentEvent.OnCanvasCreate += value; }
+            remove { currentFlowEnvironmentEvent.OnCanvasCreate -= value; }
+        }
+        public event CanvasRemoveHandler OnCanvasRemove
+        {
+            add { currentFlowEnvironmentEvent.OnCanvasRemove += value; }
+            remove { currentFlowEnvironmentEvent.OnCanvasRemove -= value; }
+        }
+
         public event NodeCreateHandler OnNodeCreate
         {
             add { currentFlowEnvironmentEvent.OnNodeCreate += value; }
@@ -217,7 +231,27 @@ namespace Serein.NodeFlow.Env
             currentFlowEnvironment.ActivateFlipflopNode(nodeGuid);
         }
 
-        
+        /// <summary>
+        /// 增加画布
+        /// </summary>
+        /// <param name="canvasName">画布名称</param>
+        /// <param name="width">宽度</param>
+        /// <param name="height">高度</param>
+        /// <returns></returns>
+        public async Task<FlowCanvasInfo> CreateCanvasAsync(string canvasName, int width, int height)
+        {
+            return await currentFlowEnvironment.CreateCanvasAsync(canvasName, width, height);
+        }
+
+        /// <summary>
+        /// 删除画布
+        /// </summary>
+        /// <param name="canvasGuid">画布Guid</param>
+        /// <returns></returns>
+        public async Task<bool> RemoteCanvasAsync(string canvasGuid)
+        {
+            return await currentFlowEnvironment.RemoteCanvasAsync(canvasGuid);
+        }
 
 
         /// <summary>
@@ -228,13 +262,14 @@ namespace Serein.NodeFlow.Env
         /// <param name="fromNodeJunctionType">起始节点控制点</param>
         /// <param name="toNodeJunctionType">目标节点控制点</param>
         /// <param name="invokeType">决定了方法执行后的后继行为</param>
-        public async Task<bool> ConnectInvokeNodeAsync(string fromNodeGuid,
+        public async Task<bool> ConnectInvokeNodeAsync(string canvasGuid, 
+                                                string fromNodeGuid,
                                                  string toNodeGuid,
                                                  JunctionType fromNodeJunctionType,
                                                  JunctionType toNodeJunctionType,
                                                  ConnectionInvokeType invokeType)
         {
-            return await currentFlowEnvironment.ConnectInvokeNodeAsync(fromNodeGuid, toNodeGuid, fromNodeJunctionType, toNodeJunctionType, invokeType);
+            return await currentFlowEnvironment.ConnectInvokeNodeAsync(canvasGuid, fromNodeGuid, toNodeGuid, fromNodeJunctionType, toNodeJunctionType, invokeType);
         }
 
 
@@ -247,14 +282,15 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeJunctionType">目标节点控制点</param>
         /// <param name="argSourceType">决定了方法参数来源</param>
         /// <param name="argIndex">设置第几个参数</param>
-        public async Task<bool> ConnectArgSourceNodeAsync(string fromNodeGuid,
+        public async Task<bool> ConnectArgSourceNodeAsync(string canvasGuid, 
+                                                string fromNodeGuid,
                                                  string toNodeGuid,
                                                  JunctionType fromNodeJunctionType,
                                                  JunctionType toNodeJunctionType,
                                                  ConnectionArgSourceType argSourceType,
                                                  int argIndex)
         {
-            return await currentFlowEnvironment.ConnectArgSourceNodeAsync(fromNodeGuid, toNodeGuid, fromNodeJunctionType, toNodeJunctionType, argSourceType, argIndex);
+            return await currentFlowEnvironment.ConnectArgSourceNodeAsync(canvasGuid, fromNodeGuid, toNodeGuid, fromNodeJunctionType, toNodeJunctionType, argSourceType, argIndex);
         }
 
 
@@ -291,10 +327,10 @@ namespace Serein.NodeFlow.Env
             SetProjectLoadingFlag(true);
         }
 
-        public async Task<NodeInfo> CreateNodeAsync(NodeControlType nodeBase, PositionOfUI position, MethodDetailsInfo methodDetailsInfo = null)
+        public async Task<NodeInfo> CreateNodeAsync(string canvasGuid, NodeControlType nodeBase, PositionOfUI position, MethodDetailsInfo methodDetailsInfo = null)
         {
             SetProjectLoadingFlag(false);
-            var result = await currentFlowEnvironment.CreateNodeAsync(nodeBase, position, methodDetailsInfo); // 装饰器调用
+            var result = await currentFlowEnvironment.CreateNodeAsync(canvasGuid, nodeBase, position, methodDetailsInfo); // 装饰器调用
             SetProjectLoadingFlag(true);
             return result;
         }
@@ -304,10 +340,10 @@ namespace Serein.NodeFlow.Env
         /// 将节点放置在容器中
         /// </summary>
         /// <returns></returns>
-        public async Task<bool> PlaceNodeToContainerAsync(string nodeGuid, string containerNodeGuid)
+        public async Task<bool> PlaceNodeToContainerAsync(string canvasGuid, string nodeGuid, string containerNodeGuid)
         {
             SetProjectLoadingFlag(false);
-            var result = await currentFlowEnvironment.PlaceNodeToContainerAsync(nodeGuid, containerNodeGuid); // 装饰器调用
+            var result = await currentFlowEnvironment.PlaceNodeToContainerAsync(canvasGuid, nodeGuid, containerNodeGuid); // 装饰器调用
             SetProjectLoadingFlag(true);
             return result;
         }
@@ -316,10 +352,10 @@ namespace Serein.NodeFlow.Env
         /// 将节点从容器中脱离
         /// </summary>
         /// <returns></returns>
-        public async Task<bool> TakeOutNodeToContainerAsync(string nodeGuid)
+        public async Task<bool> TakeOutNodeToContainerAsync(string canvasGuid, string nodeGuid)
         {
             SetProjectLoadingFlag(false);
-            var result = await currentFlowEnvironment.TakeOutNodeToContainerAsync(nodeGuid); // 装饰器调用
+            var result = await currentFlowEnvironment.TakeOutNodeToContainerAsync(canvasGuid,nodeGuid); // 装饰器调用
             SetProjectLoadingFlag(true);
             return result;
         }
@@ -374,9 +410,9 @@ namespace Serein.NodeFlow.Env
             currentFlowEnvironment.MonitorObjectNotification(nodeGuid, monitorData, sourceType);
         }
 
-        public void MoveNode(string nodeGuid, double x, double y)
+        public void MoveNode(string canvasGuid, string nodeGuid, double x, double y)
         {
-            currentFlowEnvironment.MoveNode(nodeGuid, x, y);
+            currentFlowEnvironment.MoveNode(canvasGuid, nodeGuid, x, y);
         }
 
         public void NodeLocated(string nodeGuid)
@@ -408,9 +444,9 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeGuid"></param>
         /// <param name="connectionType"></param>
         /// <returns></returns>
-        public async Task<bool> RemoveConnectInvokeAsync(string fromNodeGuid, string toNodeGuid, ConnectionInvokeType connectionType)
+        public async Task<bool> RemoveConnectInvokeAsync(string canvasGuid, string fromNodeGuid, string toNodeGuid, ConnectionInvokeType connectionType)
         {
-            return await currentFlowEnvironment.RemoveConnectInvokeAsync(fromNodeGuid, toNodeGuid, connectionType);
+            return await currentFlowEnvironment.RemoveConnectInvokeAsync(canvasGuid, fromNodeGuid, toNodeGuid, connectionType);
         }
 
         /// <summary>
@@ -420,14 +456,14 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeGuid">目标节点Guid</param>
         /// <param name="argIndex">连接到第几个参数</param>
         /// <param name="connectionArgSourceType">参数来源类型</param>
-        public async Task<bool> RemoveConnectArgSourceAsync(string fromNodeGuid, string toNodeGuid, int argIndex)
+        public async Task<bool> RemoveConnectArgSourceAsync(string canvasGuid, string fromNodeGuid, string toNodeGuid, int argIndex)
         {
-            return await currentFlowEnvironment.RemoveConnectArgSourceAsync(fromNodeGuid, toNodeGuid, argIndex);
+            return await currentFlowEnvironment.RemoveConnectArgSourceAsync(canvasGuid, fromNodeGuid, toNodeGuid, argIndex);
         }
 
-        public async Task<bool> RemoveNodeAsync(string nodeGuid)
+        public async Task<bool> RemoveNodeAsync(string canvasGuid, string nodeGuid)
         {
-          return await  currentFlowEnvironment.RemoveNodeAsync(nodeGuid);
+          return await  currentFlowEnvironment.RemoveNodeAsync(canvasGuid, nodeGuid);
         }
 
 
@@ -477,9 +513,9 @@ namespace Serein.NodeFlow.Env
 #endif
 
         #endregion
-        public async Task<string> SetStartNodeAsync(string nodeGuid)
+        public async Task<string> SetStartNodeAsync(string canvasGuid, string nodeGuid)
         {
-            return await currentFlowEnvironment.SetStartNodeAsync(nodeGuid);
+            return await currentFlowEnvironment.SetStartNodeAsync(canvasGuid, nodeGuid);
         }
 
         public async Task<bool> StartFlowAsync()

NodeFlow/Env/MsgControllerOfClient.cs

@@ -132,7 +132,6 @@ namespace Serein.NodeFlow.Env
 
 
 
-
         /// <summary>
         /// 从某个节点开始运行
         /// </summary>
@@ -164,6 +163,18 @@ namespace Serein.NodeFlow.Env
             _ = remoteFlowEnvironment.InvokeTriggerAsync<object>(msgId, null);
         }
 
+        [AutoSocketHandle(ThemeValue = EnvMsgTheme.CreateCanvas, IsReturnValue = false)]
+        public void CreateCanvas([UseMsgId] string msgId, [UseData] FlowCanvasInfo canvasInfo)
+        {
+            _ = remoteFlowEnvironment.InvokeTriggerAsync(msgId, canvasInfo);
+        }
+
+        [AutoSocketHandle(ThemeValue = EnvMsgTheme.RemoveCanvas, IsReturnValue = false)]
+        public void RemoveCanvas([UseMsgId] string msgId, [UseData] bool state)
+        {
+            _ = remoteFlowEnvironment.InvokeTriggerAsync(msgId, state);
+        }
+
 
         /// <summary>
         /// 创建节点

NodeFlow/Env/MsgControllerOfServer.cs

@@ -310,6 +310,22 @@ namespace Serein.NodeFlow.Env
             return false;
         }
 
+
+        [AutoSocketHandle(ThemeValue = EnvMsgTheme.CreateCanvas, IsReturnValue = false)]
+        public  async Task<FlowCanvasInfo> CreateCanvas(string canvasName, int width, int height)
+        {
+            var canvasInfo = await environment.CreateCanvasAsync(canvasName, width, height); // 监听到客户端创建节点的请求
+            return canvasInfo;
+        }
+
+        [AutoSocketHandle(ThemeValue = EnvMsgTheme.RemoveCanvas, IsReturnValue = false)]
+        public async Task<object> RemoveCanvas([Needful] string canvasGuid)
+        {
+            var result = await environment.RemoteCanvasAsync(canvasGuid); // 监听到客户端创建节点的请求
+            return new { state = result} ;
+        }
+
+
         /// <summary>
         /// 从远程环境创建节点
         /// </summary>
@@ -317,13 +333,13 @@ namespace Serein.NodeFlow.Env
         /// <param name="position"></param>
         /// <param name="mdInfo">如果是表达式节点条件节点，该项为null</param>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.CreateNode,ArgNotNull = false)]
-        public async Task<NodeInfo> CreateNode([Needful] string nodeType, [Needful] PositionOfUI position, MethodDetailsInfo? mdInfo = null)
+        public async Task<NodeInfo> CreateNode([Needful] string canvasGuid, [Needful] string nodeType, [Needful] PositionOfUI position, MethodDetailsInfo? mdInfo = null)
         {
             if (!EnumHelper.TryConvertEnum<NodeControlType>(nodeType, out var nodeControlType))
             {
                 return null;
             }
-           var nodeInfo =  await environment.CreateNodeAsync(nodeControlType, position, mdInfo); // 监听到客户端创建节点的请求
+           var nodeInfo =  await environment.CreateNodeAsync(canvasGuid,  nodeControlType, position, mdInfo); // 监听到客户端创建节点的请求
             return nodeInfo;
         }
 
@@ -333,9 +349,9 @@ namespace Serein.NodeFlow.Env
         /// <param name="nodeGuid"></param>
         /// <exception cref="NotImplementedException"></exception>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.RemoveNode)]
-        public async Task<object> RemoveNode(string nodeGuid)
+        public async Task<object> RemoveNode(string canvasGuid, string nodeGuid)
         {
-            var result = await environment.RemoveNodeAsync(nodeGuid);
+            var result = await environment.RemoveNodeAsync(canvasGuid, nodeGuid);
             return new { state = result };
         }
         /// <summary>
@@ -345,20 +361,21 @@ namespace Serein.NodeFlow.Env
         /// <param name="containerNodeGuid"></param>
         /// <exception cref="NotImplementedException"></exception>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.PlaceNode)]
-        public async Task<object> PlaceNode(string nodeGuid, string containerNodeGuid)
+        public async Task<object> PlaceNode( string canvasGuid, string nodeGuid, string containerNodeGuid)
         {
-            var result = await environment.PlaceNodeToContainerAsync(nodeGuid, containerNodeGuid);
+            var result = await environment.PlaceNodeToContainerAsync(canvasGuid,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)
+        public async Task<object> TakeOutNode(string canvasGuid, string nodeGuid)
         {
-            var result = await environment.TakeOutNodeToContainerAsync(nodeGuid);
+            var result = await environment.TakeOutNodeToContainerAsync(canvasGuid, nodeGuid);
             return new { state = result };
         }
 
@@ -366,13 +383,15 @@ namespace Serein.NodeFlow.Env
         /// <summary>
         /// 远程连接节点的方法调用关系
         /// </summary>
+        /// <param name="canvasGuid">画布</param>
         /// <param name="fromNodeGuid">起始节点</param>
         /// <param name="toNodeGuid">目标节点</param>
         /// <param name="fromJunctionType">起始节点控制点</param>
         /// <param name="toJunctionType">目标节点控制点</param>
         /// <param name="invokeType">连接关系</param>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.ConnectInvokeNode)]
-        public async Task<object> ConnectInvokeNode(string fromNodeGuid, 
+        public async Task<object> ConnectInvokeNode(string canvasGuid,
+                                                    string fromNodeGuid, 
                                                     string toNodeGuid, 
                                                     string fromJunctionType,
                                                     string toJunctionType,
@@ -422,7 +441,7 @@ namespace Serein.NodeFlow.Env
             SereinEnv.WriteLine(InfoType.INFO, $"目标节点：{toNodeGuid}");
             SereinEnv.WriteLine(InfoType.INFO, $"链接请求：{(tmpFromJunctionType, tmpToJunctionType)}");
 
-            var result = await environment.ConnectInvokeNodeAsync(fromNodeGuid, toNodeGuid, tmpFromJunctionType, tmpToJunctionType, tmpConnectionType);
+            var result = await environment.ConnectInvokeNodeAsync(canvasGuid, fromNodeGuid, toNodeGuid, tmpFromJunctionType, tmpToJunctionType, tmpConnectionType);
             return new { state = result };
         }
 
@@ -433,7 +452,7 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeGuid">目标节点Guid</param>
         /// <param name="invokeType">连接关系</param>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.RemoveInvokeConnect)]
-        public async Task<object> RemoveInvokeConnect(string fromNodeGuid, string toNodeGuid, string invokeType)
+        public async Task<object> RemoveInvokeConnect(string canvasGuid, string fromNodeGuid, string toNodeGuid, string invokeType)
         {
             if (!EnumHelper.TryConvertEnum<ConnectionInvokeType>(invokeType, out var tmpConnectionType))
             {
@@ -442,10 +461,11 @@ namespace Serein.NodeFlow.Env
                     state = false
                 };
             }
-            var result = await environment.RemoveConnectInvokeAsync(fromNodeGuid, toNodeGuid, tmpConnectionType);
+            var result = await environment.RemoveConnectInvokeAsync(canvasGuid,fromNodeGuid, toNodeGuid, tmpConnectionType);
             return new { state = result };
         }
 
+        
 
         /// <summary>
         /// 远程连接节点的参数传递关系
@@ -457,7 +477,8 @@ namespace Serein.NodeFlow.Env
         /// <param name="argSourceType">入参参数来源类型</param>
         /// <param name="argIndex">第几个参数</param>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.ConnectArgSourceNode)]
-        public async Task<object> ConnectArgSourceNode(string fromNodeGuid,
+        public async Task<object> ConnectArgSourceNode(string canvasGuid, 
+                                                       string fromNodeGuid,
                                                        string toNodeGuid,
                                                        string fromJunctionType,
                                                        string toJunctionType,
@@ -511,7 +532,7 @@ namespace Serein.NodeFlow.Env
             }
 
             // 调用环境接口进行连接
-            var result = await environment.ConnectArgSourceNodeAsync(fromNodeGuid, toNodeGuid, tmpFromJunctionType, tmpToJunctionType, tmpArgSourceType, argIndex);
+            var result = await environment.ConnectArgSourceNodeAsync(canvasGuid, fromNodeGuid, toNodeGuid, tmpFromJunctionType, tmpToJunctionType, tmpArgSourceType, argIndex);
             return new { state = result };
         }
 
@@ -522,11 +543,11 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeGuid">目标节点Guid</param>
         /// <param name="argIndex">目标节点的第几个参数</param>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.RemoveArgSourceConnect)]
-        public async Task<object> RemoveArgSourceConnect(string fromNodeGuid, string toNodeGuid, int argIndex)
+        public async Task<object> RemoveArgSourceConnect(string canvasGuid, string fromNodeGuid, string toNodeGuid, int argIndex)
         {
 
 
-            var result = await environment.RemoveConnectArgSourceAsync(fromNodeGuid, toNodeGuid, argIndex);
+            var result = await environment.RemoveConnectArgSourceAsync(canvasGuid,fromNodeGuid, toNodeGuid, argIndex);
             return new
             {
                 state = result
@@ -540,9 +561,9 @@ namespace Serein.NodeFlow.Env
         /// <param name="x"></param>
         /// <param name="y"></param>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.MoveNode)]
-        public void MoveNode(string nodeGuid, double x, double y)
+        public void MoveNode(string canvasGuid, string nodeGuid, double x, double y)
         {
-            environment.MoveNode(nodeGuid, x, y);
+            environment.MoveNode(canvasGuid, nodeGuid, x, y);
         }
 
         /// <summary>
@@ -550,9 +571,9 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         /// <param name="nodeGuid"></param>
         [AutoSocketHandle(ThemeValue = EnvMsgTheme.SetStartNode)]
-        public async Task<string> SetStartNode([NotNull]string nodeGuid)
+        public async Task<string> SetStartNode(string canvasGuid, [NotNull]string nodeGuid)
         {
-            return await environment.SetStartNodeAsync(nodeGuid);
+            return await environment.SetStartNodeAsync(canvasGuid, nodeGuid);
         }
 
 

NodeFlow/Env/RemoteFlowEnvironment.cs

@@ -45,7 +45,9 @@ namespace Serein.NodeFlow.Env
 
         public event LoadDllHandler OnDllLoad;
         public event ProjectLoadedHandler OnProjectLoaded;
-        public event ProjectSavingHandler? OnProjectSaving;
+        public event ProjectSavingHandler OnProjectSaving;
+        public event CanvasCreateHandler OnCanvasCreate;
+        public event CanvasRemoveHandler OnCanvasRemove;
         public event NodeConnectChangeHandler OnNodeConnectChange;
         public event NodeCreateHandler OnNodeCreate;
         public event NodeRemoveHandler OnNodeRemove;
@@ -165,9 +167,14 @@ namespace Serein.NodeFlow.Env
             }
             #endregion
 
+            var nodeInfos = flowEnvInfo.Project.Nodes.ToList();
+            LoadNodeInfos(nodeInfos); // 加载节点
 
-            LoadNodeInfos(flowEnvInfo.Project.Nodes.ToList()); // 加载节点
-            _ = SetStartNodeAsync(flowEnvInfo.Project.StartNode); // 设置流程起点
+            var canvasGuid = nodeInfos.FirstOrDefault(item => item.Guid == flowEnvInfo.Project.StartNode)?.CanvasGuid;
+            if (!string.IsNullOrEmpty(canvasGuid))
+            {
+                _ = SetStartNodeAsync(canvasGuid, flowEnvInfo.Project.StartNode); // 设置流程起点
+            }
             UIContextOperation?.Invoke(() =>
             {
                 OnProjectLoaded?.Invoke(new ProjectLoadedEventArgs()); // 加载完成
@@ -413,13 +420,67 @@ namespace Serein.NodeFlow.Env
             return result;
         }
 
+        /// <summary>
+        /// 增加画布
+        /// </summary>
+        /// <param name="canvasName">画布名称</param>
+        /// <param name="width">宽度</param>
+        /// <param name="height">高度</param>
+        /// <returns></returns>
+        public async Task<FlowCanvasInfo> CreateCanvasAsync(string canvasName, int width, int height)
+        {
+            var info = await msgClient.SendAndWaitDataAsync<FlowCanvasInfo>(EnvMsgTheme.CreateCanvas, new
+            {
+                canvasName,
+                width,
+                height,
+            });
+            if (info is not null)
+            {
+                var model = new FlowCanvasModel(this)
+                {
+                    Guid = info.Guid,
+                    Height = info.Height,
+                    Name = info.Name,
+                    Width = info.Width,
+                };
+                UIContextOperation?.Invoke(() =>
+                    OnCanvasCreate?.Invoke(new CanvasCreateEventArgs(info)));
+
+                return info;
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// 删除画布
+        /// </summary>
+        /// <param name="canvasGuid">画布Guid</param>
+        /// <returns></returns>
+        public async Task<bool> RemoteCanvasAsync(string canvasGuid)
+        {
+            var result = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.RemoveCanvas, new
+            {
+                canvasGuid
+            });
+            if (result)
+            {
+                UIContextOperation?.Invoke(() =>
+                    OnCanvasRemove?.Invoke(new CanvasRemoveEventArgs(canvasGuid)));
+
+            }
+            return true;
+        }
+
+
         /// <summary>
         /// 移动节点，通知远程环境也一起移动，保持相对位置一致
         /// </summary>
         /// <param name="nodeGuid"></param>
         /// <param name="x"></param>
         /// <param name="y"></param>
-        public void MoveNode(string nodeGuid, double x, double y)
+        public void MoveNode(string cavnasGuid, string nodeGuid, double x, double y)
         {
             //UIContextOperation?.Invoke(() =>
             //{
@@ -428,6 +489,7 @@ namespace Serein.NodeFlow.Env
             _ = msgClient.SendAsync(EnvMsgTheme.MoveNode,
                     new
                     {
+                        cavnasGuid,
                         nodeGuid,
                         x,
                         y
@@ -446,16 +508,16 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         /// <param name="nodeGuid">尝试设置为起始节点的节点Guid</param>
         /// <returns>被设置为起始节点的Guid</returns>
-        public async Task<string> SetStartNodeAsync(string nodeGuid)
+        public async Task<string> SetStartNodeAsync(string canvasGuid, string nodeGuid)
         {
-
             var newNodeGuid = await msgClient.SendAndWaitDataAsync<string>(EnvMsgTheme.SetStartNode, new
             {
+                canvasGuid,
                 nodeGuid
             });
             if (NodeModels.TryGetValue(newNodeGuid, out var nodeModel)) // 存在节点
             {
-                UIContextOperation?.Invoke(() => OnStartNodeChange?.Invoke(new StartNodeChangeEventArgs(nodeGuid, newNodeGuid)));
+                UIContextOperation?.Invoke(() => OnStartNodeChange?.Invoke(new StartNodeChangeEventArgs(canvasGuid, nodeGuid, newNodeGuid)));
             }
             return newNodeGuid;
         }
@@ -469,7 +531,8 @@ namespace Serein.NodeFlow.Env
         /// <param name="fromNodeJunctionType">起始节点控制点</param>
         /// <param name="toNodeJunctionType">目标节点控制点</param>
         /// <param name="invokeType">决定了方法执行后的后继行为</param>
-        public async Task<bool> ConnectInvokeNodeAsync(string fromNodeGuid,
+        public async Task<bool> ConnectInvokeNodeAsync(string canvasGuid,
+                                                        string fromNodeGuid,
                                                          string toNodeGuid,
                                                          JunctionType fromNodeJunctionType,
                                                          JunctionType toNodeJunctionType,
@@ -505,6 +568,7 @@ namespace Serein.NodeFlow.Env
 
             var sendObj = new
             {
+                canvasGuid = canvasGuid,
                 fromNodeGuid = fromNodeGuid,
                 toNodeGuid = toNodeGuid,
                 fromJunctionType = fromNodeJunctionType.ToString(),
@@ -514,7 +578,8 @@ namespace Serein.NodeFlow.Env
             var result = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.ConnectInvokeNode, sendObj);
             if (result)
             {
-                OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(fromNodeGuid,
+                OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(canvasGuid,
+                                                                            fromNodeGuid,
                                                                             toNodeGuid,
                                                                             JunctionOfConnectionType.Invoke,
                                                                             invokeType,
@@ -532,7 +597,8 @@ namespace Serein.NodeFlow.Env
         /// <param name="toNodeJunctionType">目标节点控制点</param>
         /// <param name="argSourceType">决定了方法参数来源</param>
         /// <param name="argIndex">设置第几个参数</param>
-        public async Task<bool> ConnectArgSourceNodeAsync(string fromNodeGuid,
+        public async Task<bool> ConnectArgSourceNodeAsync(string canvasGuid,
+                                                string fromNodeGuid,
                                                  string toNodeGuid,
                                                  JunctionType fromNodeJunctionType,
                                                  JunctionType toNodeJunctionType,
@@ -576,6 +642,7 @@ namespace Serein.NodeFlow.Env
 
             var sendObj = new
             {
+                canvasGuid = canvasGuid,
                 fromNodeGuid = fromNodeGuid,
                 toNodeGuid = toNodeGuid,
                 fromJunctionType = fromNodeJunctionType.ToString(),
@@ -586,7 +653,8 @@ namespace Serein.NodeFlow.Env
             var result = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.ConnectArgSourceNode, sendObj);
             if (result)
             {
-                OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(fromNodeGuid,
+                OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(canvasGuid,
+                                                                            fromNodeGuid,
                                                                             toNodeGuid,
                                                                             JunctionOfConnectionType.Arg,
                                                                             argIndex,
@@ -615,7 +683,7 @@ namespace Serein.NodeFlow.Env
         /// <param name="fromNodeGuid">起始节点</param>
         /// <param name="toNodeGuid">目标节点</param>
         /// <param name="invokeType">连接类型</param>
-        public async Task<bool> RemoveConnectInvokeAsync(string fromNodeGuid, string toNodeGuid, ConnectionInvokeType invokeType)
+        public async Task<bool> RemoveConnectInvokeAsync(string canvasGuid, string fromNodeGuid, string toNodeGuid, ConnectionInvokeType invokeType)
         {
             var result = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.RemoveInvokeConnect, new
             {
@@ -627,7 +695,8 @@ namespace Serein.NodeFlow.Env
             {
                 UIContextOperation.Invoke(() =>
                 {
-                    OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(fromNodeGuid,
+                    OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(canvasGuid,
+                                                                            fromNodeGuid,
                                                                             toNodeGuid,
                                                                             JunctionOfConnectionType.Invoke,
                                                                             invokeType,
@@ -643,7 +712,7 @@ namespace Serein.NodeFlow.Env
         /// <param name="fromNodeGuid">起始节点Guid</param>
         /// <param name="toNodeGuid">目标节点Guid</param>
         /// <param name="argIndex">连接到第几个参数</param>
-        public async Task<bool> RemoveConnectArgSourceAsync(string fromNodeGuid, string toNodeGuid, int argIndex)
+        public async Task<bool> RemoveConnectArgSourceAsync(string canvasGuid, string fromNodeGuid, string toNodeGuid, int argIndex)
         {
             var result = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.RemoveArgSourceConnect, new
             {
@@ -655,7 +724,8 @@ namespace Serein.NodeFlow.Env
             {
                 UIContextOperation.Invoke(() =>
                 {
-                    OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(fromNodeGuid,
+                    OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(canvasGuid,
+                                                                               fromNodeGuid,
                                                                                toNodeGuid,
                                                                                JunctionOfConnectionType.Arg,
                                                                                argIndex,
@@ -686,6 +756,7 @@ namespace Serein.NodeFlow.Env
             #region 尝试从节点信息加载节点
             foreach (NodeInfo? nodeInfo in nodeInfos)
             {
+                var canvasGuid = nodeInfo.CanvasGuid;
                 if (!EnumHelper.TryConvertEnum<NodeControlType>(nodeInfo.Type, out var controlType))
                 {
                     continue;
@@ -701,11 +772,11 @@ namespace Serein.NodeFlow.Env
                             continue; // 有方法名称，但本地没有缓存的相关方法信息，跳过
                         }
                         // 加载远程环境时尝试获取方法信息
-                        newNodeInfo = await CreateNodeAsync(controlType, nodeInfo.Position, methodDetails.ToInfo());
+                        newNodeInfo = await CreateNodeAsync(canvasGuid, controlType, nodeInfo.Position, methodDetails.ToInfo());
                     }
                     else
                     {
-                        newNodeInfo = await CreateNodeAsync(controlType, nodeInfo.Position);
+                        newNodeInfo = await CreateNodeAsync(canvasGuid, controlType, nodeInfo.Position);
                     }
                     loadSuuccessNodes.Add(nodeInfo);
                 }
@@ -738,8 +809,9 @@ namespace Serein.NodeFlow.Env
             loadFailureNodes.Clear();
             foreach (var nodeInfo in needPlaceNodeInfos)
             {
+                var canvasGuid = nodeInfo.CanvasGuid;
                 // 通知远程调整节点放置位置
-                var isSuuccess = await PlaceNodeToContainerAsync(nodeInfo.Guid, nodeInfo.ParentNodeGuid);
+                var isSuuccess = await PlaceNodeToContainerAsync(canvasGuid, nodeInfo.Guid, nodeInfo.ParentNodeGuid);
                 if (isSuuccess)
                 {
                     loadSuuccessNodes.Add(nodeInfo);
@@ -765,13 +837,15 @@ namespace Serein.NodeFlow.Env
         /// <param name="nodeType">节点/区域/基础控件类型</param>
         /// <param name="position">节点在画布上的位置（</param>
         /// <param name="methodDetailsInfo">节点绑定的方法说明</param>
-        public async Task<NodeInfo> CreateNodeAsync(NodeControlType nodeControlType, 
-            PositionOfUI position,
-            MethodDetailsInfo methodDetailsInfo = null)
+        public async Task<NodeInfo> CreateNodeAsync(string canvasGuid,
+                                                    NodeControlType nodeControlType, 
+                                                    PositionOfUI position,
+                                                    MethodDetailsInfo methodDetailsInfo = null)
         {
             IsLoadingNode = true;
             var nodeInfo = await msgClient.SendAndWaitDataAsync<NodeInfo>(EnvMsgTheme.CreateNode, new
             {
+                canvasGuid = canvasGuid,
                 nodeType = nodeControlType.ToString(),
                 position = position,
                 mdInfo = methodDetailsInfo,
@@ -792,7 +866,7 @@ namespace Serein.NodeFlow.Env
             // 通知UI更改
             UIContextOperation.Invoke(() =>
             {
-                OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeModel, position));
+                OnNodeCreate?.Invoke(new NodeCreateEventArgs(canvasGuid, nodeModel, position));
             });
             return nodeInfo;
         }
@@ -803,10 +877,11 @@ namespace Serein.NodeFlow.Env
         /// 将节点放置在容器中
         /// </summary>
         /// <returns></returns>
-        public async Task<bool> PlaceNodeToContainerAsync(string nodeGuid, string containerNodeGuid)
+        public async Task<bool> PlaceNodeToContainerAsync(string canvasGuid, string nodeGuid, string containerNodeGuid)
         {
             var isSuuccess = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.PlaceNode, new
             {
+                canvasGuid = canvasGuid,
                 nodeGuid = nodeGuid,
                 containerNodeGuid = containerNodeGuid,
             });
@@ -822,7 +897,7 @@ namespace Serein.NodeFlow.Env
                     // 通知UI更改
                     UIContextOperation.Invoke(() =>
                     {
-                        OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
+                        OnNodePlace?.Invoke(new NodePlaceEventArgs(canvasGuid, nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
                     });
                 }
                 return result;
@@ -834,7 +909,7 @@ namespace Serein.NodeFlow.Env
         /// 将节点从容器中脱离
         /// </summary>
         /// <returns></returns>
-        public async Task<bool> TakeOutNodeToContainerAsync(string nodeGuid)
+        public async Task<bool> TakeOutNodeToContainerAsync(string canvasGuid, string nodeGuid)
         {
             var isSuuccess = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.TakeOutNode, new
             {
@@ -854,7 +929,7 @@ namespace Serein.NodeFlow.Env
                     // 通知UI更改
                     UIContextOperation.Invoke(() =>
                     {
-                        OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
+                        OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(canvasGuid, nodeGuid)); // 重新放置在画布上
                     });
                 }
                 return result;
@@ -869,7 +944,7 @@ namespace Serein.NodeFlow.Env
         /// </summary>
         /// <param name="nodeGuid"></param>
         /// <returns></returns>
-        public async Task<bool> RemoveNodeAsync(string nodeGuid)
+        public async Task<bool> RemoveNodeAsync(string canvasGuid, string nodeGuid)
         {
             var result = await msgClient.SendAndWaitDataAsync<bool>(EnvMsgTheme.RemoveNode, new
             {
@@ -879,7 +954,7 @@ namespace Serein.NodeFlow.Env
             {
                 UIContextOperation.Invoke(() =>
                 {
-                    OnNodeRemove?.Invoke(new NodeRemoveEventArgs(nodeGuid));
+                    OnNodeRemove?.Invoke(new NodeRemoveEventArgs(canvasGuid, nodeGuid));
                 });
             }
             else
@@ -1077,6 +1152,7 @@ namespace Serein.NodeFlow.Env
             #region 从NodeInfo创建NodeModel
             foreach (NodeInfo? nodeInfo in nodeInfos)
             {
+                var canvasGuid = nodeInfo.CanvasGuid;
                 if (!EnumHelper.TryConvertEnum<NodeControlType>(nodeInfo.Type, out var controlType))
                 {
                     continue;
@@ -1108,7 +1184,7 @@ namespace Serein.NodeFlow.Env
                 TryAddNode(nodeModel); // 加载项目时将节点加载到环境中
                 
                 UIContextOperation?.Invoke(() =>
-                    OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeModel, nodeInfo.Position))); // 添加到UI上
+                    OnNodeCreate?.Invoke(new NodeCreateEventArgs(canvasGuid, nodeModel, nodeInfo.Position))); // 添加到UI上
             }
             #endregion
 
@@ -1127,10 +1203,11 @@ namespace Serein.NodeFlow.Env
                 if (NodeModels.TryGetValue(nodeInfo.Guid, out var childNode) &&
                     NodeModels.TryGetValue(nodeInfo.ParentNodeGuid, out var parentNode))
                 {
+                    var canvasGuid = nodeInfo.CanvasGuid;
                     childNode.ContainerNode = parentNode;
                     parentNode.ChildrenNode.Add(childNode);
                     UIContextOperation?.Invoke(() => 
-                        OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeInfo.Guid, nodeInfo.ParentNodeGuid)) // 通知UI更改节点放置位置
+                        OnNodePlace?.Invoke(new NodePlaceEventArgs(canvasGuid,nodeInfo.Guid, nodeInfo.ParentNodeGuid)) // 通知UI更改节点放置位置
                     );
 
                 }
@@ -1148,6 +1225,7 @@ namespace Serein.NodeFlow.Env
                         // 不存在对应的起始节点
                         continue;
                     }
+                    var canvasGuid = nodeInfo.CanvasGuid;
                     List<(ConnectionInvokeType connectionType, string[] guids)> allToNodes = [(ConnectionInvokeType.IsSucceed,nodeInfo.TrueNodes),
                                                                                     (ConnectionInvokeType.IsFail,   nodeInfo.FalseNodes),
                                                                                     (ConnectionInvokeType.IsError,  nodeInfo.ErrorNodes),
@@ -1164,7 +1242,8 @@ namespace Serein.NodeFlow.Env
                         // 遍历当前类型分支的节点（确认连接关系）
                         foreach (var toNode in item.toNodes)
                         {
-                            UIContextOperation?.Invoke(() => OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(fromNode.Guid,
+                            UIContextOperation?.Invoke(() => OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(canvasGuid,
+                                                                                fromNode.Guid,
                                                                                 toNode.Guid,
                                                                                 JunctionOfConnectionType.Invoke,
                                                                                 item.connectionType,
@@ -1187,10 +1266,11 @@ namespace Serein.NodeFlow.Env
                         if (!string.IsNullOrEmpty(pd.ArgDataSourceNodeGuid)
                             && NodeModels.TryGetValue(pd.ArgDataSourceNodeGuid, out var fromNode))
                         {
-
+                            var canvasGuid = toNode.CanvasGuid;
                             UIContextOperation?.Invoke(() =>
                                          OnNodeConnectChange?.Invoke(
                                          new NodeConnectChangeEventArgs(
+                                             canvasGuid,
                                              fromNode.Guid, // 从哪个节点开始
                                              toNode.Guid, // 连接到那个节点
                                              JunctionOfConnectionType.Arg,

NodeFlow/Model/SingleGlobalDataNode.cs

@@ -96,7 +96,7 @@ namespace Serein.NodeFlow.Model
         {
             foreach (var nodeModel in ChildrenNode) 
             {
-                await nodeModel.Env.TakeOutNodeToContainerAsync(nodeModel.Guid);
+                await nodeModel.Env.TakeOutNodeToContainerAsync(nodeModel.CanvasGuid, nodeModel.Guid);
             }
             DataNode = null;
         }
@@ -174,8 +174,11 @@ namespace Serein.NodeFlow.Model
         /// </summary>
         public override void Remove()
         {
+            if (DataNode is null) {
+                return;
+            }
             // 移除数据节点
-            _ = this.Env.RemoveNodeAsync(DataNode?.Guid);
+            _ = this.Env.RemoveNodeAsync(DataNode.CanvasGuid, DataNode.Guid);
         }
 
     }