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

Library/Api/IFlowEnvironment.cs

@@ -28,7 +28,6 @@ namespace Serein.Library.Api
     public delegate void ProjectSavingHandler(ProjectSavingEventArgs eventArgs);
 
 
-
     /// <summary>
     /// 加载项目文件时成功加载了DLL文件
     /// </summary>
@@ -46,12 +45,34 @@ namespace Serein.Library.Api
     /// <param name="eventArgs"></param>
     public delegate void NodeConnectChangeHandler(NodeConnectChangeEventArgs eventArgs);
 
+    
+
+
+    /// <summary>
+    /// 环境中新增了一个画布
+    /// </summary>
+    /// <param name="eventArgs"></param>
+    public delegate void CanvasCreateHandler(CanvasCreateEventArgs eventArgs);
+
+    /// <summary>
+    /// 环境中移除了一个画布
+    /// </summary>
+    /// <param name="eventArgs"></param>
+    public delegate void CanvasRemoveHandler(CanvasRemoveEventArgs eventArgs);
+
     /// <summary>
     /// 环境中加载了一个节点
     /// </summary>
     /// <param name="eventArgs"></param>
     public delegate void NodeCreateHandler(NodeCreateEventArgs eventArgs);
 
+    /// <summary>
+    /// 环境中移除了一个节点
+    /// </summary>
+    /// <param name="eventArgs"></param>
+
+    public delegate void NodeRemoveHandler(NodeRemoveEventArgs eventArgs);
+
     /// <summary>
     /// 节点放置事件
     /// </summary>
@@ -132,23 +153,9 @@ namespace Serein.Library.Api
         public string ErrorTips { get; protected set; } = string.Empty;
     }
 
-    //public class LoadNodeEventArgs : FlowEventArgs
+    /// <summary>
-    //{
+    /// 项目加载完成
-    //    public LoadNodeEventArgs(NodeInfo NodeInfo, MethodDetails MethodDetailss)
+    /// </summary>
-    //    {
-    //        this.NodeInfo = NodeInfo;
-    //        this.MethodDetailss = MethodDetailss;
-    //    }
-    //    /// <summary>
-    //    /// 项目文件节点信息参数
-    //    /// </summary>
-    //    public NodeInfo NodeInfo { get; protected set; }
-    //    /// <summary>
-    //    /// 已加载在环境中的方法描述
-    //    /// </summary>
-    //    public MethodDetails MethodDetailss { get; protected set; }
-    //}
-
     public class ProjectLoadedEventArgs : FlowEventArgs
     {
         public ProjectLoadedEventArgs()
@@ -156,6 +163,9 @@ namespace Serein.Library.Api
         }
     }
     
+    /// <summary>
+    /// 项目保存
+    /// </summary>
     public class ProjectSavingEventArgs : FlowEventArgs
     {
         public ProjectSavingEventArgs()
@@ -163,6 +173,9 @@ namespace Serein.Library.Api
         }
     }
 
+    /// <summary>
+    /// 加载了DLL外部依赖
+    /// </summary>
     public class LoadDllEventArgs : FlowEventArgs
     {
         public LoadDllEventArgs(NodeLibraryInfo nodeLibraryInfo, List<MethodDetailsInfo> MethodDetailss)
@@ -180,6 +193,9 @@ namespace Serein.Library.Api
         public List<MethodDetailsInfo> MethodDetailss { get; protected set; }
     }
 
+    /// <summary>
+    /// 移除了DLL外部依赖
+    /// </summary>
     public class RemoteDllEventArgs : FlowEventArgs
     {
         public RemoteDllEventArgs()
@@ -187,6 +203,9 @@ namespace Serein.Library.Api
         }
     }
 
