移除了中断相关的后台代码与UI交互（待重写）；重写运行时节点获取参数的方法；重写了节点容器的互动；完善了WebSocket远程交互；完善了项目文件的加载；

2026-03-03 00:00:49 +08:00 · 2024-12-26 16:42:05 +08:00
parent 56b22be8c0
commit 7a6f8c407b
37 changed files with 880 additions and 1127 deletions
--- a/Library/Utils/FlowTrigger/ChannelFlowInterrupt.cs
+++ b/Library/Utils/FlowTrigger/ChannelFlowInterrupt.cs
@@ -0,0 +1,163 @@
+using Newtonsoft.Json.Linq;
+using Serein.Library.Api;
+using Serein.Library.Utils;
+using System;
+using System.Collections.Concurrent;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using System.Transactions;
+
+namespace Serein.Library.Utils
+{
+
+
+    /// <summary>
+    /// 信号触发器类，带有消息广播功能。
+    /// 使用枚举作为标记，创建
+    /// </summary>
+    public class ValueTaskFlowTrigger<TSignal>
+    {
+        // 使用并发字典管理每个信号对应的广播列表
+        private readonly ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>> _subscribers = new ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>>();
+
+        /// <summary>
+        /// 获取或创建指定信号的 Subject（消息广播者）
+        /// </summary>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <returns>对应的 Subject</returns>
+        private Subject<TriggerResult<object>> GetOrCreateSubject(TSignal signal)
+        {
+            return _subscribers.GetOrAdd(signal, _ => new Subject<TriggerResult<object>>());
+        }
+
+        /// <summary>
+        /// 订阅指定信号的消息
+        /// </summary>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <param name="observer">订阅者</param>
+        /// <returns>取消订阅的句柄</returns>
+        private IDisposable Subscribe<TResult>(TSignal signal, Action<TriggerResult<object>> action)
+        {
+            IObserver<TriggerResult<object>> observer = new Observer<TriggerResult<object>>(action);
+            var subject = GetOrCreateSubject(signal);
+            return subject.Subscribe(observer); // 返回取消订阅的句柄
+        }
+
+
+
+        /// <summary>
+        /// 等待触发器并指定超时的时间
+        /// </summary>
+        /// <typeparam name="TResult">返回值类型</typeparam>
+        /// <param name="signal">等待信号</param>
+        /// <param name="outTime">超时时间</param>
+        /// <returns></returns>
+        public async ValueTask<TriggerResult<TResult>> WaitTriggerWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime)
+        {
+            var subject = GetOrCreateSubject(signal);
+            var cts = new CancellationTokenSource();
+
+            // 异步任务：超时后自动触发信号
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await Task.Delay(outTime, cts.Token);
+                    if (!cts.IsCancellationRequested) // 如果还没有被取消
+                    {
+                        var outResult = new TriggerResult<object>()
+                        {
+                            Type = TriggerDescription.Overtime
+                        };
+                        subject.OnNext(outResult); // 广播给所有订阅者
+                        subject.OnCompleted(); // 通知订阅结束
+                    }
+                }
+                catch (OperationCanceledException)
+                {
+                    // 超时任务被取消
+                }
+                finally
+                {
+                    cts?.Dispose();  // 确保 cts 被释放
+                }
+            }, cts.Token);
+            var result = await WaitTriggerAsync<TResult>(signal); // 返回一个可以超时触发的等待任务
+            return result;
+        }
+
+        /// <summary>
+        /// 等待触发
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="signal"></param>
+        /// <returns></returns>
+        public async ValueTask<TriggerResult<TResult>> WaitTriggerAsync<TResult>(TSignal signal)
+        {
+
+            var taskCompletionSource = new TaskCompletionSource<TriggerResult<object>>();
+            var subscription = Subscribe<TResult>(signal, taskCompletionSource.SetResult);
+            var result = await taskCompletionSource.Task;
+            subscription.Dispose(); // 取消订阅
+            if (result.Value is TResult data)
+            {
+                return new TriggerResult<TResult>()
+                {
+                    Value = data,
+                    Type = TriggerDescription.External,
+                };
+            }
+            else
+            {
+                return new TriggerResult<TResult>()
+                {
+                    Type = TriggerDescription.TypeInconsistency,
+                };
+            }
+        }
+
+
+        /// <summary>
+        /// 手动触发信号，并广播给所有订阅者
+        /// </summary>
+        /// <typeparam name="TResult">触发类型</typeparam>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <param name="value">传递的数据</param>
+        /// <returns>是否成功触发</returns>
+        public Task<bool> InvokeTriggerAsync<TResult>(TSignal signal, TResult value)
+        {
+            if (_subscribers.TryGetValue(signal, out var subject))
+            {
+                var result = new TriggerResult<object>()
+                {
+                    Type = TriggerDescription.External,
+                    Value = value
+                };
+                subject.OnNext(result); // 广播给所有订阅者
+                subject.OnCompleted(); // 通知订阅结束
+                return Task.FromResult(true);
+            }
+            return Task.FromResult(false);
+        }
+        /// <summary>
+        /// 取消所有任务
+        /// </summary>
+
+        public void CancelAllTrigger()
+        {
+            foreach (var subject in _subscribers.Values)
+            {
+                subject.OnCompleted(); // 通知所有订阅者结束
+            }
+            _subscribers.Clear();
+        }
+    }
+
+
+
+
+
+}
--- a/Library/Utils/FlowTrigger/ChannelFlowTrigger.cs
+++ b/Library/Utils/FlowTrigger/ChannelFlowTrigger.cs
@@ -0,0 +1,116 @@
+using Serein.Library.Api;
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+
+
+namespace Serein.Library.Utils
+{
+
+
+
+    public class ChannelFlowTrigger<TSignal> : IFlowTrigger<TSignal>
+    {
+        // 使用并发字典管理每个枚举信号对应的 Channel
+        private readonly ConcurrentDictionary<TSignal, Channel<TriggerResult<object>>> _channels = new ConcurrentDictionary<TSignal, Channel<TriggerResult<object>>>();
+
+        /// <summary>
+        /// 获取或创建指定信号的 Channel
+        /// </summary>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <returns>对应的 Channel</returns>
+        private Channel<TriggerResult<object>> GetOrCreateChannel(TSignal signal)
+        {
+            return _channels.GetOrAdd(signal, _ => Channel.CreateUnbounded<TriggerResult<object>>());
+        }
+
+        public async Task<TriggerResult<TResult>> WaitTriggerWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime)
+        {
+            var channel = GetOrCreateChannel(signal);
+            var cts = new CancellationTokenSource();
+
+            // 异步任务：超时后自动触发信号
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await Task.Delay(outTime, cts.Token);
+                    var outResult = new TriggerResult<object>()
+                    {
+                        Type = TriggerDescription.Overtime
+                    };
+                    await channel.Writer.WriteAsync(outResult);
+                }
+                catch (OperationCanceledException)
+                {
+                    // 超时任务被取消
+                }
+            }, cts.Token);
+
+            // 等待信号传入（超时或手动触发）
+            var result = await WaitTriggerAsync<TResult>(signal); // 返回一个可以超时触发的等待任务
+            return result;
+
+
+        }
+
+        public async Task<TriggerResult<TResult>> WaitTriggerAsync<TResult>(TSignal signal)
+        {
+            var channel = GetOrCreateChannel(signal);
+            // 等待信号传入（超时或手动触发）
+            var result = await channel.Reader.ReadAsync();
+            if (result.Value is TResult data)
+            {
+                return new TriggerResult<TResult>()
+                {
+                    Value = data,
+                    Type = TriggerDescription.External,
+                };
+            }
+            else
+            {
+                return new TriggerResult<TResult>()
+                {
+                    Type = TriggerDescription.TypeInconsistency,
+                };
+            }
+        }
+
+        public async Task<bool> InvokeTriggerAsync<TResult>(TSignal signal, TResult value)
+        {
+            if (_channels.TryGetValue(signal, out var channel))
+            {
+                // 手动触发信号
+                var result = new TriggerResult<object>()
+                {
+                    Type = TriggerDescription.External,
+                    Value = value
+                };
+                await channel.Writer.WriteAsync(result);
+                return true;
+            }
+            return false;
+        }
+
+        public void CancelAllTrigger()
+        {
+            foreach (var channel in _channels.Values)
+            {
+                channel.Writer.Complete();
+            }
+            _channels.Clear();
+        }
+    }
+
+
+
+
+
+
+
+
+
+
+}
--- a/Library/Utils/FlowTrigger/TaskFlowTrigger.cs
+++ b/Library/Utils/FlowTrigger/TaskFlowTrigger.cs
@@ -0,0 +1,160 @@
+using Microsoft.Extensions.ObjectPool;
+using Newtonsoft.Json.Linq;
+using Serein.Library.Api;
+using Serein.Library.Utils;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+using System.Transactions;
+
+namespace Serein.Library.Utils
+{
+
+    /// <summary>
+    /// 信号触发器类，带有消息广播功能。
+    /// 使用枚举作为标记，创建
+    /// </summary>
+    public class TaskFlowTrigger<TSignal> : IFlowTrigger<TSignal>
+    {
+        // 使用并发字典管理每个信号对应的广播列表
+        private readonly ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>> _subscribers = new ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>>();
+        private readonly TriggerResultPool _triggerResultPool = new TriggerResultPool();
+        /// <summary>
+        /// 获取或创建指定信号的 Subject（消息广播者）
+        /// </summary>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <returns>对应的 Subject</returns>
+        private Subject<TriggerResult<object>> GetOrCreateSubject(TSignal signal)
+        {
+            return _subscribers.GetOrAdd(signal, _ => new Subject<TriggerResult<object>>());
+        }
+
+        /// <summary>
+        /// 订阅指定信号的消息
+        /// </summary>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <param name="action">订阅者</param>
+        /// <returns>取消订阅的句柄</returns>
+        private IDisposable Subscribe<TResult>(TSignal signal, Action<TriggerResult<object>> action)
+        {
+            IObserver<TriggerResult<object>> observer = new Observer<TriggerResult<object>>(action);
+            var subject = GetOrCreateSubject(signal);
+            return subject.Subscribe(observer); // 返回取消订阅的句柄
+        }
+
+
+
+        /// <summary>
+        /// 等待触发器并指定超时的时间
+        /// </summary>
+        /// <typeparam name="TResult">返回值类型</typeparam>
+        /// <param name="signal">等待信号</param>
+        /// <param name="outTime">超时时间</param>
+        /// <returns></returns>
+        public async Task<TriggerResult<TResult>> WaitTriggerWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime)
+        {
+            var subject = GetOrCreateSubject(signal);
+            var cts = new CancellationTokenSource();
+
+            // 超时任务：延迟后触发超时信号
+            var timeoutTask = Task.Delay(outTime, cts.Token).ContinueWith(t =>
+            {
+                if (!cts.Token.IsCancellationRequested)
+                {
+                    var outResult = _triggerResultPool.Get();
+                    outResult.Type = TriggerDescription.Overtime;
+                    subject.OnNext(outResult);
+                    subject.OnCompleted();
+                }
+            }, cts.Token, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Default);
+
+            var result = await WaitTriggerAsync<TResult>(signal); // 获取触发的结果
+            cts.Cancel();  // 取消超时任务
+            await timeoutTask; // 确保超时任务完成
+            cts.Dispose();
+            return result;
+
+        }
+
+        /// <summary>
+        /// 等待触发
+        /// </summary>
+        /// <typeparam name="TResult"></typeparam>
+        /// <param name="signal"></param>
+        /// <returns></returns>
+        public async Task<TriggerResult<TResult>> WaitTriggerAsync<TResult>(TSignal signal)
+        {
+            var taskCompletionSource = new TaskCompletionSource<TriggerResult<object>>();
+            var subscription = Subscribe<TResult>(signal, taskCompletionSource.SetResult);
+            var result = await taskCompletionSource.Task;
+            subscription.Dispose(); // 取消订阅
+            var result2 = result.Value is TResult data
+                ? new TriggerResult<TResult> { Value = data, Type = TriggerDescription.External }
+                : new TriggerResult<TResult> { Type = TriggerDescription.TypeInconsistency };
+            _triggerResultPool.Return(result); // 将结果归还池中
+            return result2;
+        }
+
+
+        /// <summary>
+        /// 手动触发信号，并广播给所有订阅者
+        /// </summary>
+        /// <typeparam name="TResult">触发类型</typeparam>
+        /// <param name="signal">枚举信号标识符</param>
+        /// <param name="value">传递的数据</param>
+        /// <returns>是否成功触发</returns>
+        public Task<bool> InvokeTriggerAsync<TResult>(TSignal signal, TResult value)
+        {
+            if (_subscribers.TryGetValue(signal, out var subject))
+            {
+                var result = _triggerResultPool.Get();
+                result.Type = TriggerDescription.External;
+                result.Value = value;
+                subject.OnNext(result); // 广播给所有订阅者
+                subject.OnCompleted(); // 通知订阅结束
+                return Task.FromResult(true);
+            }
+            return Task.FromResult(false);
+        }
+        /// <summary>
+        /// 取消所有任务
+        /// </summary>
+
+        public void CancelAllTrigger()
+        {
+            foreach (var subject in _subscribers.Values)
+            {
+                subject.OnCompleted(); // 通知所有订阅者结束
+            }
+            _subscribers.Clear();
+        }
+    }
+
+
+
+
+    /// <summary>
+    /// 观察者类，用于包装 Action
+    /// </summary>
+    public class Observer<T> : IObserver<T>
+    {
+        private readonly Action<T> _onNext;
+
+        public Observer(Action<T> onNext)
+        {
+            _onNext = onNext;
+        }
+
+        public void OnCompleted() { }
+        public void OnError(Exception error) { }
+        public void OnNext(T value)
+        {
+            _onNext?.Invoke(value);
+        }
+    }
+}
--- a/Library/Utils/FlowTrigger/TriggerResult.cs
+++ b/Library/Utils/FlowTrigger/TriggerResult.cs
@@ -0,0 +1,112 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Serein.Library.Utils
+{
+    public class TriggerResult<TResult>
+    {
+        public TriggerDescription Type { get; set; }
+        public TResult Value { get; set; }
+    }
+
+    /// <summary>
+    /// 对象池队列
+    /// </summary>
+    public class ConcurrentExpandingObjectPool<T> where T : class, new()
+    {
+        private readonly ConcurrentQueue<T> _pool; // 存储池中对象的队列
+
+        public ConcurrentExpandingObjectPool(int initialCapacity)
+        {
+            // 初始化对象池，初始容量为 initialCapacity
+            _pool = new ConcurrentQueue<T>();
+
+            // 填充初始对象
+            for (int i = 0; i < initialCapacity; i++)
+            {
+                _pool.Enqueue(new T());
+            }
+        }
+
+        /// <summary>
+        /// 获取一个对象，如果池中没有对象，则动态创建新的对象
+        /// </summary>
+        /// <returns>池中的一个对象</returns>
+        public T Get()
+        {
+            // 尝试从池中获取一个对象
+            if (!_pool.TryDequeue(out var item))
+            {
+                // 如果池为空，则创建一个新的对象
+                item = new T();
+            }
+
+            return item;
+        }
+
+        /// <summary>
+        /// 将一个对象归还到池中
+        /// </summary>
+        /// <param name="item">需要归还的对象</param>
+        public void Return(T item)
+        {
+            // 将对象归还到池中
+            _pool.Enqueue(item);
+        }
+
+        /// <summary>
+        /// 获取当前池中的对象数
+        /// </summary>
+        public int CurrentSize => _pool.Count;
+
+        /// <summary>
+        /// 清空池中的所有对象
+        /// </summary>
+        public void Clear()
+        {
+            while (_pool.TryDequeue(out _)) { } // 清空队列
+        }
+    }
+
+    /// <summary>
+    /// 使用 ObjectPool 来复用 TriggerResult 对象
+    /// </summary>
+      // 示例 TriggerResult 对象池
+    public class TriggerResultPool
+    {
+        private readonly ConcurrentExpandingObjectPool<TriggerResult<object>> _objectPool;
+
+        public TriggerResultPool(int defaultCapacity = 30)
+        {
+            _objectPool = new ConcurrentExpandingObjectPool<TriggerResult<object>>(defaultCapacity);
+        }
+
+        public TriggerResult<object> Get() => _objectPool.Get();
+
+        public void Return(TriggerResult<object> result) => _objectPool.Return(result);
+    }
+
+
+    /// <summary>
+    /// 触发类型
+    /// </summary>
+    public enum TriggerDescription
+    {
+        /// <summary>
+        /// 外部触发
+        /// </summary>
+        External,
+        /// <summary>
+        /// 超时触发
+        /// </summary>
+        Overtime,
+        /// <summary>
+        /// 触发了，但类型不一致
+        /// </summary>
+        TypeInconsistency
+    }
+}