重写了节点的view、viewmodel关系，实现了对画布元素的选取功能，重构了底层依赖，添加了对net .Framework4.6.1以上的Framework类库支持

2026-03-06 01:30:47 +08:00 · 2024-09-12 20:32:54 +08:00
parent ec6e09ced1
commit f286fc644a
120 changed files with 91218 additions and 761 deletions
--- a/Library.Framework/NodeFlow/Tool/Attribute.cs
+++ b/Library.Framework/NodeFlow/Tool/Attribute.cs
@@ -0,0 +1,8 @@
+using Serein.Library.Api.Enums;
+using System;
+
+namespace Serein.Library.Framework.NodeFlow.Tool
+{
+
+    
+}
--- a/Library.Framework/NodeFlow/Tool/DynamicTool.cs
+++ b/Library.Framework/NodeFlow/Tool/DynamicTool.cs
@@ -0,0 +1,194 @@
+namespace Serein.Library.Framework.NodeFlow.Tool
+{
+
+    #region 锁、tsk工具 (已注释）
+    /*public class LockManager
+    {
+        private readonly ConcurrentDictionary<string, LockQueue> _locks = new ConcurrentDictionary<string, LockQueue>();
+
+        public void CreateLock(string name)
+        {
+            _locks.TryAdd(name, new LockQueue());
+        }
+
+        public async Task AcquireLockAsync(string name, CancellationToken cancellationToken = default)
+        {
+            if (!_locks.ContainsKey(name))
+            {
+                throw new ArgumentException($"Lock with name '{name}' does not exist.");
+            }
+
+            var lockQueue = _locks[name];
+            var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            lock (lockQueue.Queue)
+            {
+                lockQueue.Queue.Enqueue(tcs);
+                if (lockQueue.Queue.Count == 1)
+                {
+                    tcs.SetResult(true);
+                }
+            }
+
+            await tcs.Task.ConfigureAwait(false);
+
+            // 处理取消操作
+            if (cancellationToken.CanBeCanceled)
+            {
+                cancellationToken.Register(() =>
+                {
+                    lock (lockQueue.Queue)
+                    {
+                        if (lockQueue.Queue.Contains(tcs))
+                        {
+                            tcs.TrySetCanceled();
+                        }
+                    }
+                });
+            }
+        }
+
+        public void ReleaseLock(string name)
+        {
+            if (!_locks.ContainsKey(name))
+            {
+                throw new ArgumentException($"Lock with name '{name}' does not exist.");
+            }
+
+            var lockQueue = _locks[name];
+
+            lock (lockQueue.Queue)
+            {
+                if (lockQueue.Queue.Count > 0)
+                {
+                    lockQueue.Queue.Dequeue();
+
+                    if (lockQueue.Queue.Count > 0)
+                    {
+                        var next = lockQueue.Queue.Peek();
+                        next.SetResult(true);
+                    }
+                }
+            }
+        }
+
+        private class LockQueue
+        {
+            public Queue<TaskCompletionSource<bool>> Queue { get; } = new Queue<TaskCompletionSource<bool>>();
+        }
+    }
+
+
+    public interface ITaskResult
+    {
+        object Result { get; }
+    }
+
+    public class TaskResult<T> : ITaskResult
+    {
+        public TaskResult(T result)
+        {
+            Result = result;
+        }
+
+        public T Result { get; }
+
+        object ITaskResult.Result => Result;
+    }
+
+    public class DynamicTasks
+    {
+        private static readonly ConcurrentDictionary<string, Task<ITaskResult>> TaskGuidPairs = new();
+        public static Task<ITaskResult> GetTask(string Guid)
+        {
+            TaskGuidPairs.TryGetValue(Guid, out Task<ITaskResult> task);
+            return task;
+        }
+
+        public static bool AddTask<T>(string Guid, T result)
+        {
+            var task = Task.FromResult<ITaskResult>(new TaskResult<T>(result));
+
+            return TaskGuidPairs.TryAdd(Guid, task);
+        }
+    }
+    public class TaskNodeManager
+    {
+        private readonly ConcurrentDictionary<string, TaskQueue> _taskQueues = new ConcurrentDictionary<string, TaskQueue>();
+
+        public void CreateTaskNode(string name)
+        {
+            _taskQueues.TryAdd(name, new TaskQueue());
+        }
+
+        public async Task WaitForTaskNodeAsync(string name, CancellationToken cancellationToken = default)
+        {
+            if (!_taskQueues.ContainsKey(name))
+            {
+                throw new ArgumentException($"Task node with name '{name}' does not exist.");
+            }
+
+            var taskQueue = _taskQueues[name];
+            var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            lock (taskQueue.Queue)
+            {
+                taskQueue.Queue.Enqueue(tcs);
+                if (taskQueue.Queue.Count == 1)
+                {
+                    tcs.SetResult(true);
+                }
+            }
+
+            await tcs.Task.ConfigureAwait(false);
+
+            // 处理取消操作
+            if (cancellationToken.CanBeCanceled)
+            {
+                cancellationToken.Register(() =>
+                {
+                    lock (taskQueue.Queue)
+                    {
+                        if (taskQueue.Queue.Contains(tcs))
+                        {
+                            tcs.TrySetCanceled();
+                        }
+                    }
+                });
+            }
+        }
+
+        public void CompleteTaskNode(string name)
+        {
+            if (!_taskQueues.ContainsKey(name))
+            {
+                throw new ArgumentException($"Task node with name '{name}' does not exist.");
+            }
+
+            var taskQueue = _taskQueues[name];
+
+            lock (taskQueue.Queue)
+            {
+                if (taskQueue.Queue.Count > 0)
+                {
+                    taskQueue.Queue.Dequeue();
+
+                    if (taskQueue.Queue.Count > 0)
+                    {
+                        var next = taskQueue.Queue.Peek();
+                        next.SetResult(true);
+                    }
+                }
+            }
+        }
+
+        private class TaskQueue
+        {
+            public Queue<TaskCompletionSource<bool>> Queue { get; } = new Queue<TaskCompletionSource<bool>>();
+        }
+    }*/
+    #endregion
+
+
+
+}
--- a/Library.Framework/NodeFlow/Tool/TcsSignal.cs
+++ b/Library.Framework/NodeFlow/Tool/TcsSignal.cs
@@ -0,0 +1,65 @@
+using Serein.Library.Enums;
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+
+namespace Serein.Library.Framework.NodeFlow.Tool
+{
+    public class TcsSignalException : Exception
+    {
+        public FlowStateType FsState { get; set; }
+        public TcsSignalException(string message) : base(message)
+        {
+            FsState = FlowStateType.Error;
+        }
+    }
+
+    public class TcsSignal<TSignal> where TSignal : struct, Enum
+    {
+        //public ConcurrentDictionary<TSignal, Queue<TaskCompletionSource<object>>> TcsEvent { get; } = new();
+        public ConcurrentDictionary<TSignal, TaskCompletionSource<object>> TcsEvent { get; } = new ConcurrentDictionary<TSignal, TaskCompletionSource<object>>();
+
+        public ConcurrentDictionary<TSignal, object> TcsLock { get; } = new ConcurrentDictionary<TSignal, object>();
+
+        /// <summary>
+        /// 触发信号
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="signal">信号</param>
+        /// <param name="value">传递的参数</param>
+        /// <returns>是否成功触发</returns>
+        public bool TriggerSignal<T>(TSignal signal, T value)
+        {
+            var tcsLock = TcsLock.GetOrAdd(signal, new object());
+            lock (tcsLock)
+            {
+                if (TcsEvent.TryRemove(signal, out var waitTcs))
+                {
+                    waitTcs.SetResult(value);
+                    return true;
+                }
+                return false;
+            }
+        }
+
+        public TaskCompletionSource<object> CreateTcs(TSignal signal)
+        {
+            var tcsLock = TcsLock.GetOrAdd(signal, new object());
+            lock (tcsLock)
+            {
+                var tcs = TcsEvent.GetOrAdd(signal, new TaskCompletionSource<object>());
+                return tcs;
+            }
+            
+        }
+
+        public void CancelTask()
+        {
+            foreach (var tcs in TcsEvent.Values)
+            {
+                tcs.SetException(new TcsSignalException("任务取消"));
+            }
+            TcsEvent.Clear();
+        }
+    }
+}