+    /// <summary>
+    /// 改变节点连接关系
+    /// </summary>
 
     public class NodeConnectChangeEventArgs : FlowEventArgs
     {
@@ -213,12 +232,14 @@ namespace Serein.Library.Api
         /// <param name="junctionOfConnectionType"></param>
         /// <param name="connectionInvokeType"></param>
         /// <param name="changeType"></param>
-        public NodeConnectChangeEventArgs(string fromNodeGuid,
+        public NodeConnectChangeEventArgs(string canvasGuid,
+                                          string fromNodeGuid,
                                           string toNodeGuid,
                                           JunctionOfConnectionType junctionOfConnectionType, // 指示需要创建什么类型的连接线
                                           ConnectionInvokeType connectionInvokeType, // 节点调用的方法类型（true/false/error/cancel )
                                           ConnectChangeType changeType) // 需要创建连接线还是删除连接线
         {
+            this.CanvasGuid = canvasGuid;
             this.FromNodeGuid = fromNodeGuid;
             this.ToNodeGuid = toNodeGuid;
             this.ConnectionInvokeType = connectionInvokeType;
@@ -235,13 +256,15 @@ namespace Serein.Library.Api
         /// <param name="argIndex"></param>
         /// <param name="connectionArgSourceType"></param>
         /// <param name="changeType"></param>
-        public NodeConnectChangeEventArgs(string fromNodeGuid,
+        public NodeConnectChangeEventArgs(string canvasGuid,
+                                          string fromNodeGuid,
                                           string toNodeGuid,
                                           JunctionOfConnectionType junctionOfConnectionType, // 指示需要创建什么类型的连接线
                                           int argIndex,
                                           ConnectionArgSourceType connectionArgSourceType, // 节点对应的方法入参所需参数来源
                                           ConnectChangeType changeType) // 需要创建连接线还是删除连接线
         {
+            CanvasGuid = canvasGuid;
             this.FromNodeGuid = fromNodeGuid;
             this.ToNodeGuid = toNodeGuid;
             this.ChangeType = changeType;
@@ -250,6 +273,9 @@ namespace Serein.Library.Api
             this.JunctionOfConnectionType = junctionOfConnectionType;
 
         }
+
+        public string CanvasGuid { get; }
+
         /// <summary>
         /// 连接关系中始节点的Guid
         /// </summary>
@@ -282,7 +308,36 @@ namespace Serein.Library.Api
         
     }
 
+    /// <summary>
+    /// 添加了一个画布
+    /// </summary>
+    public class CanvasCreateEventArgs : FlowEventArgs
+    {
+        public CanvasCreateEventArgs(
+            FlowCanvasInfo info)
+        {
+            Info = info;
+        }
 
+        public FlowCanvasInfo Info { get; }
+    }
+
+    /// <summary>
+    /// 移除了一个画布
+    /// </summary>
+    public class CanvasRemoveEventArgs : FlowEventArgs
+    {
+        public CanvasRemoveEventArgs(string canvasGuid)
+        {
+            CanvasGuid = canvasGuid;
+        }
+
+        public string CanvasGuid { get; }
+    }
+
+    /// <summary>
+    /// 添加了节点
+    /// </summary>
     public class NodeCreateEventArgs : FlowEventArgs
     {
         /// <summary>
@@ -290,31 +345,56 @@ namespace Serein.Library.Api
         /// </summary>
         /// <param name="nodeModel">节点对象</param>
         /// <param name="position">位置</param>
-        public NodeCreateEventArgs(NodeModelBase nodeModel, PositionOfUI position)
+        public NodeCreateEventArgs(string canvasGuid, NodeModelBase nodeModel, PositionOfUI position)
         {
+            CanvasGuid = canvasGuid;
             this.NodeModel = nodeModel;
             this.Position = position;
         }
 
+        public string CanvasGuid { get; }
+
         /// <summary>
         /// 节点Model对象
         /// </summary>
         public NodeModelBase NodeModel { get; private set; }
         public PositionOfUI Position { get; private set; }
-        //public bool IsAddInRegion { get; private set; }
         public string RegeionGuid { get; private set; }
     }
 
+    /// <summary>
+    /// 移除了节点的事件
+    /// </summary>
+    public class NodeRemoveEventArgs : FlowEventArgs
+    {
+        public NodeRemoveEventArgs(string canvasGuid, string nodeGuid)
+        {
+            CanvasGuid = canvasGuid;
+            this.NodeGuid = nodeGuid;
+        }
+
+        public string CanvasGuid { get; }
+
+        /// <summary>
+        /// 被移除节点的Guid
+        /// </summary>
+        public string NodeGuid { get; private set; }
+    }
+
     /// <summary>
     /// 节点放置事件参数
     /// </summary>
     public class NodePlaceEventArgs : FlowEventArgs 
     {
-        public NodePlaceEventArgs(string nodeGuid, string containerNodeGuid)
+        public NodePlaceEventArgs(string canvasGuid, string nodeGuid, string containerNodeGuid)
         {
+            CanvasGuid = canvasGuid;
             NodeGuid = nodeGuid;
             ContainerNodeGuid = containerNodeGuid;
         }
+
+        public string CanvasGuid { get; }
+
         /// <summary>
         /// 子节点，该数据为此次时间的主节点
         /// </summary>
@@ -330,10 +410,14 @@ namespace Serein.Library.Api
     /// </summary>
     public class NodeTakeOutEventArgs : FlowEventArgs
     {
-        public NodeTakeOutEventArgs(string nodeGuid)
+        public NodeTakeOutEventArgs(string canvasGuid, string nodeGuid)
         {
+            CanvasGuid = canvasGuid;
             NodeGuid = nodeGuid;
         }
+
+        public string CanvasGuid { get; }
+
         /// <summary>
         /// 需要取出的节点Guid
         /// </summary>
@@ -341,34 +425,21 @@ namespace Serein.Library.Api
     }
 
 
-    /// <summary>
-    /// 环境中移除了一个节点
-    /// </summary>
-    /// <param name="eventArgs"></param>
-
-    public delegate void NodeRemoveHandler(NodeRemoveEventArgs eventArgs);
-    public class NodeRemoveEventArgs : FlowEventArgs
-    {
-        public NodeRemoveEventArgs(string nodeGuid)
-        {
-            this.NodeGuid = nodeGuid;
-        }
-        /// <summary>
-        /// 被移除节点的Guid
-        /// </summary>
-        public string NodeGuid { get; private set; }
-    }
 
 
 
 
     public class StartNodeChangeEventArgs : FlowEventArgs
     {
-        public StartNodeChangeEventArgs(string oldNodeGuid, string newNodeGuid)
+        public StartNodeChangeEventArgs(string canvasGuid, string oldNodeGuid, string newNodeGuid)
         {
+            CanvasGuid = canvasGuid;
             this.OldNodeGuid = oldNodeGuid;
             this.NewNodeGuid = newNodeGuid; ;
         }
+
+        public string CanvasGuid { get; }
+
         /// <summary>
         /// 原来的起始节点Guid
         /// </summary>
@@ -577,6 +648,16 @@ namespace Serein.Library.Api
         /// </summary>
         event NodeConnectChangeHandler OnNodeConnectChange;
 
+        /// <summary>
+        /// 增加画布事件
+        /// </summary>
+        event CanvasCreateHandler OnCanvasCreate;
+
+        /// <summary>
+        /// 删除画布事件
+        /// </summary>
+        event CanvasRemoveHandler OnCanvasRemove;
+
         /// <summary>
         /// 节点创建事件
         /// </summary>
@@ -793,20 +874,37 @@ namespace Serein.Library.Api
 
         #region 流程节点操作接口
 
+        /// <summary>
+        /// 增加画布
+        /// </summary>
+        /// <param name="canvasName">画布名称</param>
+        /// <param name="width">宽度</param>
+        /// <param name="height">高度</param>
+        /// <returns></returns>
+        Task<FlowCanvasInfo> CreateCanvasAsync(string canvasName, int width , int height);
+
+        /// <summary>
+        /// 删除画布
+        /// </summary>
+        /// <param name="canvasGuid">画布Guid</param>
+        /// <returns></returns>
+        Task<bool> RemoteCanvasAsync(string canvasGuid);
+
+
         /// <summary>
         /// 移动了某个节点(远程插件使用）
         /// </summary>
         /// <param name="nodeGuid"></param>
         /// <param name="x"></param>
         /// <param name="y"></param>
-        void MoveNode(string nodeGuid,double x, double y);
+        void MoveNode(string canvasGuid, string nodeGuid, double x, double y);
 
         /// <summary>
         /// 设置流程起点节点
         /// </summary>
         /// <param name="nodeGuid">尝试设置为起始节点的节点Guid</param>
         /// <returns>被设置为起始节点的Guid</returns>
-        Task<string> SetStartNodeAsync(string nodeGuid);
+        Task<string> SetStartNodeAsync(string canvasGuid, string nodeGuid);
 
         /// <summary>
         /// 在两个节点之间创建连接关系
@@ -816,11 +914,12 @@ namespace Serein.Library.Api
         /// <param name="fromNodeJunctionType">起始节点控制点</param>
         /// <param name="toNodeJunctionType">目标节点控制点</param>
         /// <param name="invokeType">决定了方法执行后的后继行为</param>
-        Task<bool> ConnectInvokeNodeAsync(string fromNodeGuid,
+        Task<bool> ConnectInvokeNodeAsync(string canvasGuid, 
-                                    string toNodeGuid,
+                                          string fromNodeGuid,
-                                    JunctionType fromNodeJunctionType,
+                                          string toNodeGuid,
-                                    JunctionType toNodeJunctionType,
+                                          JunctionType fromNodeJunctionType,
-                                    ConnectionInvokeType invokeType);
+                                          JunctionType toNodeJunctionType,
+                                          ConnectionInvokeType invokeType);
 
         /// <summary>
         /// 在两个节点之间创建连接关系
@@ -831,12 +930,13 @@ namespace Serein.Library.Api
         /// <param name="toNodeJunctionType">目标节点控制点</param>
         /// <param name="argSourceType">决定了方法参数来源</param>
         /// <param name="argIndex">设置第几个参数</param>
-        Task<bool> ConnectArgSourceNodeAsync(string fromNodeGuid,
+        Task<bool> ConnectArgSourceNodeAsync(string canvasGuid, 
-                                                 string toNodeGuid,
+                                             string fromNodeGuid,
-                                                 JunctionType fromNodeJunctionType,
+                                             string toNodeGuid,
-                                                 JunctionType toNodeJunctionType,
+                                             JunctionType fromNodeJunctionType,
-                                                 ConnectionArgSourceType argSourceType,
+                                             JunctionType toNodeJunctionType,
-                                                 int argIndex);
+                                             ConnectionArgSourceType argSourceType,
+                                             int argIndex);
 
         
 
@@ -846,19 +946,19 @@ namespace Serein.Library.Api
         /// <param name="nodeType">控件类型</param>
         /// <param name="position">节点在画布上的位置（</param>
         /// <param name="methodDetailsInfo">节点绑定的方法说明</param>
-        Task<NodeInfo> CreateNodeAsync(NodeControlType nodeType, PositionOfUI position, MethodDetailsInfo methodDetailsInfo = null);
+        Task<NodeInfo> CreateNodeAsync(string canvasGuid, NodeControlType nodeType, PositionOfUI position, MethodDetailsInfo methodDetailsInfo = null);
 
         /// <summary>
         /// 将节点放置在容器中
         /// </summary>
         /// <returns></returns>
-        Task<bool> PlaceNodeToContainerAsync(string nodeGuid, string containerNodeGuid);
+        Task<bool> PlaceNodeToContainerAsync(string canvasGuid, string nodeGuid, string containerNodeGuid);
 
         /// <summary>
         /// 将节点从容器中脱离
         /// </summary>
         /// <returns></returns>
-        Task<bool> TakeOutNodeToContainerAsync(string nodeGuid);
+        Task<bool> TakeOutNodeToContainerAsync(string canvasGuid, string nodeGuid);
 
 
         /// <summary>
@@ -876,7 +976,7 @@ namespace Serein.Library.Api
         /// <param name="fromNodeGuid">起始节点</param>
         /// <param name="toNodeGuid">目标节点</param>
         /// <param name="connectionType">连接类型</param>
-        Task<bool> RemoveConnectInvokeAsync(string fromNodeGuid, string toNodeGuid, ConnectionInvokeType connectionType);
+        Task<bool> RemoveConnectInvokeAsync(string canvasGuid, string fromNodeGuid, string toNodeGuid, ConnectionInvokeType connectionType);
 
         /// <summary>
         /// 移除连接节点之间参数传递的关系
@@ -885,13 +985,13 @@ namespace Serein.Library.Api
         /// <param name="toNodeGuid">目标节点Guid</param>
         /// <param name="argIndex">连接到第几个参数</param>
         /// <param name="connectionArgSourceType">参数来源类型</param>
-        Task<bool> RemoveConnectArgSourceAsync(string fromNodeGuid, string toNodeGuid, int argIndex);
+        Task<bool> RemoveConnectArgSourceAsync(string canvasGuid, string fromNodeGuid, string toNodeGuid, int argIndex);
 
         /// <summary>
         /// 移除节点/区域/基础控件
         /// </summary>
         /// <param name="nodeGuid">待移除的节点Guid</param>
-        Task<bool> RemoveNodeAsync(string nodeGuid);
+        Task<bool> RemoveNodeAsync(string canvasGuid, string nodeGuid);
 
         /// <summary>
         /// 改变可选参数的数目

Library/Extension/FlowModelExtension.cs

@@ -7,14 +7,52 @@ using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Xml.Linq;
 
 namespace Serein.Library
 {
     /// <summary>
     /// 节点方法拓展
     /// </summary>
-    public static class NodeModelExtension
+    public static class FlowModelExtension
     {
+        /// <summary>
+        /// 导出为画布信息
+        /// </summary>
+        /// <param name="model"></param>
+        /// <returns></returns>
+        public static FlowCanvasInfo ToInfo(this FlowCanvasModel model)
+        {
+            return new FlowCanvasInfo
+            {
+                Guid = model.Guid,
+                Height = model.Height,
+                Width = model.Width,
+                Name = model.Name,
+                ScaleX = model.ScaleX,
+                ScaleY = model.ScaleY,
+                ViewX = model.ViewX,
+                ViewY = model.ViewY,
+            };
+        }
+
+        /// <summary>
+        /// 从画布信息加载
+        /// </summary>
+        /// <param name="model"></param>
+        /// <param name="info"></param>
+        public static void LoadInfo(this FlowCanvasModel model, FlowCanvasInfo info)
+        {
+            model.Guid = info.Guid;
+            model.Height = info.Height;
+            model.Width = info.Width;
+            model.Name = info.Name;
+            model.ScaleX = info.ScaleX;
+            model.ScaleY = info.ScaleY;
+            model.ViewX = info.ViewX;
+            model.ViewY = info.ViewY;
+        }
+
         /// <summary>
         /// 输出方法参数信息
         /// </summary>

Library/FlowNode/ContainerFlowEnvironment.cs

@@ -1,390 +0,0 @@
-using Serein.Library.Api;
-using Serein.Library.Utils;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Serein.Library
-{
-
-    /// <summary>
-    /// 不提供流程操作能力，仅提供容器功能
-    /// </summary>
-    public class ContainerFlowEnvironment : IFlowEnvironment, ISereinIOC
-    {
-        /// <summary>
-        /// 本地运行环境缓存的持久化实例
-        /// </summary>
-        private Dictionary<string, object> PersistennceInstance { get; } = new Dictionary<string, object>();
-        public ContainerFlowEnvironment()
-        {
-            
-        }
-
-        private ISereinIOC sereinIOC => this;
-        public ISereinIOC IOC => sereinIOC;
-
-        public string EnvName => throw new NotImplementedException();
-        public string ProjectFileLocation => throw new NotImplementedException();
-
-        public bool IsGlobalInterrupt => throw new NotImplementedException();
-
-        public bool IsControlRemoteEnv => throw new NotImplementedException();
-
-        public InfoClass InfoClass { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
-        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 UIContextOperation UIContextOperation { get; set; }
-        public NodeMVVMManagement NodeMVVMManagement { get; set; }
-
-        /// <summary>
-        /// 设置在UI线程操作的线程上下文
-        /// </summary>
-        /// <param name="uiContextOperation"></param>
-        public void SetUIContextOperation(UIContextOperation uiContextOperation)
-        {
-            this.UIContextOperation = uiContextOperation;
-        }
-
-        public void ActivateFlipflopNode(string nodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> ChangeParameter(string nodeGuid, bool isAdd, int paramIndex)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> ConnectArgSourceNodeAsync(string fromNodeGuid, string toNodeGuid, JunctionType fromNodeJunctionType, JunctionType toNodeJunctionType, ConnectionArgSourceType argSourceType, int argIndex)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> ConnectInvokeNodeAsync(string fromNodeGuid, string toNodeGuid, JunctionType fromNodeJunctionType, JunctionType toNodeJunctionType, ConnectionInvokeType invokeType)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<(bool, RemoteMsgUtil)> ConnectRemoteEnv(string addres, int port, string token)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<NodeInfo> CreateNodeAsync(NodeControlType nodeType, PositionOfUI position, MethodDetailsInfo methodDetailsInfo = null)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> ExitFlowAsync()
-        {
-            throw new NotImplementedException();
-        }
-
-        public void ExitRemoteEnv()
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<FlowEnvInfo> GetEnvInfoAsync()
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<SereinProjectData> GetProjectInfoAsync()
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<object> InvokeNodeAsync(IDynamicContext context, string nodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void LoadAllNativeLibraryOfRuning(string path, bool isRecurrence = true)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void LoadLibrary(string dllPath)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool LoadNativeLibraryOfRuning(string file)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task LoadNodeInfosAsync(List<NodeInfo> nodeInfos)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void LoadProject(FlowEnvInfo flowEnvInfo, string filePath)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void MonitorObjectNotification(string nodeGuid, object monitorData, MonitorObjectEventArgs.ObjSourceType sourceType)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void MoveNode(string nodeGuid, double x, double y)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void NodeLocated(string nodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task NotificationNodeValueChangeAsync(string nodeGuid, string path, object value)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> PlaceNodeToContainerAsync(string nodeGuid, string containerNodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> RemoveConnectArgSourceAsync(string fromNodeGuid, string toNodeGuid, int argIndex)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> RemoveConnectInvokeAsync(string fromNodeGuid, string toNodeGuid, ConnectionInvokeType connectionType)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> RemoveNodeAsync(string nodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void SaveProject()
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> SetConnectPriorityInvoke(string fromNodeGuid, string toNodeGuid, ConnectionInvokeType connectionType)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<string> SetStartNodeAsync(string nodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> StartAsyncInSelectNode(string startNodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> StartFlowAsync()
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task StartRemoteServerAsync(int port = 7525)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void StopRemoteServer()
-        {
-            throw new NotImplementedException();
-        }
-
-        public Task<bool> TakeOutNodeToContainerAsync(string nodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void TerminateFlipflopNode(string nodeGuid)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void TriggerInterrupt(string nodeGuid, string expression, InterruptTriggerEventArgs.InterruptTriggerType type)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool TryGetDelegateDetails(string assemblyName, string methodName, out DelegateDetails del)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool TryGetMethodDetailsInfo(string assemblyName, string methodName, out MethodDetailsInfo mdInfo)
-        {
-            throw new NotImplementedException();
-        }
-
-        public bool TryUnloadLibrary(string assemblyFullName)
-        {
-            throw new NotImplementedException();
-        }
-
-        public void WriteLine(InfoType type, string message, InfoClass @class = InfoClass.Trivial)
-        {
-            throw new NotImplementedException();
-        }
-
-
-
-        #region IOC容器相关
-        ISereinIOC ISereinIOC.Reset()
-        {
-            sereinIOC.Reset();
-            lock (PersistennceInstance)
-            {
-                foreach (var kvp in PersistennceInstance)
-                {
-                    IOC.RegisterPersistennceInstance(kvp.Key, kvp.Value);
-                }
-            } // 重置后重新登记
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Register(Type type, params object[] parameters)
-        {
-            sereinIOC.Register(type, parameters);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Register<T>(params object[] parameters)
-        {
-            sereinIOC.Register<T>(parameters);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Register<TService, TImplementation>(params object[] parameters)
-        {
-            sereinIOC.Register<TService, TImplementation>(parameters);
-            return this;
-        }
-
-        //T ISereinIOC.GetOrRegisterInstantiate<T>()
-        //{
-        //    return sereinIOC.GetOrRegisterInstantiate<T>();
-
-        //}
-
-        //object ISereinIOC.GetOrRegisterInstantiate(Type type)
-        //{
-        //    return sereinIOC.GetOrRegisterInstantiate(type);
-        //}
-
-        object ISereinIOC.Get(Type type)
-        {
-            return sereinIOC.Get(type);
-
-        }
-        T ISereinIOC.Get<T>()
-        {
-            return (T)sereinIOC.Get(typeof(T));
-        }
-        //T ISereinIOC.Get<T>(string key)
-        //{
-        //    return sereinIOC.Get<T>(key);
-        //}
-
-
-        bool ISereinIOC.RegisterPersistennceInstance(string key, object instance)
-        {
-            if (PersistennceInstance.ContainsKey(key))
-            {
-                return false;
-            }
-            PersistennceInstance.Add(key, instance); // 记录需要持久化的实例
-            return sereinIOC.RegisterPersistennceInstance(key, instance);
-        }
-
-        //bool ISereinIOC.RegisterInstance(string key, object instance)
-        //{
-        //    return sereinIOC.RegisterInstance(key, instance);
-        //}
-
-
-        object ISereinIOC.Instantiate(Type type)
-        {
-            return sereinIOC.Instantiate(type);
-        }
-        T ISereinIOC.Instantiate<T>()
-        {
-            return sereinIOC.Instantiate<T>();
-        }
-        ISereinIOC ISereinIOC.Build()
-        {
-            sereinIOC.Build();
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Run<T>(Action<T> action)
-        {
-            sereinIOC.Run(action);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Run<T1, T2>(Action<T1, T2> action)
-        {
-            sereinIOC.Run(action);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Run<T1, T2, T3>(Action<T1, T2, T3> action)
-        {
-            sereinIOC.Run(action);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Run<T1, T2, T3, T4>(Action<T1, T2, T3, T4> action)
-        {
-            sereinIOC.Run(action);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Run<T1, T2, T3, T4, T5>(Action<T1, T2, T3, T4, T5> action)
-        {
-            sereinIOC.Run(action);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Run<T1, T2, T3, T4, T5, T6>(Action<T1, T2, T3, T4, T5, T6> action)
-        {
-            sereinIOC.Run(action);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Run<T1, T2, T3, T4, T5, T6, T7>(Action<T1, T2, T3, T4, T5, T6, T7> action)
-        {
-            sereinIOC.Run(action);
-            return this;
-        }
-
-        ISereinIOC ISereinIOC.Run<T1, T2, T3, T4, T5, T6, T7, T8>(Action<T1, T2, T3, T4, T5, T6, T7, T8> action)
-        {
-            sereinIOC.Run(action);
-            return this;
-        }
-
-        public bool TryGetNodeModel(string nodeGuid, out NodeModelBase nodeModel)
-        {
-            throw new NotImplementedException();
-        }
-        #endregion
-
-
-    }
-}

Library/FlowNode/FlowCanvasModel.cs

@@ -0,0 +1,57 @@
+using Serein.Library.Api;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library
+{
+
+    [NodeProperty(ValuePath = NodeValuePath.Node)]
+    public partial class FlowCanvasModel
+    {
+        public FlowCanvasModel(IFlowEnvironment env)
+        {
+            Env = env;
+        }
+        public IFlowEnvironment Env { get; }
+
+        [PropertyInfo(IsProtection = true)]
+        private string _guid;
+
+        [PropertyInfo(IsNotification = true)]
+        private string _name;
+
+        [PropertyInfo(IsNotification = true)]
+        private double _width;
+
+        [PropertyInfo(IsNotification = true)]
+        private double _height;
+
+        /// <summary>
+        /// 预览位置X
+        /// </summary>
+        [PropertyInfo]
+        private double _viewX ;
+
+        /// <summary>
+        /// 预览位置Y
+        /// </summary>
+        [PropertyInfo]
+        private double _viewY ;
+
+        /// <summary>
+        /// 缩放比例X
+        /// </summary>
+        [PropertyInfo]
+        private double _scaleX ;
+
+        /// <summary>
+        /// 缩放比例Y
+        /// </summary>
+        [PropertyInfo]
+        private double _scaleY ;
+
+    }
+}

Library/FlowNode/NodeModelBaseData.cs

@@ -35,6 +35,14 @@ namespace Serein.Library
         [PropertyInfo(IsProtection = true)]
         private NodeControlType _controlType;
 
+
+        /// <summary>
+        /// 所属画布
+        /// </summary>
+        [PropertyInfo(IsProtection = true)] 
+        private string _canvasGuid ;
+        
+
         /// <summary>
         /// 在画布中的位置
         /// </summary>

Library/FlowNode/SereinProjectData.cs

@@ -87,7 +87,7 @@ namespace Serein.Library
         /// 画布
         /// </summary>
 
-        public FlowCanvas Canvas { get; set; }
+        public FlowCanvasInfo Canvas { get; set; }
 
         /// <summary>
         /// 版本
@@ -98,8 +98,12 @@ namespace Serein.Library
     /// <summary>
     /// 画布信息，项目文件相关
     /// </summary>
-    public class FlowCanvas
+    public class FlowCanvasInfo
     {
+        public string Guid { get; set; }
+
+        public string Name { get; set; }
+
         /// <summary>
         /// 宽度
         /// </summary>
@@ -178,6 +182,12 @@ namespace Serein.Library
     /// </summary>
     public class NodeInfo
     {
+        /// <summary>
+        /// 所属画布Guid
+        /// </summary>
+        public string CanvasGuid { get; set; }  
+
+
         /// <summary>
         /// 节点的GUID
         /// </summary>

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,6 +767,45 @@ 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>
         /// 从节点信息集合批量加载节点控件
@@ -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="canvasGuid">所属画布</param>
-        /// <param name="position"></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,7 +1163,8 @@ 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,
@@ -1129,7 +1172,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 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(
+                await UIContextOperation.InvokeAsync(() => OnNodeConnectChange?.Invoke(
-                                                                          fromNode.Guid,
+                    new NodeConnectChangeEventArgs(
-                                                                          toNode.Guid,
+                        canvasGuid,
-                                                                          JunctionOfConnectionType.Invoke,
+                        fromNode.Guid,
-                                                                          connectionType,
+                        toNode.Guid,
-                                                                          NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
+                        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(
+                await UIContextOperation.InvokeAsync(() => OnNodeConnectChange?.Invoke(
-                                                                          fromNode.Guid,
+                    new NodeConnectChangeEventArgs(
-                                                                          toNode.Guid,
+                        canvasGuid,                                             
-                                                                          JunctionOfConnectionType.Arg,
+                        fromNode.Guid,
-                                                                          argIndex,
+                        toNode.Guid,
-                                                                          ConnectionArgSourceType.GetPreviousNodeData,
+                        JunctionOfConnectionType.Arg,
-                                                                          NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
+                        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,11 +461,12 @@ 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>
         /// 远程连接节点的参数传递关系
         /// </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()); // 加载节点
+            var canvasGuid = nodeInfos.FirstOrDefault(item => item.Guid == flowEnvInfo.Project.StartNode)?.CanvasGuid;
-            _ = SetStartNodeAsync(flowEnvInfo.Project.StartNode); // 设置流程起点
+            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, 
+        public async Task<NodeInfo> CreateNodeAsync(string canvasGuid,
-            PositionOfUI position,
+                                                    NodeControlType nodeControlType, 
-            MethodDetailsInfo methodDetailsInfo = null)
+                                                    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);
         }
 
     }

Workbench/App.xaml

@@ -3,9 +3,10 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:local="clr-namespace:Serein.Workbench"
              xmlns:view="clr-namespace:Serein.Workbench.Views"
-             StartupUri="MainWindow.xaml"
+             StartupUri="Views/FlowWorkbenchView.xaml"
              Startup="Application_Startup">
     <!--StartupUri="Views/FlowWorkbenchView.xaml"-->
+    <!--StartupUri="MainWindow.xaml"-->
 
     <Application.Resources>
         <ResourceDictionary>

Workbench/App.xaml.cs

@@ -39,7 +39,7 @@ namespace Serein.Workbench
         {
             collection.AddSingleton<IFlowEEForwardingService, FlowEEForwardingService>(); // 流程事件管理
             collection.AddSingleton<IWorkbenchEventService, WorkbenchEventService>(); // 流程事件管理
-            collection.AddSingleton<INodeOperationService, NodeOperationService>(); // 节点操作管理
+            collection.AddSingleton<NodeControlService>(); // 节点操作管理
             // collection.AddSingleton<IKeyEventService, KeyEventService>(); // 按键事件管理
                                                                           //collection.AddSingleton<FlowNodeControlService>(); // 流程节点控件管理
         }
@@ -90,19 +90,20 @@ namespace Serein.Workbench
 
         public App()
         {
-            _ = Task.Run(async () =>
+            
-            {
-                await Task.Delay(500);
-                await this.LoadLocalProjectAsync();
-            });
-            return;
             var collection = new ServiceCollection();
             collection.AddWorkbenchServices();
             collection.AddFlowServices();
             collection.AddViewModelServices();
             var services = collection.BuildServiceProvider(); // 绑定并返回获取实例的服务接口
             App.ServiceProvider = services;
+            _ = Task.Run(async () =>
+            {
+                await Task.Delay(500);
+                await this.LoadLocalProjectAsync();
+                App.GetService<IFlowEnvironment>().LoadProject(new FlowEnvInfo { Project = App.FlowProjectData }, App.FileDataPath);
 
+            });
         }
 
 
@@ -124,7 +125,6 @@ namespace Serein.Workbench
                 App.FileDataPath = System.IO.Path.GetDirectoryName(filePath)!;   //  filePath;//
                 var dir = Path.GetDirectoryName(filePath);
 
-                //App.GetService<IFlowEnvironment>().LoadProject(new FlowEnvInfo { Project = App.FlowProjectData },App.FileDataPath);
             }
 #endif
         }

Workbench/MainWindow.xaml.cs

@@ -356,7 +356,7 @@ namespace Serein.Workbench
 
             projectData.Basic = new Basic
             {
-                Canvas = new FlowCanvas
+                Canvas = new FlowCanvasInfo
                 {
                     Height = FlowChartCanvas.Height,
                     Width = FlowChartCanvas.Width,
@@ -763,9 +763,11 @@ namespace Serein.Workbench
             NodeControls.TryAdd(nodeModel.Guid, nodeControl); // 添加到
             if (TryPlaceNodeInRegion(nodeControl, position, out var regionControl)) // 判断添加到区域容器
             {
+                var canvasGuid = nodeControl.ViewModel.NodeModel.CanvasGuid;
                 // 通知运行环境调用加载节点子项的方法
-                _ = EnvDecorator.PlaceNodeToContainerAsync(nodeControl.ViewModel.NodeModel.Guid, // 待移动的节点
+                _ = EnvDecorator.PlaceNodeToContainerAsync(canvasGuid,
-                                                       regionControl.ViewModel.NodeModel.Guid); // 目标的容器节点
+                                                        nodeControl.ViewModel.NodeModel.Guid, // 待移动的节点
+                                                        regionControl.ViewModel.NodeModel.Guid); // 目标的容器节点
             }
             else
             {
@@ -1148,7 +1150,7 @@ namespace Serein.Workbench
         /// </param>
         private void ConfigureContextMenu(NodeControlBase nodeControl)
         {
-            
+            var canvasGuid = nodeControl.ViewModel.NodeModel.CanvasGuid;
             var contextMenu = new ContextMenu();
             var nodeGuid = nodeControl.ViewModel?.NodeModel?.Guid;
             #region 触发器节点
@@ -1187,10 +1189,10 @@ namespace Serein.Workbench
 
             
            
-            contextMenu.Items.Add(CreateMenuItem("设为起点", (s, e) => EnvDecorator.SetStartNodeAsync(nodeGuid)));
+            contextMenu.Items.Add(CreateMenuItem("设为起点", (s, e) => EnvDecorator.SetStartNodeAsync(canvasGuid, nodeGuid)));
             contextMenu.Items.Add(CreateMenuItem("删除", async (s, e) =>
             {
-                var result = await EnvDecorator.RemoveNodeAsync(nodeGuid);
+                var result = await EnvDecorator.RemoveNodeAsync(canvasGuid, nodeGuid);
             }));
 
             #region 右键菜单功能 - 控件对齐
@@ -1407,7 +1409,8 @@ namespace Serein.Workbench
                     {
                         Task.Run(async () =>
                         {
-                            await EnvDecorator.CreateNodeAsync(nodeData.NodeControlType, position, nodeData.MethodDetailsInfo); // 创建DLL文件的节点对象
+                            
+                            await EnvDecorator.CreateNodeAsync("MainCanvas", nodeData.NodeControlType, position, nodeData.MethodDetailsInfo); // 创建DLL文件的节点对象
                         });
                     }
                 }
@@ -1429,7 +1432,7 @@ namespace Serein.Workbench
                         {
                             Task.Run(async () =>
                             {
-                                await EnvDecorator.CreateNodeAsync(nodeControlType, position); // 创建基础节点对象
+                                await EnvDecorator.CreateNodeAsync("MainCanvas", nodeControlType, position); // 创建基础节点对象
                             });
                         }
                     }
@@ -1580,7 +1583,7 @@ namespace Serein.Workbench
                     var newLeft = oldLeft + deltaX;
                     var newTop = oldTop + deltaY;
 
-                    this.EnvDecorator.MoveNode(nodeControlMain.ViewModel.NodeModel.Guid, newLeft, newTop); // 移动节点
+                    this.EnvDecorator.MoveNode("MainCanvas", nodeControlMain.ViewModel.NodeModel.Guid, newLeft, newTop); // 移动节点
 
                     // 计算控件实际移动的距离
                     var actualDeltaX = newLeft - oldLeft;
@@ -1593,7 +1596,7 @@ namespace Serein.Workbench
                         {
                             var otherNewLeft = Canvas.GetLeft(nodeControl) + actualDeltaX;
                             var otherNewTop = Canvas.GetTop(nodeControl) + actualDeltaY;
-                            this.EnvDecorator.MoveNode(nodeControl.ViewModel.NodeModel.Guid, otherNewLeft, otherNewTop); // 移动节点
+                            this.EnvDecorator.MoveNode("MainCanvas", nodeControl.ViewModel.NodeModel.Guid, otherNewLeft, otherNewTop); // 移动节点
                         }
                     }
 
@@ -1613,7 +1616,7 @@ namespace Serein.Workbench
                     double deltaY = currentPosition.Y - startControlDragPoint.Y; // 计算Y轴方向的偏移量
                     double newLeft = Canvas.GetLeft(nodeControl) + deltaX; // 新的左边距
                     double newTop = Canvas.GetTop(nodeControl) + deltaY; // 新的上边距
-                    this.EnvDecorator.MoveNode(nodeControl.ViewModel.NodeModel.Guid, newLeft, newTop); // 移动节点
+                    this.EnvDecorator.MoveNode("MainCanvas", nodeControl.ViewModel.NodeModel.Guid, newLeft, newTop); // 移动节点
                     nodeControl.UpdateLocationConnections();
                 }
                 startControlDragPoint = currentPosition; // 更新起始点位置
@@ -1975,7 +1978,9 @@ namespace Serein.Workbench
                         #region 方法调用关系创建
                         if (myData.Type == JunctionOfConnectionType.Invoke)
                         {
-                            await EnvDecorator.ConnectInvokeNodeAsync(myData.StartJunction.MyNode.Guid, myData.CurrentJunction.MyNode.Guid,
+                            await EnvDecorator.ConnectInvokeNodeAsync(
+                                "MainCanvas", 
+                                    myData.StartJunction.MyNode.Guid, myData.CurrentJunction.MyNode.Guid,
                                         myData.StartJunction.JunctionType,
                                         myData.CurrentJunction.JunctionType,
                                         myData.ConnectionInvokeType);
@@ -1995,7 +2000,9 @@ namespace Serein.Workbench
                                 argIndex = argJunction2.ArgIndex;
                             }
 
-                            await EnvDecorator.ConnectArgSourceNodeAsync(myData.StartJunction.MyNode.Guid, myData.CurrentJunction.MyNode.Guid,
+                            await EnvDecorator.ConnectArgSourceNodeAsync(
+                                "MainCanvas", 
+                                myData.StartJunction.MyNode.Guid, myData.CurrentJunction.MyNode.Guid,
                                     myData.StartJunction.JunctionType,
                                     myData.CurrentJunction.JunctionType,
                                     myData.ConnectionArgSourceType,
@@ -2060,7 +2067,7 @@ namespace Serein.Workbench
                         var guid = node?.ViewModel?.NodeModel?.Guid;
                         if (!string.IsNullOrEmpty(guid))
                         {
-                            EnvDecorator.RemoveNodeAsync(guid);
+                            EnvDecorator.RemoveNodeAsync("MainCanvas", guid);
                         }
                     }
                 }

Workbench/Models/TabModel.cs

@@ -0,0 +1,50 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using Newtonsoft.Json.Linq;
+using Serein.Workbench.ViewModels;
+using Serein.Workbench.Views;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Linq;
+
+namespace Serein.Workbench.Models
+{
+    public partial class FlowCanvasModel : ObservableObject
+    {
+        public string Name
+        {
+            get
+            {
+
+                var vm = (FlowCanvasViewModel)content.DataContext;
+                return vm.Name;
+            }
+            set
+            {
+                var vm = (FlowCanvasViewModel)content.DataContext;
+                vm.Name = value;
+                OnPropertyChanged(nameof(Name));
+            }
+        }
+
+        [ObservableProperty]
+        private bool _isSelected;
+        [ObservableProperty]
+        private bool _isEditing;
+        [ObservableProperty]
+        private FlowCanvasView content;
+
+
+        public FlowCanvasModel()
+        {
+            
+        }
+
+    }
+
+
+}

Workbench/Node/View/ConnectionControl.cs

@@ -237,13 +237,14 @@ namespace Serein.Workbench.Node.View
         {
             Canvas.Children.Remove(BezierLine);
             var env = Start.MyNode.Env;
+            var canvasGuid = Start.MyNode.CanvasGuid;
             if (Start.JunctionType.ToConnectyionType() == JunctionOfConnectionType.Invoke)
             {
-                env.RemoveConnectInvokeAsync(Start.MyNode.Guid, End.MyNode.Guid, InvokeType);
+                env.RemoveConnectInvokeAsync(canvasGuid, Start.MyNode.Guid, End.MyNode.Guid, InvokeType);
             }
             else if (Start.JunctionType.ToConnectyionType() == JunctionOfConnectionType.Arg)
             {
-                env.RemoveConnectArgSourceAsync(Start.MyNode.Guid, End.MyNode.Guid, ArgIndex) ;
+                env.RemoveConnectArgSourceAsync(canvasGuid,Start.MyNode.Guid, End.MyNode.Guid, ArgIndex) ;
             }
         }
 

Workbench/Services/FlowEEForwardingService.cs

@@ -109,6 +109,14 @@ namespace Serein.Workbench.Services
         /// 运行环境输出事件
         /// </summary>
         public event EnvOutHandler? OnEnvOut;
+        /// <summary>
+        /// 添加画布事件
+        /// </summary>
+        public event CanvasCreateHandler OnCanvasCreate;
+        /// <summary>
+        /// 移除了画布事件
+        /// </summary>
+        public event CanvasRemoveHandler OnCanvasRemove;
 
         #endregion
 
@@ -119,6 +127,8 @@ namespace Serein.Workbench.Services
             flowEnvironmentEvent.OnDllLoad += FlowEnvironment_DllLoadEvent;
             flowEnvironmentEvent.OnProjectSaving += EnvDecorator_OnProjectSaving;
             flowEnvironmentEvent.OnProjectLoaded += FlowEnvironment_OnProjectLoaded;
+            flowEnvironmentEvent.OnCanvasCreate += FlowEnvironmentEvent_OnCanvasCreate;
+            flowEnvironmentEvent.OnCanvasRemove += FlowEnvironmentEvent_OnCanvasRemove;
             flowEnvironmentEvent.OnStartNodeChange += FlowEnvironment_StartNodeChangeEvent;
             flowEnvironmentEvent.OnNodeConnectChange += FlowEnvironment_NodeConnectChangeEvemt;
             flowEnvironmentEvent.OnNodeCreate += FlowEnvironment_NodeCreateEvent;
@@ -139,6 +149,7 @@ namespace Serein.Workbench.Services
             flowEnvironmentEvent.OnEnvOut += FlowEnvironment_OnEnvOutEvent;
         }
 
+      
         private void ResetFlowEnvironmentEvent()
         {
            flowEnvironmentEvent.OnDllLoad -= FlowEnvironment_DllLoadEvent;
@@ -224,6 +235,28 @@ namespace Serein.Workbench.Services
             OnNodeConnectChange?.Invoke(eventArgs);
         }
 
+
+        /// <summary>
+        /// 添加了画布
+        /// </summary>
+        /// <param name="eventArgs"></param>
+        /// <exception cref="NotImplementedException"></exception>
+        private void FlowEnvironmentEvent_OnCanvasCreate(CanvasCreateEventArgs eventArgs)
+        {
+            OnCanvasCreate?.Invoke(eventArgs);
+        }
+
+        /// <summary>
+        /// 移除了画布
+        /// </summary>
+        /// <param name="eventArgs"></param>
+        /// <exception cref="NotImplementedException"></exception>
+        private void FlowEnvironmentEvent_OnCanvasRemove(CanvasRemoveEventArgs eventArgs)
+        {
+            OnCanvasRemove?.Invoke(eventArgs);
+
+        }
+
         /// <summary>
         /// 节点移除事件
         /// </summary>

Workbench/Services/NodeControlService.cs

@@ -0,0 +1,63 @@
+
+using Newtonsoft.Json;
+using Serein.Library;
+using Serein.Library.Api;
+using Serein.Library.Utils;
+using Serein.NodeFlow;
+using Serein.NodeFlow.Env;
+using Serein.Workbench.Api;
+using Serein.Workbench.Avalonia.Api;
+using Serein.Workbench.Node;
+using Serein.Workbench.Node.View;
+using Serein.Workbench.Node.ViewModel;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+
+
+
+
+
+namespace Serein.Workbench.Api
+{
+
+}
+
+namespace Serein.Workbench.Services
+{
+    /// <summary>
+    /// 节点操作相关服务
+    /// </summary>
+    internal class NodeControlService 
+    {
+
+        public NodeControlService(IFlowEnvironment flowEnvironment,
+                                    IFlowEEForwardingService feefService)
+        {
+          /*  this.flowEnvironment = flowEnvironment;
+            this.feefService = feefService;
+            feefService.OnNodeCreate += FeefService_OnNodeCreate; // 订阅运行环境创建节点事件
+            feefService.OnNodeConnectChange += FeefService_OnNodeConnectChange; // 订阅运行环境连接了节点事件
+            // 手动加载项目
+            _ = Task.Run(async delegate
+            {
+                await Task.Delay(1000);
+                var flowEnvironment = new FlowEnvironment();// App.GetService<IFlowEnvironment>();
+                var filePath = @"C:\Users\Az\source\repos\CLBanyunqiState\CLBanyunqiState\bin\debug\net8.0\project.dnf";
+                string content = System.IO.File.ReadAllText(filePath); // 读取整个文件内容
+                var projectData = JsonConvert.DeserializeObject<SereinProjectData>(content);
+                var projectDfilePath = System.IO.Path.GetDirectoryName(filePath)!;
+                flowEnvironment.LoadProject(new FlowEnvInfo { Project = projectData }, projectDfilePath);
+            }, CancellationToken.None);*/
+        }
+
+
+
+
+
+    }
+
+}

Workbench/Services/NodeOperationService.cs

@@ -1,406 +0,0 @@
-
-using Newtonsoft.Json;
-using Serein.Library;
-using Serein.Library.Api;
-using Serein.Library.Utils;
-using Serein.NodeFlow;
-using Serein.NodeFlow.Env;
-using Serein.Workbench.Api;
-using Serein.Workbench.Avalonia.Api;
-using Serein.Workbench.Node;
-using Serein.Workbench.Node.View;
-using Serein.Workbench.Node.ViewModel;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Threading;
-using System.Threading.Tasks;
-using System.Windows.Controls;
-
-
-
-
-
-namespace Serein.Workbench.Api
-{
-
-    /// <summary>
-    /// 提供节点操作的接口
-    /// </summary>
-    internal interface INodeOperationService
-    {
-        /// <summary>
-        /// 连接数据
-        /// </summary>
-        // ConnectingManage ConnectingManage { get; }
-
-        /// <summary>
-        /// 主画布
-        /// </summary>
-        Canvas MainCanvas { get; set; }
-
-        /// <summary>
-        /// 节点创建事件
-        /// </summary>
-
-        event NodeViewCreateHandle OnNodeViewCreate;
-
-        /// <summary>
-        /// 创建节点控件
-        /// </summary>
-        /// <param name="nodeType">控件类型</param>
-        /// <param name="position">创建坐标</param>
-        /// <param name="methodDetailsInfo">节点方法信息</param>
-        public void CreateNodeView(MethodDetailsInfo methodDetailsInfo, PositionOfUI position);
-
-        /// <summary>
-        /// 尝试从连接控制点创建连接
-        /// </summary>
-        /// <param name="startJunction"></param>
-        //void TryCreateConnectionOnJunction(NodeJunctionView startJunction);
-
-    }
-
-
-
-
-    #region 事件与事件参数
-    /// <summary>
-    /// 创建节点控件事件
-    /// </summary>
-    /// <param name="eventArgs"></param>
-
-    internal delegate bool NodeViewCreateHandle(NodeViewCreateEventArgs eventArgs);
-
-    /// <summary>
-    /// 创建节点控件事件参数
-    /// </summary>
-
-
-
-    internal class NodeViewCreateEventArgs : EventArgs
-    {
-        internal NodeViewCreateEventArgs(NodeControlBase nodeControl, PositionOfUI position)
-        {
-            this.NodeControl = nodeControl;
-            this.Position = position;
-        }
-        public NodeControlBase NodeControl { get; private set; }
-        public PositionOfUI Position { get; private set; }
-    }
-
-
-    #endregion
-
-
-
-
-
-}
-
-namespace Serein.Workbench.Services
-{
-    /// <summary>
-    /// 节点操作相关服务
-    /// </summary>
-    internal class NodeOperationService : INodeOperationService
-    {
-
-        public NodeOperationService(IFlowEnvironment flowEnvironment,
-                                    IFlowEEForwardingService feefService)
-        {
-            this.flowEnvironment = flowEnvironment;
-            this.feefService = feefService;
-            feefService.OnNodeCreate += FeefService_OnNodeCreate; // 订阅运行环境创建节点事件
-            feefService.OnNodeConnectChange += FeefService_OnNodeConnectChange; // 订阅运行环境连接了节点事件
-            // 手动加载项目
-            _ = Task.Run(async delegate
-            {
-                await Task.Delay(1000);
-                var flowEnvironment = new FlowEnvironment();// App.GetService<IFlowEnvironment>();
-                var filePath = @"C:\Users\Az\source\repos\CLBanyunqiState\CLBanyunqiState\bin\debug\net8.0\project.dnf";
-                string content = System.IO.File.ReadAllText(filePath); // 读取整个文件内容
-                var projectData = JsonConvert.DeserializeObject<SereinProjectData>(content);
-                var projectDfilePath = System.IO.Path.GetDirectoryName(filePath)!;
-                flowEnvironment.LoadProject(new FlowEnvInfo { Project = projectData }, projectDfilePath);
-            }, CancellationToken.None);
-        }
-
-
-        #region 接口属性
-        //public ConnectingManage ConnectingManage { get; private set; } = new ConnectingManage();
-        public Canvas MainCanvas { get; set; }
-
-        #endregion
-
-        #region 私有变量
-
-        /// <summary>
-        /// 存储所有与节点有关的控件
-        /// </summary>
-        private Dictionary<string, NodeControlBase> NodeControls { get; } = [];
-
-        /// <summary>
-        /// 存储所有连接
-        /// </summary>
-        //private List<NodeConnectionLineControl> Connections { get; } = [];
-
-
-
-        /// <summary>
-        /// 流程运行环境
-        /// </summary>
-        private readonly IFlowEnvironment flowEnvironment;
-
-        /// <summary>
-        /// 流程运行环境事件转发
-        /// </summary>
-        private readonly IFlowEEForwardingService feefService;
-        #endregion
-
-        #region 节点操作事件
-
-        /// <summary>
-        /// 创建了节点控件
-        /// </summary>
-        public event NodeViewCreateHandle OnNodeViewCreate;
-
-        #endregion
-
-        #region 转发事件的处理
-
-        /// <summary>
-        /// 从工作台事件转发器监听节点创建事件
-        /// </summary>
-        /// <param name="eventArgs"></param>
-        private void FeefService_OnNodeCreate(NodeCreateEventArgs eventArgs)
-        {
-            var nodeModel = eventArgs.NodeModel;
-            if (NodeControls.ContainsKey(nodeModel.Guid))
-            {
-                SereinEnv.WriteLine(InfoType.WARN, $"OnNodeCreate 事件意外触发，节点Guid重复 - {nodeModel.Guid}");
-                return;
-            }
-            if (!flowEnvironment.NodeMVVMManagement.TryGetType(nodeModel.ControlType, out var nodeMVVM))
-            {
-                SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModel.ControlType}节点，节点类型尚未注册。");
-                return;
-            }
-            if (nodeMVVM.ControlType == null
-                || nodeMVVM.ViewModelType == null)
-            {
-                SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModel.ControlType}节点，UI类型尚未注册（请通过 NodeMVVMManagement.RegisterUI() 方法进行注册）。");
-                return;
-            }
-
-            var isSuccessful = TryCreateNodeView(nodeMVVM.ControlType, // 控件UI类型
-                                                nodeMVVM.ViewModelType, // 控件VIewModel类型
-                                                nodeModel, // 控件数据实体
-                                                out var nodeControl); // 成功创建后传出的节点控件实体
-            if (!isSuccessful || nodeControl is null)
-            {
-                SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModel.ControlType}节点，节点创建失败。");
-                return;
-            }
-
-
-            var e = new NodeViewCreateEventArgs(nodeControl, eventArgs.Position);
-            if (OnNodeViewCreate?.Invoke(e) == true)
-            {
-                // 成功创建
-                NodeControls.TryAdd(nodeModel.Guid, nodeControl); // 缓存起来，通知其它地方拿取这个控件
-            }
-
-        }
-
-
-        /// <summary>
-        /// 运行环境连接了节点事件
-        /// </summary>
-        /// <param name="eventArgs"></param>
-        /// <exception cref="NotImplementedException"></exception>
-        private void FeefService_OnNodeConnectChange(NodeConnectChangeEventArgs eventArgs)
-        {
-            string fromNodeGuid = eventArgs.FromNodeGuid;
-            string toNodeGuid = eventArgs.ToNodeGuid;
-            if (!TryGetControl(fromNodeGuid, out var fromNodeControl)
-               || !TryGetControl(toNodeGuid, out var toNodeControl))
-            {
-                return;
-            }
-
-
-            if (eventArgs.JunctionOfConnectionType == JunctionOfConnectionType.Invoke)
-            {
-                ConnectionInvokeType connectionType = eventArgs.ConnectionInvokeType;
-                #region 创建/删除节点之间的调用关系
-                #region 创建连接
-                if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Create) // 添加连接
-                {
-                    if (fromNodeControl is not INodeJunction IFormJunction || toNodeControl is not INodeJunction IToJunction)
-                    {
-                        SereinEnv.WriteLine(InfoType.INFO, "非预期的连接");
-                        return;
-                    }
-                    var startJunction = IFormJunction.NextStepJunction;
-                    var endJunction = IToJunction.ExecuteJunction;
-
-                    // NodeConnectionLineControl nodeConnectionLineControl = new NodeConnectionLineControl(MainCanvas, startJunction, endJunction);
-
-                    //startJunction.TransformToVisual(MainCanvas);
-
-                    //// 添加连接
-                    //var shape = new ConnectionLineShape(
-                    //    FlowChartCanvas,
-                    //    connectionType,
-                    //    startJunction,
-                    //    endJunction
-                    //);
-
-
-                    //NodeConnectionLine nodeConnectionLine = new NodeConnectionLine(MainCanvas, shape);
-
-                    //if (toNodeControl is FlipflopNodeControl flipflopControl
-                    //    && flipflopControl?.ViewModel?.NodeModel is NodeModelBase nodeModel) // 某个节点连接到了触发器，尝试从全局触发器视图中移除该触发器
-                    //{
-                    //    NodeTreeViewer.RemoveGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
-                    //}
-
-                    //Connections.Add(nodeConnectionLineControl);
-                    //fromNodeControl.AddConnection(nodeConnectionLineControl);
-                    //toNodeControl.AddConnection(nodeConnectionLineControl);
-                }
-                #endregion
-
-
-                #region 移除连接
-               /* else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remove) // 移除连接
-                {
-                    // 需要移除连接
-                    var removeConnections = Connections.Where(c =>
-                                               c.Start.MyNode.Guid.Equals(fromNodeGuid)
-                                            && c.End.MyNode.Guid.Equals(toNodeGuid)
-                                            && (c.Start.JunctionType.ToConnectyionType() == JunctionOfConnectionType.Invoke
-                                            || c.End.JunctionType.ToConnectyionType() == JunctionOfConnectionType.Invoke))
-                                            .ToList();
-
-
-                    foreach (var connection in removeConnections)
-                    {
-                        Connections.Remove(connection);
-                        fromNodeControl.RemoveConnection(connection); // 移除连接
-                        toNodeControl.RemoveConnection(connection); // 移除连接
-                        if (NodeControls.TryGetValue(connection.End.MyNode.Guid, out var control))
-                        {
-                            JudgmentFlipFlopNode(control); // 连接关系变更时判断
-                        }
-                    }
-                }*/
-                #endregion
-
-
-                #endregion
-            }
-
-        }
-        #endregion
-
-        #region 私有方法
-
-        /// <summary>
-        /// 创建节点控件
-        /// </summary>
-        /// <param name="viewType">节点控件视图控件类型</param>
-        /// <param name="viewModelType">节点控件ViewModel类型</param>
-        /// <param name="nodeModel">节点Model实例</param>
-        /// <param name="nodeView">返回的节点对象</param>
-        /// <returns>是否创建成功</returns>
-        /// <exception cref="Exception">无法创建节点控件</exception>
-        private bool TryCreateNodeView(Type viewType, Type viewModelType, NodeModelBase nodeModel, out NodeControlBase? nodeView)
-        {
-            if (string.IsNullOrEmpty(nodeModel.Guid))
-            {
-                nodeModel.Guid = Guid.NewGuid().ToString();
-            }
-            var t_ViewModel = Activator.CreateInstance(viewModelType, nodeModel);
-            if (t_ViewModel is not NodeControlViewModelBase viewModelBase)
-            {
-                nodeView = null;
-                return false;
-            }
-            var controlObj = Activator.CreateInstance(viewType);
-            if (controlObj is NodeControlBase nodeControl)
-            {
-                nodeControl.DataContext = viewModelBase;
-                nodeView = nodeControl;
-                return true;
-            }
-            else
-            {
-                nodeView = null;
-                return false;
-            }
-
-            // 在其它地方验证过了，所以注释
-            //if ((viewType is null)
-            //    || viewModelType is null
-            //    || nodeModel is null)
-            //{
-            //    nodeView = null;
-            //    return false;
-            //}
-            //if (typeof(INodeControl).IsSubclassOf(viewType) 
-            // || typeof(NodeViewModelBase).IsSubclassOf(viewModelType))
-            //{
-            //    nodeView = null;
-            //    return false;
-            //}
-        }
-
-        private bool TryGetControl(string nodeGuid, out NodeControlBase nodeControl)
-        {
-            if (string.IsNullOrEmpty(nodeGuid))
-            {
-                nodeControl = null;
-                return false;
-            }
-            if (!NodeControls.TryGetValue(nodeGuid, out nodeControl))
-            {
-                nodeControl = null;
-                return false;
-            }
-            if (nodeControl is null)
-            {
-                return false;
-            }
-            return true;
-        }
-
-        #endregion
-
-        #region 操作接口对外暴露的接口
-
-        /// <summary>
-        /// 创建节点控件
-        /// </summary>
-        /// <param name="nodeType">控件类型</param>
-        /// <param name="position">创建坐标</param>
-        /// <param name="methodDetailsInfo">节点方法信息（基础节点传null）</param>
-        public void CreateNodeView(MethodDetailsInfo methodDetailsInfo, PositionOfUI position)
-        {
-            Task.Run(async () =>
-            {
-                if (EnumHelper.TryConvertEnum<NodeControlType>(methodDetailsInfo.NodeType, out var nodeType))
-                {
-                    await flowEnvironment.CreateNodeAsync(nodeType, position, methodDetailsInfo);
-                }
-            });
-        }
-
-
-
-
-        #endregion
-    }
-
-}

Workbench/Tool/Converters/BoolToVisibilityConverter.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Data;
+using System.Windows;
+
+namespace Serein.Workbench.Tool.Converters
+{
+    public class BoolToVisibilityConverter : IValueConverter
+    {
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (value is bool b)
+            {
+                return b ? Visibility.Visible : Visibility.Collapsed;
+            }
+            return Visibility.Collapsed;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            return value is Visibility v && v == Visibility.Visible;
+        }
+    }
+}

Workbench/ViewModels/FlowCanvasViewModel.cs

@@ -9,11 +9,35 @@ namespace Serein.Workbench.ViewModels
 {
     public partial class FlowCanvasViewModel : ObservableObject
     {
-
+        /// <summary>
+        /// 正在创建节点方法调用关系
+        /// </summary>
         [ObservableProperty]
         private bool _isConnectionInvokeNode;
 
+        /// <summary>
+        /// 正在创建节点参数连接关系
+        /// </summary>
         [ObservableProperty]
         private bool _isConnectionArgSourceNode;
+
+        /// <summary>
+        /// 画布显示名称
+        /// </summary>
+        [ObservableProperty]
+        private string _name;
+        
+        /// <summary>
+        /// 画布ID
+        /// </summary>
+        [ObservableProperty]
+        private string _canvasGuid;
+
+
+
+        public FlowCanvasViewModel()
+        {
+            
+        }
     }
 }

Workbench/ViewModels/FlowEditViewModel.cs

@@ -1,9 +1,15 @@
 using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Serein.Workbench.Models;
+using Serein.Workbench.Views;
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Windows.Input;
 
 namespace Serein.Workbench.ViewModels
 {
@@ -12,5 +18,80 @@ namespace Serein.Workbench.ViewModels
     /// </summary>
     public partial class FlowEditViewModel : ObservableObject
     {
+        public ObservableCollection<FlowCanvasModel> Tabs { get; set; }
+        public ICommand AddTabCommand { get; set; }
+        public ICommand RemoveTabCommand { get; set; }
+        public ICommand RenameTabCommand { get; set; }
+
+        [ObservableProperty]
+        private FlowCanvasModel _selectedTab;
+
+        private int _addCount = 0;
+
+        public FlowEditViewModel()
+        {
+            Tabs = new ObservableCollection<FlowCanvasModel>();
+            AddTabCommand = new RelayCommand(AddTab);
+            RemoveTabCommand = new RelayCommand(RemoveTab, CanRemoveTab);
+
+            // 初始化时添加一个默认的Tab
+            AddTab(); // 添加一个默认选项卡
+        }
+
+        private void AddTab()
+        {
+            var flowCanvasView = new FlowCanvasView(); // 创建FlowCanvasView实例
+            Tabs.Add(new FlowCanvasModel { Content = flowCanvasView ,Name = $"New Tab {_addCount++}"});
+            SelectedTab = Tabs[Tabs.Count - 1]; // 选择刚添加的Tab
+        }
+
+        private void RemoveTab()
+        {
+            if (Tabs.Count > 0 && SelectedTab != null)
+            {
+                Tabs.Remove(SelectedTab);
+                SelectedTab = Tabs.Count > 0 ? Tabs[Tabs.Count - 1] : null;
+            }
+        }
+
+        private bool CanRemoveTab()
+        {
+            return SelectedTab != null;
+        }
+
+       
+
+        /// <summary>
+        /// 进入编辑模式
+        /// </summary>
+        /// <param name="tab"></param>
+        public void StartEditingTab(FlowCanvasModel tab)
+        {
+            if (tab != null)
+            {
+                tab.IsEditing = true;
+                OnPropertyChanged(nameof(Tabs)); // 刷新Tabs集合，以便更新UI
+            }
+        }
+
+        /// <summary>
+        /// 结束编辑，重命名
+        /// </summary>
+        /// <param name="tab"></param>
+        /// <param name="newName"></param>
+        public void EndEditingTab(FlowCanvasModel tab, string newName)
+        {
+            if (tab != null)
+            {
+                tab.IsEditing = false;
+                tab.Name = newName; // 设置新名称
+                OnPropertyChanged(nameof(Tabs)); // 刷新Tabs集合
+            }
+        }
+        
+    
+
+      
+
     }
 }

Workbench/Views/FlowCanvasView.xaml

@@ -15,17 +15,14 @@
         <tool:HorizontalCenterThumbPositionConverter x:Key="HorizontalCenterThumbPositionConverter" />
     </UserControl.Resources>
 
-
+    <DockPanel x:Name="FlowChartStackPanel"
-
-    <StackPanel x:Name="FlowChartStackPanel"
                          ClipToBounds="True">
-        <!-- 虚拟化 VirtualizingStackPanel.IsVirtualizing="True" -->
+        <Canvas  ClipToBounds="True"
-        <Canvas 
                     x:Name="FlowChartCanvas" 
                     Background="#E1FBEA"
                     AllowDrop="True" 
-                    Width="1920"
+                    Width="1000"
-                    Height="1080"
+                    Height="600"
                     MouseLeftButtonDown ="FlowChartCanvas_MouseLeftButtonDown"
                     MouseLeftButtonUp="FlowChartCanvas_MouseLeftButtonUp"
                     MouseDown="FlowChartCanvas_MouseDown"
@@ -116,6 +113,6 @@ Canvas.Top="{Binding ActualHeight, ElementName=FlowChartCanvas, Mode=OneWay, Con
         </Canvas>
 
 
-    </StackPanel>
+    </DockPanel>
 
 </UserControl>

Workbench/Views/FlowCanvasView.xaml.cs

@@ -71,19 +71,6 @@ namespace Serein.Workbench.Views
         private Point startSelectControolPoint;
 
 
-        /// <summary>
-        /// 记录开始连接的文本块
-        /// </summary>
-        //private NodeControlBase? startConnectNodeControl;
-        /// <summary>
-        /// 当前正在绘制的连接线
-        /// </summary>
-        //private Line? currentLine;
-        /// <summary>
-        /// 当前正在绘制的真假分支属性
-        /// </summary>
-        //private ConnectionInvokeType currentConnectionType;
-
 
         /// <summary>
         /// 组合变换容器
@@ -103,9 +90,8 @@ namespace Serein.Workbench.Views
         public FlowCanvasView()
         {
             ViewModel = App.GetService<Locator>().FlowCanvasViewModel;
-
+            this.DataContext = ViewModel;
             EnvDecorator =  App.GetService<IFlowEnvironment>();
-
             InitializeComponent();
 
             #region 缩放平移容器
@@ -185,7 +171,6 @@ namespace Serein.Workbench.Views
             }
         }
 
-
         /// <summary>
         /// 放置操作，根据拖放数据创建相应的控件，并处理相关操作
         /// </summary>
@@ -201,9 +186,10 @@ namespace Serein.Workbench.Views
                 {
                     if (e.Data.GetData(MouseNodeType.CreateDllNodeInCanvas) is MoveNodeData nodeData)
                     {
+                        var canvasGuid = this.ViewModel.CanvasGuid;
                         Task.Run(async () =>
                         {
-                            await EnvDecorator.CreateNodeAsync(nodeData.NodeControlType, position, nodeData.MethodDetailsInfo); // 创建DLL文件的节点对象
+                            await EnvDecorator.CreateNodeAsync(canvasGuid, nodeData.NodeControlType, position, nodeData.MethodDetailsInfo); // 创建DLL文件的节点对象
                         });
                     }
                 }
@@ -223,9 +209,10 @@ namespace Serein.Workbench.Views
                         };
                         if (nodeControlType != NodeControlType.None)
                         {
+                            var canvasGuid = this.ViewModel.CanvasGuid;
                             Task.Run(async () =>
                             {
-                                await EnvDecorator.CreateNodeAsync(nodeControlType, position); // 创建基础节点对象
+                                await EnvDecorator.CreateNodeAsync(canvasGuid, nodeControlType, position); // 创建基础节点对象
                             });
                         }
                     }
@@ -257,11 +244,6 @@ namespace Serein.Workbench.Views
             e.Handled = true;
         }
 
-
-
-
-
-
         /// <summary>
         /// 在画布中尝试选取控件
         /// </summary>
@@ -340,7 +322,12 @@ namespace Serein.Workbench.Views
                         #region 方法调用关系创建
                         if (myData.Type == JunctionOfConnectionType.Invoke)
                         {
-                            await EnvDecorator.ConnectInvokeNodeAsync(myData.StartJunction.MyNode.Guid, myData.CurrentJunction.MyNode.Guid,
+                            var canvasGuid = this.ViewModel.CanvasGuid;
+
+                            await EnvDecorator.ConnectInvokeNodeAsync(
+                                        canvasGuid,
+                                        myData.StartJunction.MyNode.Guid, 
+                                        myData.CurrentJunction.MyNode.Guid,
                                         myData.StartJunction.JunctionType,
                                         myData.CurrentJunction.JunctionType,
                                         myData.ConnectionInvokeType);
@@ -359,8 +346,12 @@ namespace Serein.Workbench.Views
                             {
                                 argIndex = argJunction2.ArgIndex;
                             }
+                            var canvasGuid = this.ViewModel.CanvasGuid;
 
-                            await EnvDecorator.ConnectArgSourceNodeAsync(myData.StartJunction.MyNode.Guid, myData.CurrentJunction.MyNode.Guid,
+                            await EnvDecorator.ConnectArgSourceNodeAsync(
+                                    canvasGuid,
+                                    myData.StartJunction.MyNode.Guid, 
+                                    myData.CurrentJunction.MyNode.Guid,
                                     myData.StartJunction.JunctionType,
                                     myData.CurrentJunction.JunctionType,
                                     myData.ConnectionArgSourceType,
@@ -376,9 +367,6 @@ namespace Serein.Workbench.Views
 
         }
 
-
-
-
         #region 拖动画布实现缩放平移效果
         private void FlowChartCanvas_MouseDown(object sender, MouseButtonEventArgs e)
         {
@@ -568,7 +556,6 @@ namespace Serein.Workbench.Views
         #endregion
 
 
-
         /// 完成选取操作
         /// </summary>
         private void CompleteSelection()
@@ -607,7 +594,9 @@ namespace Serein.Workbench.Views
             SelectedNode();
         }
 
-
+        /// <summary>
+        /// 选择控件
+        /// </summary>
         private void SelectedNode()
         {
 
@@ -657,7 +646,10 @@ namespace Serein.Workbench.Views
         }
 
 
-
+        /// <summary>
+        /// 选择范围配置
+        /// </summary>
+        /// <returns></returns>
         private ContextMenu ConfiguerSelectionRectangle()
         {
             var contextMenu = new ContextMenu();
@@ -670,7 +662,8 @@ namespace Serein.Workbench.Views
                         var guid = node?.ViewModel?.NodeModel?.Guid;
                         if (!string.IsNullOrEmpty(guid))
                         {
-                            EnvDecorator.RemoveNodeAsync(guid);
+                            var canvasGuid = this.ViewModel.CanvasGuid;
+                            EnvDecorator.RemoveNodeAsync(canvasGuid, guid);
                         }
                     }
                 }

Workbench/Views/FlowEditView.xaml

@@ -4,10 +4,62 @@
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
              xmlns:local="clr-namespace:Serein.Workbench.Views"
+             xmlns:vm="clr-namespace:Serein.Workbench.ViewModels"
              mc:Ignorable="d" 
              d:DesignHeight="450" d:DesignWidth="800"
-              Background="#FFD3D3D3">
+             d:DataContext="{d:DesignInstance vm:FlowEditViewModel}"
+             xmlns:converters="clr-namespace:Serein.Workbench.Tool.Converters"
+             Background="#E7F0F6">
+    <UserControl.Resources>
+        <converters:InvertableBooleanToVisibilityConverter x:Key="InvertableBooleanToVisibilityConverter"/>
+
+    </UserControl.Resources>
     <Grid>
-        <local:FlowCanvasView></local:FlowCanvasView>
+        <!-- TabControl -->
+        <!--DragOver="TabControl_DragOver" 
+        Drop="TabControl_Drop"
+AllowDrop="True"-->
+        <TabControl SelectedItem="{Binding SelectedTab}" >
+            <TabControl.ItemTemplate>
+                <DataTemplate>
+                    <StackPanel>
+                        <!-- 双击选项卡名称来进入编辑模式 -->
+                        <TextBlock Text="{Binding Name}"
+                                   FontSize="18"
+                                   Visibility="{Binding IsEditing, Converter={StaticResource           InvertableBooleanToVisibilityConverter},ConverterParameter=Inverted}"
+                                   PreviewMouseLeftButtonDown="TextBlock_PreviewMouseLeftButtonDown"
+                                   MouseLeftButtonDown="TextBlock_MouseLeftButtonDown"/>
+                        <!-- 编辑模式下显示TextBox -->
+                        <TextBox Text="{Binding Name, Mode=TwoWay}" 
+                                 FontSize="18"
+                                 Visibility="{Binding IsEditing, Converter={StaticResource   InvertableBooleanToVisibilityConverter},ConverterParameter=Normal}"
+                                 KeyDown="TextBox_KeyDown" 
+                                 LostFocus="TextBox_LostFocus"/>
+                    </StackPanel>
+                </DataTemplate>
+            </TabControl.ItemTemplate>
+
+            <!-- Tabs Collection -->
+            <TabControl.ItemsSource>
+                <Binding Path="Tabs" />
+            </TabControl.ItemsSource>
+
+            <!-- Content of the Tab (e.g., FlowCanvasView) -->
+            <TabControl.ContentTemplate>
+                <DataTemplate>
+                    <Grid Background="#FFD3D3D3">
+                        <ContentControl Content="{Binding Content}" />
+                    </Grid>
+                </DataTemplate>
+            </TabControl.ContentTemplate>
+        </TabControl>
+
+        <!-- Tab control buttons -->
+        <StackPanel Orientation="Horizontal" VerticalAlignment="Top" HorizontalAlignment="Right">
+            <Button Content="添加" Command="{Binding AddTabCommand}"  Margin="5" Width="80"/>
+            <Button Content="移除" Command="{Binding RemoveTabCommand}"  Margin="5" Width="80"/>
+            <!--<Button Content="Rename Tab" Command="{Binding RenameTabCommand}" />-->
+        </StackPanel>
     </Grid>
 </UserControl>
+

Workbench/Views/FlowEditView.xaml.cs

@@ -1,4 +1,5 @@
-using Serein.Workbench.ViewModels;
+using Serein.Workbench.Models;
+using Serein.Workbench.ViewModels;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -8,11 +9,19 @@ using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Data;
 using System.Windows.Documents;
+using System.Windows.Forms;
 using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using System.Windows.Navigation;
 using System.Windows.Shapes;
+using System.Windows.Threading;
+using static System.Windows.Forms.VisualStyles.VisualStyleElement;
+using DragDropEffects = System.Windows.DragDropEffects;
+using DragEventArgs = System.Windows.DragEventArgs;
+using TabControl = System.Windows.Controls.TabControl;
+using TextBox = System.Windows.Controls.TextBox;
+using UserControl = System.Windows.Controls.UserControl;
 
 namespace Serein.Workbench.Views
 {
@@ -24,8 +33,99 @@ namespace Serein.Workbench.Views
         public FlowEditView()
         {
             this.DataContext = App.GetService<Locator>().FlowEditViewModel;
-
             InitializeComponent();
         }
+
+        private void TextBlock_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            var textBlock = sender as TextBlock;
+            var tab = textBlock?.DataContext as FlowCanvasModel;
+            if (tab != null)
+            {
+                DragDrop.DoDragDrop(textBlock, tab, DragDropEffects.Move);
+            }
+        }
+        private void TabControl_DragOver(object sender, DragEventArgs e)
+        {
+            if (e.Data.GetDataPresent(typeof(FlowCanvasModel)))
+            {
+                e.Effects = DragDropEffects.Move;
+            }
+            else
+            {
+                e.Effects = DragDropEffects.None;
+            }
+        }
+
+        private void TabControl_Drop(object sender, DragEventArgs e)
+        {
+            var sourceTab = e.Data.GetData(typeof(FlowCanvasModel)) as FlowCanvasModel;
+            var targetTab = (sender as TabControl)?.SelectedItem as FlowCanvasModel;
+            var viewModel = (FlowEditViewModel)this.DataContext;
+            if (sourceTab != null && targetTab != null && sourceTab != targetTab)
+            {
+                var sourceIndex = viewModel.Tabs.IndexOf(sourceTab);
+                var targetIndex = viewModel.Tabs.IndexOf(targetTab);
+
+                // 删除源项并插入到目标位置
+                viewModel.Tabs.Remove(sourceTab);
+                viewModel.Tabs.Insert(targetIndex, sourceTab);
+
+                // 更新视图模型中的选中的Tab
+                viewModel.SelectedTab = sourceTab;
+            }
+        }
+
+
+        private void TextBox_KeyDown(object sender, System.Windows.Input.KeyEventArgs e)
+        {
+         
+            if (e.Key == Key.Enter || e.Key == Key.Escape)
+            {
+                var textBox = sender as TextBox;
+                var newName = textBox?.Text;
+                if (string.IsNullOrEmpty(newName))
+                {
+                    return;
+                }
+                var tab = textBox?.DataContext as FlowCanvasModel;
+                if (tab != null)
+                {
+                    var viewModel = (FlowEditViewModel)this.DataContext;
+                    viewModel.EndEditingTab(tab, newName); // 确认新名称
+                }
+            }
+        }
+
+        private void TextBox_LostFocus(object sender, RoutedEventArgs e)
+        {
+            var textBox = sender as TextBox;
+            var newName = textBox?.Text;
+            if (string.IsNullOrEmpty(newName))
+            {
+                return;
+            }
+            var tab = textBox?.DataContext as FlowCanvasModel;
+            if (tab != null && tab.IsEditing)
+            {
+                var viewModel = (FlowEditViewModel)this.DataContext;
+                viewModel.EndEditingTab(tab, newName); // 确认新名称
+            }
+        }
+
+        private void TextBlock_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            if (e.ClickCount == 2)
+            {
+                var textBlock = sender as TextBlock;
+                var tab = textBlock?.DataContext as FlowCanvasModel;
+                if (tab != null)
+                {
+                    var viewModel = (FlowEditViewModel)this.DataContext;
+                    viewModel.StartEditingTab(tab);
+                }
+            }
+            
+        }
     }
 }

Workbench/Views/FlowWorkbenchView.xaml.cs

@@ -25,7 +25,6 @@ namespace Serein.Workbench.Views
             this.DataContext = App.GetService<Locator>().FlowWorkbenchViewModel;
             InitializeComponent();
         }
-
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
             this.MaxHeight = SystemParameters.PrimaryScreenHeight;