zhusenlin/serein-flow
1
0
Fork 0
mirror of https://gitee.com/langsisi_admin/serein-flow synced 2026-04-28 18:43:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

更改了日志输出，更改了ChannelFlowTrigger存在的内存泄漏（取消超时机制）

Browse Source
This commit is contained in:
fengjiayi
2024-09-21 10:06:44 +08:00
parent a1ecd259dd
commit 3537a49784
15 changed files with 624 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
Library.Framework/NodeFlow/DynamicContext.cs
View File

@@ -24,17 +24,24 @@ namespace Serein.Library.Framework.NodeFlow
{ {
if(NodeRunCts == null) if(NodeRunCts == null)
{ {
NodeRunCts = SereinIoc.GetOrRegisterInstantiate<NodeRunCts>(); NodeRunCts = SereinIoc.GetOrRegisterInstantiate<NodeRunCts>();
} }
return Task.Factory.StartNew(async () => // 使用局部变量，避免捕获外部的 `action`
Action localAction = action;
return Task.Run(async () =>
{ {
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
NodeRunCts.Token.ThrowIfCancellationRequested(); NodeRunCts.Token.ThrowIfCancellationRequested();
await Task.Delay(time); await Task.Delay(time);
action.Invoke();
// 确保对局部变量的引用
localAction?.Invoke();
} }
// 清理引用，避免闭包导致的内存泄漏
localAction = null;
}); });
} }
} }

1
Library/Api/IDynamicContext.cs
View File

@@ -8,7 +8,6 @@ namespace Serein.Library.Api
{ {
IFlowEnvironment FlowEnvironment { get; } IFlowEnvironment FlowEnvironment { get; }
ISereinIOC SereinIoc { get; } ISereinIOC SereinIoc { get; }
NodeRunCts NodeRunCts { get; set; }
Task CreateTimingTask(Action action, int time = 100, int count = -1); Task CreateTimingTask(Action action, int time = 100, int count = -1);
} }
} }

6
Library/Api/ISereinIoc.cs
View File

@@ -25,6 +25,12 @@ namespace Serein.Library.Api
/// 获取或创建并注入目标类型 /// 获取或创建并注入目标类型
/// </summary> /// </summary>
object GetOrRegisterInstantiate(Type type); object GetOrRegisterInstantiate(Type type);
object Get(Type type);
T Get<T>(string name);
object Get(string name);
void CustomRegisterInstance(string name, object instance, bool needInjectProperty = true);
/// <summary> /// <summary>
/// 创建目标类型的对象， 并注入依赖项 /// 创建目标类型的对象， 并注入依赖项

10
Library/Utils/ChannelFlowInterrupt.cs
View File

@@ -37,12 +37,20 @@ namespace Serein.Library.Utils
try try
{ {
await Task.Delay(outTime, cts.Token); await Task.Delay(outTime, cts.Token);
await channel.Writer.WriteAsync(CancelType.Overtime); if(!cts.Token.IsCancellationRequested)
{
await channel.Writer.WriteAsync(CancelType.Overtime);
}
} }
catch (OperationCanceledException) catch (OperationCanceledException)
{ {
// 超时任务被取消 // 超时任务被取消
} }
finally
{
cts?.Dispose();
}
}, cts.Token); }, cts.Token);
// 等待信号传入（超时或手动触发） // 等待信号传入（超时或手动触发）

55
Library/Utils/ChannelFlowTrigger.cs
View File

@@ -34,8 +34,11 @@ namespace Serein.Library.NodeFlow.Tool
// 使用并发字典管理每个枚举信号对应的 Channel // 使用并发字典管理每个枚举信号对应的 Channel
private readonly ConcurrentDictionary<TSignal, Channel<TriggerData>> _channels = new ConcurrentDictionary<TSignal, Channel<TriggerData>>(); private readonly ConcurrentDictionary<TSignal, Channel<TriggerData>> _channels = new ConcurrentDictionary<TSignal, Channel<TriggerData>>();
// 到期后自动触发。短时间内触发频率过高的情况下，请将 outTime 设置位短一些的时间，因为如果超时等待时间过长，会导致非预期的“托管内存泄露”。
/// <summary> /// <summary>
/// 创建信号并指定超时时间，到期后自动触发（异步方法） /// 创建信号并指定超时时间的Channel.
/// </summary> /// </summary>
/// <param name="signal">枚举信号标识符</param> /// <param name="signal">枚举信号标识符</param>
/// <param name="outTime">超时时间</param> /// <param name="outTime">超时时间</param>
@@ -43,29 +46,39 @@ namespace Serein.Library.NodeFlow.Tool
public async Task<TriggerData> CreateChannelWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime, TResult outValue) public async Task<TriggerData> CreateChannelWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime, TResult outValue)
{ {
var channel = GetOrCreateChannel(signal); var channel = GetOrCreateChannel(signal);
var cts = new CancellationTokenSource(); //var cts = new CancellationTokenSource();
//// 异步任务：超时后自动触发信号
// 异步任务：超时后自动触发信号 //_ = Task.Run(async () =>
_ = Task.Run(async () => //{
{ // try
try // {
{ // await Task.Delay(outTime, cts.Token);
await Task.Delay(outTime, cts.Token); // if(!cts.IsCancellationRequested) // 如果还没有被取消
TriggerData triggerData = new TriggerData() // {
{ // TriggerData triggerData = new TriggerData()
Value = outValue, // {
Type = TriggerType.Overtime, // Value = outValue,
}; // Type = TriggerType.Overtime,
await channel.Writer.WriteAsync(triggerData); // };
} // await channel.Writer.WriteAsync(triggerData);
catch (OperationCanceledException) // }
{ // }
// 超时任务被取消 // catch (OperationCanceledException)
} // {
}, cts.Token); // // 超时任务被取消
// }
// finally
// {
// cts?.Cancel();
// cts?.Dispose(); // 确保 cts 被释放
// }
//}, cts.Token);
// 等待信号传入（超时或手动触发） // 等待信号传入（超时或手动触发）
var result = await channel.Reader.ReadAsync(); var result = await channel.Reader.ReadAsync();
//cts?.Cancel();
//cts?.Dispose();
return result; return result;
} }

58
Library/Utils/SereinIoc.cs
View File

@@ -1,4 +1,5 @@
using Serein.Library.Api; using Newtonsoft.Json.Linq;
using Serein.Library.Api;
using Serein.Library.Attributes; using Serein.Library.Attributes;
using Serein.Library.Web; using Serein.Library.Web;
using System; using System;
@@ -6,6 +7,7 @@ using System.Collections.Concurrent;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
using System.Xml;
namespace Serein.Library.Utils namespace Serein.Library.Utils
{ {
@@ -88,8 +90,7 @@ namespace Serein.Library.Utils
public ISereinIOC Register<TService, TImplementation>(params object[] parameters) public ISereinIOC Register<TService, TImplementation>(params object[] parameters)
where TImplementation : TService where TImplementation : TService
{ {
var typeFullName = typeof(TService).FullName; RegisterType(typeof(TService).FullName, typeof(TImplementation));
RegisterType(typeFullName, typeof(TImplementation));
return this; return this;
} }
#endregion #endregion
@@ -140,6 +141,57 @@ namespace Serein.Library.Utils
return (T)GetOrRegisterInstantiate(typeof(T)); return (T)GetOrRegisterInstantiate(typeof(T));
} }
public void CustomRegisterInstance(string name,object instance, bool needInjectProperty = true)
{
// 不存在时才允许创建
if (!_dependencies.ContainsKey(name))
{
_dependencies.TryAdd(name, instance);
}
if (needInjectProperty)
{
InjectDependencies(instance); // 注入实例需要的依赖项
}
// 检查是否存在其它实例
if (_unfinishedDependencies.TryGetValue(name, out var unfinishedPropertyList))
{
foreach ((object obj, PropertyInfo property) in unfinishedPropertyList)
{
property.SetValue(obj, instance); //注入依赖项
}
if (_unfinishedDependencies.TryRemove(name, out unfinishedPropertyList))
{
unfinishedPropertyList.Clear();
}
}
}
public object Get(Type type)
{
return Get(type.FullName);
}
public T Get<T>(string name)
{
return (T)Get(name);
}
public object Get(string name)
{
object value;
if (!_dependencies.TryGetValue(name, out value))
{
value = null;
}
return value;
}
/// <summary> /// <summary>
/// 根据类型生成对应的实例，并注入其中的依赖项（类型信息不登记到IOC容器中）,类型创建后自动注入其它需要此类型的对象 /// 根据类型生成对应的实例，并注入其中的依赖项（类型信息不登记到IOC容器中）,类型创建后自动注入其它需要此类型的对象
/// </summary> /// </summary>

226
NodeFlow/Base/NodeModelBaseFunc.cs
View File

@@ -11,6 +11,7 @@ using System.Linq;
using System.Net.Http.Headers; using System.Net.Http.Headers;
using System.Text; using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
using System.Xml.Linq;
using static Serein.Library.Utils.ChannelFlowInterrupt; using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.NodeFlow.Base namespace Serein.NodeFlow.Base
@@ -35,6 +36,7 @@ namespace Serein.NodeFlow.Base
this.DebugSetting.InterruptClass = InterruptClass.Branch; this.DebugSetting.InterruptClass = InterruptClass.Branch;
this.DebugSetting.IsInterrupt = true; this.DebugSetting.IsInterrupt = true;
} }
/// <summary> /// <summary>
/// 不再中断 /// 不再中断
/// </summary> /// </summary>
@@ -90,22 +92,6 @@ namespace Serein.NodeFlow.Base
node.MethodDetails.ExplicitDatas[i].DataValue = pd.Value; node.MethodDetails.ExplicitDatas[i].DataValue = pd.Value;
} }
} }
//if (control is ConditionNodeControl conditionNodeControl)
//{
// conditionNodeControl.ViewModel.IsCustomData = pd.state;
// conditionNodeControl.ViewModel.CustomData = pd.value;
// conditionNodeControl.ViewModel.Expression = pd.expression;
//}
//else if (control is ExpOpNodeControl expOpNodeControl)
//{
// expOpNodeControl.ViewModel.Expression = pd.expression;
//}
//else
//{
// node.MethodDetails.ExplicitDatas[i].IsExplicitData = pd.state;
// node.MethodDetails.ExplicitDatas[i].DataValue = pd.value;
//}
return this; return this;
} }
@@ -120,101 +106,85 @@ namespace Serein.NodeFlow.Base
/// <returns></returns> /// <returns></returns>
public async Task StartExecute(IDynamicContext context) public async Task StartExecute(IDynamicContext context)
{ {
var cts = context.SereinIoc.GetOrRegisterInstantiate<CancellationTokenSource>(); CancellationTokenSource cts = null;
Stack<NodeModelBase> stack = new Stack<NodeModelBase>(); try
stack.Push(this);
while (stack.Count > 0 && !cts.IsCancellationRequested) // 循环中直到栈为空才会退出循环
{ {
// 从栈中弹出一个节点作为当前节点进行处理 cts = context.SereinIoc.Get<CancellationTokenSource>(FlowStarter.FlipFlopCtsName);
var currentNode = stack.Pop();
// 设置方法执行的对象
if (currentNode.MethodDetails?.ActingInstance == null && currentNode.MethodDetails?.ActingInstanceType is not null) Stack<NodeModelBase> stack = new Stack<NodeModelBase>();
stack.Push(this);
while (stack.Count > 0 && !cts.IsCancellationRequested) // 循环中直到栈为空才会退出循环
{ {
currentNode.MethodDetails.ActingInstance ??= context.SereinIoc.GetOrRegisterInstantiate(currentNode.MethodDetails.ActingInstanceType); // 从栈中弹出一个节点作为当前节点进行处理
} var currentNode = stack.Pop();
//if (TryCreateInterruptTask(context, currentNode, out Task<CancelType>? task)) // 设置方法执行的对象
//{ if (currentNode.MethodDetails?.ActingInstance == null && currentNode.MethodDetails?.ActingInstanceType is not null)
// var cancelType = await task!;
// await Console.Out.WriteLineAsync($"[{currentNode.MethodDetails.MethodName}]中断已{(cancelType == CancelType.Manual ? "手动取消" : "自动取消")}，开始执行后继分支");
//}
#region 执行相关
// 首先执行上游分支
var upstreamNodes = currentNode.SuccessorNodes[ConnectionType.Upstream];
for (int i = upstreamNodes.Count - 1; i >= 0; i--)
{
if (upstreamNodes[i].DebugSetting.IsEnable) // 排除未启用的上游节点
{ {
upstreamNodes[i].PreviousNode = currentNode; currentNode.MethodDetails.ActingInstance ??= context.SereinIoc.GetOrRegisterInstantiate(currentNode.MethodDetails.ActingInstanceType);
await upstreamNodes[i].StartExecute(context); // 执行流程节点的上游分支
} }
}
currentNode.FlowData = currentNode.ExecutingAsync(context); // 流程中正常执行 #region 执行相关
// 首先执行上游分支
// 判断是否为触发器节点，如果是，则开始等待。 #if false
//if (currentNode.MethodDetails != null && currentNode.MethodDetails.MethodDynamicType == NodeType.Flipflop) var upstreamNodes = currentNode.SuccessorNodes[ConnectionType.Upstream];
//{ for (int i = upstreamNodes.Count - 1; i >= 0; i--)
// currentNode.FlowData = await currentNode.ExecutingFlipflopAsync(context); // 流程中遇到了触发器
//}
//else
//{
//}
#endregion
#region 执行完成
if (currentNode.NextOrientation == ConnectionType.None) break; // 不再执行
// 选择后继分支
var nextNodes = currentNode.SuccessorNodes[currentNode.NextOrientation];
// 将下一个节点集合中的所有节点逆序推入栈中
for (int i = nextNodes.Count - 1; i >= 0; i--)
{
// 排除未启用的节点
if (nextNodes[i].DebugSetting.IsEnable)
{ {
nextNodes[i].PreviousNode = currentNode; if (upstreamNodes[i].DebugSetting.IsEnable) // 排除未启用的上游节点
stack.Push(nextNodes[i]); {
upstreamNodes[i].PreviousNode = currentNode;
await upstreamNodes[i].StartExecute(context); // 执行流程节点的上游分支
}
}
#endif
currentNode.FlowData = await currentNode.ExecutingAsync(context); // 流程中正常执行
#endregion
#region 执行完成
if (currentNode.NextOrientation == ConnectionType.None) break; // 不再执行
// 选择后继分支
var nextNodes = currentNode.SuccessorNodes[currentNode.NextOrientation];
// 将下一个节点集合中的所有节点逆序推入栈中
for (int i = nextNodes.Count - 1; i >= 0; i--)
{
// 排除未启用的节点
if (nextNodes[i].DebugSetting.IsEnable)
{
nextNodes[i].PreviousNode = currentNode;
stack.Push(nextNodes[i]);
}
} }
} #endregion
#endregion }
}
finally
{
cts?.Dispose();
} }
} }
public static bool TryCreateInterruptTask(IDynamicContext context, NodeModelBase currentNode, out Task<CancelType>? task) public static bool TryCreateInterruptTask(IDynamicContext context, NodeModelBase currentNode, out Task<CancelType>? task)
{ {
if (!currentNode.DebugSetting.IsInterrupt) bool haveTask;
{
task = null;
return false;
}
Task<CancelType>? result = null;
bool haveTask = false;
Console.WriteLine($"[{currentNode.MethodDetails.MethodName}]在当前分支中断"); Console.WriteLine($"[{currentNode.MethodDetails.MethodName}]在当前分支中断");
if (currentNode.DebugSetting.InterruptClass == InterruptClass.None) if (currentNode.DebugSetting.InterruptClass == InterruptClass.None)
{ {
haveTask = false; haveTask = false;
task = null; task = null;
currentNode.DebugSetting.IsInterrupt = false; // 纠正设置 currentNode.DebugSetting.IsInterrupt = false; // 纠正设置
} }
if (currentNode.DebugSetting.InterruptClass == InterruptClass.Branch) // 中断当前分支 else if (currentNode.DebugSetting.InterruptClass == InterruptClass.Branch) // 中断当前分支
{ {
currentNode.DebugSetting.IsInterrupt = true; currentNode.DebugSetting.IsInterrupt = true;
haveTask = true; haveTask = true;
task = context.FlowEnvironment.ChannelFlowInterrupt.CreateChannelWithTimeoutAsync(currentNode.Guid, TimeSpan.FromSeconds(1)); task = context.FlowEnvironment.ChannelFlowInterrupt.CreateChannelWithTimeoutAsync(currentNode.Guid, TimeSpan.FromSeconds(60 * 30)); // 中断30分钟
currentNode.CancelInterruptCallback ??= () => context.FlowEnvironment.ChannelFlowInterrupt.TriggerSignal(currentNode.Guid);
} }
else else
{ {
@@ -233,16 +203,19 @@ namespace Serein.NodeFlow.Base
public virtual async Task<object?> ExecutingAsync(IDynamicContext context) public virtual async Task<object?> ExecutingAsync(IDynamicContext context)
{ {
#region 调试中断 #region 调试中断
if (TryCreateInterruptTask(context, this, out Task<CancelType>? task)) if (DebugSetting.IsInterrupt && TryCreateInterruptTask(context, this, out Task<CancelType>? task)) // 执行节点前检查中断
{ {
string guid = this.Guid.ToString();
this.CancelInterruptCallback ??= () => context.FlowEnvironment.ChannelFlowInterrupt.TriggerSignal(guid);
var cancelType = await task!; var cancelType = await task!;
task?.ToString();
await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已{(cancelType == CancelType.Manual ? "手动取消" : "自动取消")}，开始执行后继分支"); await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已{(cancelType == CancelType.Manual ? "手动取消" : "自动取消")}，开始执行后继分支");
} }
#endregion #endregion
MethodDetails md = MethodDetails; MethodDetails md = MethodDetails;
var del = md.MethodDelegate; var del = md.MethodDelegate.Clone();
object instance = md.ActingInstance; object instance = md.ActingInstance;
var haveParameter = md.ExplicitDatas.Length > 0; var haveParameter = md.ExplicitDatas.Length > 0;
@@ -250,13 +223,42 @@ namespace Serein.NodeFlow.Base
try try
{ {
// Action/Func([方法作用的实例],[可能的参数值],[可能的返回值]) // Action/Func([方法作用的实例],[可能的参数值],[可能的返回值])
object?[]? parameters = GetParameters(context, md);
object? result = (haveParameter, haveResult) switch object? result = (haveParameter, haveResult) switch
{ {
(false, false) => Execution((Action<object>)del, instance), // 调用节点方法，返回null (false, false) => Execution((Action<object>)del, instance), // 调用节点方法，返回null
(true, false) => Execution((Action<object, object?[]?>)del, instance, GetParameters(context, md)), // 调用节点方法，返回null (true, false) => Execution((Action<object, object?[]?>)del, instance, parameters), // 调用节点方法，返回null
(false, true) => Execution((Func<object, object?>)del, instance), // 调用节点方法，返回方法传回类型 (false, true) => Execution((Func<object, object?>)del, instance), // 调用节点方法，返回方法传回类型
(true, true) => Execution((Func<object, object?[]?, object?>)del, instance, GetParameters(context, md)), // 调用节点方法，获取入参参数，返回方法忏悔类型 (true, true) => Execution((Func<object, object?[]?, object?>)del, instance, parameters), // 调用节点方法，获取入参参数，返回方法忏悔类型
}; };
//object?[]? parameters;
//object? result = null;
//if ( haveParameter )
//{
// var data = GetParameters(context, md);
// if (data[0] is Int32 count && count > 1)
// {
// }
// parameters = [instance, data];
//}
//else
//{
// parameters = [instance];
//}
//if (haveResult)
//{
// result = del.DynamicInvoke(parameters);
//}
//else
//{
// del.DynamicInvoke(parameters);
//}
NextOrientation = ConnectionType.IsSucceed; NextOrientation = ConnectionType.IsSucceed;
return result; return result;
} }
@@ -307,7 +309,7 @@ namespace Serein.NodeFlow.Base
// 用正确的大小初始化参数数组 // 用正确的大小初始化参数数组
if (md.ExplicitDatas.Length == 0) if (md.ExplicitDatas.Length == 0)
{ {
return [];// md.ActingInstance return null;// md.ActingInstance
} }
object?[]? parameters = new object[md.ExplicitDatas.Length]; object?[]? parameters = new object[md.ExplicitDatas.Length];
@@ -344,7 +346,7 @@ namespace Serein.NodeFlow.Base
{ {
parameters[i] = ed.DataType switch parameters[i] = ed.DataType switch
{ {
Type t when t == previousDataType => context, // 上下文 //Type t when t == previousDataType => inputParameter, // 上下文
Type t when t == typeof(IDynamicContext) => context, // 上下文 Type t when t == typeof(IDynamicContext) => context, // 上下文
Type t when t == typeof(MethodDetails) => md, // 节点方法描述 Type t when t == typeof(MethodDetails) => md, // 节点方法描述
Type t when t == typeof(NodeModelBase) => this, // 节点实体类 Type t when t == typeof(NodeModelBase) => this, // 节点实体类
@@ -387,45 +389,5 @@ namespace Serein.NodeFlow.Base
#endregion #endregion
/// <summary>
/// json文本反序列化为对象
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <returns></returns>
private dynamic? ConvertValue(string value, Type targetType)
{
try
{
if (!string.IsNullOrEmpty(value))
{
return JsonConvert.DeserializeObject(value, targetType);
}
else
{
return null;
}
}
catch (JsonReaderException ex)
{
Console.WriteLine(ex);
return value;
}
catch (JsonSerializationException ex)
{
// 如果无法转为对应的JSON对象
int startIndex = ex.Message.IndexOf("to type '") + "to type '".Length; // 查找类型信息开始的索引
int endIndex = ex.Message.IndexOf('\''); // 查找类型信息结束的索引
var typeInfo = ex.Message[startIndex..endIndex]; // 提取出错类型信息，该怎么传出去？
Console.WriteLine("无法转为对应的JSON对象:" + typeInfo);
return null;
}
catch // (Exception ex)
{
return value;
}
}
} }
} }

16
NodeFlow/FlowEnvironment.cs
View File

@@ -9,6 +9,7 @@ using Serein.NodeFlow.Model;
using Serein.NodeFlow.Tool; using Serein.NodeFlow.Tool;
using System.Collections.Concurrent; using System.Collections.Concurrent;
using System.Reflection; using System.Reflection;
using System.Xml.Linq;
using static Serein.NodeFlow.FlowStarter; using static Serein.NodeFlow.FlowStarter;
namespace Serein.NodeFlow namespace Serein.NodeFlow
@@ -196,9 +197,20 @@ namespace Serein.NodeFlow
} }
public void Exit() public void Exit()
{ {
foreach (var node in Nodes.Values)
{
if (typeof(IDisposable).IsAssignableFrom(node?.FlowData?.GetType()) && node.FlowData is IDisposable disposable)
{
disposable?.Dispose();
}
node!.FlowData = null;
}
ChannelFlowInterrupt?.CancelAllTasks(); ChannelFlowInterrupt?.CancelAllTasks();
flowStarter?.Exit(); flowStarter?.Exit();
OnFlowRunComplete?.Invoke(new FlowEventArgs()); OnFlowRunComplete?.Invoke(new FlowEventArgs());
GC.Collect();
} }
/// <summary> /// <summary>
@@ -452,7 +464,9 @@ namespace Serein.NodeFlow
for (int i = 0; i < pnc.Value.Count; i++) for (int i = 0; i < pnc.Value.Count; i++)
{ {
NodeModelBase? pNode = pnc.Value[i]; NodeModelBase? pNode = pnc.Value[i];
pNode.SuccessorNodes[pCType].RemoveAt(i); //pNode.SuccessorNodes[pCType].RemoveAt(i);
pNode.SuccessorNodes[pCType].Remove(pNode);
OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(pNode.Guid, OnNodeConnectChange?.Invoke(new NodeConnectChangeEventArgs(pNode.Guid,
remoteNode.Guid, remoteNode.Guid,
pCType, pCType,

205
NodeFlow/FlowStarter.cs
View File

@@ -7,6 +7,7 @@ using Serein.Library.Web;
using Serein.NodeFlow.Base; using Serein.NodeFlow.Base;
using Serein.NodeFlow.Model; using Serein.NodeFlow.Model;
using System.ComponentModel.Design; using System.ComponentModel.Design;
using System.Runtime.CompilerServices;
using static Serein.Library.Utils.ChannelFlowInterrupt; using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.NodeFlow namespace Serein.NodeFlow
@@ -43,10 +44,12 @@ namespace Serein.NodeFlow
Completion, Completion,
} }
/// <summary> /// <summary>
/// 控制触发器的结束 /// 控制触发器
/// </summary> /// </summary>
private NodeRunCts FlipFlopCts { get; set; } = null;
public const string FlipFlopCtsName = "<>.FlowFlipFlopCts";
public bool IsStopStart = false;
/// <summary> /// <summary>
/// 运行状态 /// 运行状态
/// </summary> /// </summary>
@@ -68,6 +71,16 @@ namespace Serein.NodeFlow
/// </summary> /// </summary>
private IDynamicContext Context { get; set; } = null; private IDynamicContext Context { get; set; } = null;
private void CheckStartState()
{
if (IsStopStart)
{
throw new Exception("停止启动");
}
}
/// <summary> /// <summary>
/// 开始运行 /// 开始运行
/// </summary> /// </summary>
@@ -95,14 +108,14 @@ namespace Serein.NodeFlow
#region 选择运行环境的上下文 #region 选择运行环境的上下文
// 判断使用哪一种流程上下文 // 判断使用哪一种流程上下文
var isNetFramework = true; var isNetFramework = false;
if (isNetFramework) if (isNetFramework)
{ {
Context = new Serein.Library.Framework.NodeFlow.DynamicContext(SereinIOC, env); Context = new Serein.Library.Framework.NodeFlow.DynamicContext(SereinIOC, env);
} }
else else
{ {
Context = new Serein.Library.Core.NodeFlow.DynamicContext(SereinIOC, env); Context = new Serein.Library.Core.NodeFlow.DynamicContext(SereinIOC, env); // 从起始节点启动流程时创建上下文
} }
#endregion #endregion
@@ -119,24 +132,36 @@ namespace Serein.NodeFlow
{ {
nodeMd.ActingInstance = null; nodeMd.ActingInstance = null;
} }
SereinIOC.Reset(); // 开始运行时清空ioc中注册的实例 SereinIOC.Reset(); // 开始运行时清空ioc中注册的实例
// 初始化ioc容器中的类型对象 // 初始化ioc容器中的类型对象
foreach (var md in thisRuningMds) foreach (var md in thisRuningMds)
{ {
if(md.ActingInstanceType != null) if (md.ActingInstanceType != null)
{ {
SereinIOC.Register(md.ActingInstanceType); SereinIOC.Register(md.ActingInstanceType);
} }
} else
SereinIOC.Build(); // 流程启动前的初始化
foreach (var md in thisRuningMds)
{
if (md.ActingInstanceType != null)
{ {
md.ActingInstance = SereinIOC.GetOrRegisterInstantiate(md.ActingInstanceType); await Console.Out.WriteLineAsync($"{md.MethodName} - 没有类型声明");
IsStopStart = true;
} }
} }
CheckStartState();
SereinIOC.Build(); // 流程启动前的初始化
foreach (var md in thisRuningMds)
{
md.ActingInstance = SereinIOC.GetOrRegisterInstantiate(md.ActingInstanceType);
if(md.ActingInstance is null)
{
await Console.Out.WriteLineAsync($"{md.MethodName} - 无法获取类型[{md.ActingInstanceType}]的实例");
IsStopStart = true;
}
}
CheckStartState();
//foreach (var md in flipflopNodes.Select(it => it.MethodDetails).ToArray()) //foreach (var md in flipflopNodes.Select(it => it.MethodDetails).ToArray())
//{ //{
@@ -144,34 +169,34 @@ namespace Serein.NodeFlow
//} //}
#endregion #endregion
#region 检查并修正初始化、加载时、退出时方法作用的对象，保证后续不会报错 #region 检查并修正初始化、加载时、退出时方法作用的对象，保证后续不会报错（已注释）
foreach (var md in initMethods) // 初始化 //foreach (var md in initMethods) // 初始化
{ //{
md.ActingInstance ??= Context.SereinIoc.GetOrRegisterInstantiate(md.ActingInstanceType); // md.ActingInstance ??= Context.SereinIoc.GetOrRegisterInstantiate(md.ActingInstanceType);
} //}
foreach (var md in loadingMethods) // 加载 //foreach (var md in loadingMethods) // 加载
{ //{
md.ActingInstance ??= Context.SereinIoc.GetOrRegisterInstantiate(md.ActingInstanceType); // md.ActingInstance ??= Context.SereinIoc.GetOrRegisterInstantiate(md.ActingInstanceType);
} //}
foreach (var md in exitMethods) // 初始化 //foreach (var md in exitMethods) // 初始化
{ //{
md.ActingInstance ??= Context.SereinIoc.GetOrRegisterInstantiate(md.ActingInstanceType); // md.ActingInstance ??= Context.SereinIoc.GetOrRegisterInstantiate(md.ActingInstanceType);
} //}
#endregion #endregion
#region 执行初始化，绑定IOC容器，再执行加载时 #region 执行初始化，绑定IOC容器，再执行加载时
object?[]? args = [Context]; //object?[]? args = [Context];
foreach (var md in initMethods) // 初始化 foreach (var md in initMethods) // 初始化
{ {
object?[]? data = [md.ActingInstance, args]; ((Action<object, object?[]?>)md.MethodDelegate).Invoke(md.ActingInstance, [Context]);
md.MethodDelegate.DynamicInvoke(data);
} }
Context.SereinIoc.Build(); // 绑定初始化时注册的类型 Context.SereinIoc.Build(); // 绑定初始化时注册的类型
foreach (var md in loadingMethods) // 加载 foreach (var md in loadingMethods) // 加载
{ {
object?[]? data = [md.ActingInstance, args]; //object?[]? data = [md.ActingInstance, args];
md.MethodDelegate.DynamicInvoke(data); //md.MethodDelegate.DynamicInvoke(data);
((Action<object, object?[]?>)md.MethodDelegate).Invoke(md.ActingInstance, [Context]);
} }
Context.SereinIoc.Build(); // 预防有人在加载时才注册类型，再绑定一次 Context.SereinIoc.Build(); // 预防有人在加载时才注册类型，再绑定一次
#endregion #endregion
@@ -179,38 +204,43 @@ namespace Serein.NodeFlow
#region 设置流程退出时的回调函数 #region 设置流程退出时的回调函数
ExitAction = () => ExitAction = () =>
{ {
SereinIOC.Run<WebServer>(web => { SereinIOC.Run<WebServer>(web => {
web?.Stop(); web?.Stop();
}); });
foreach (MethodDetails? md in exitMethods) foreach (MethodDetails? md in exitMethods)
{ {
object?[]? data = [md.ActingInstance, args]; ((Action<object, object?[]?>)md.MethodDelegate).Invoke(md.ActingInstance, [Context]);
md.MethodDelegate.DynamicInvoke(data);
}
if (Context != null && Context.NodeRunCts != null && !Context.NodeRunCts.IsCancellationRequested)
{
Context.NodeRunCts.Cancel();
}
if (FlipFlopCts != null && !FlipFlopCts.IsCancellationRequested)
{
FlipFlopCts.Cancel();
} }
//if (Context != null && Context.NodeRunCts != null && !Context.NodeRunCts.IsCancellationRequested)
//{
// Context.NodeRunCts.Cancel();
//}
//if (FlipFlopCts != null && !FlipFlopCts.IsCancellationRequested)
//{
// FlipFlopCts?.Cancel();
// FlipFlopCts?.Dispose();
//}
FlowState = RunState.Completion; FlowState = RunState.Completion;
FlipFlopState = RunState.Completion; FlipFlopState = RunState.Completion;
}; };
#endregion #endregion
#region 开始启动流程 #region 开始启动流程
CancellationTokenSource FlipFlopCts = null;
try try
{ {
if (flipflopNodes.Count > 0) if (flipflopNodes.Count > 0)
{ {
FlipFlopState = RunState.Running; FlipFlopState = RunState.Running;
// 如果存在需要启动的触发器，则开始启动 // 如果存在需要启动的触发器，则开始启动
FlipFlopCts = SereinIOC.GetOrRegisterInstantiate<NodeRunCts>(); FlipFlopCts = new CancellationTokenSource();
SereinIOC.CustomRegisterInstance(FlipFlopCtsName, FlipFlopCts,false);
// 使用 TaskCompletionSource 创建未启动的触发器任务 // 使用 TaskCompletionSource 创建未启动的触发器任务
var tasks = flipflopNodes.Select(async node => var tasks = flipflopNodes.Select(async node =>
{ {
@@ -220,18 +250,25 @@ namespace Serein.NodeFlow
} }
await startNode.StartExecute(Context); // 开始运行时从起始节点开始运行 await startNode.StartExecute(Context); // 开始运行时从起始节点开始运行
// 等待结束 // 等待结束
if (FlipFlopCts != null) if(FlipFlopState == RunState.Running && FlipFlopCts is not null)
{ {
while (!FlipFlopCts.IsCancellationRequested) while (!FlipFlopCts.IsCancellationRequested)
{ {
await Task.Delay(100); await Task.Delay(100);
} }
} }
//FlipFlopCts?.Dispose();
} }
catch (Exception ex) catch (Exception ex)
{ {
await Console.Out.WriteLineAsync(ex.ToString()); await Console.Out.WriteLineAsync(ex.ToString());
} }
finally
{
FlipFlopCts?.Dispose();
FlowState = RunState.Completion;
}
#endregion #endregion
} }
@@ -253,36 +290,70 @@ namespace Serein.NodeFlow
/// <returns></returns> /// <returns></returns>
private async Task FlipflopExecute(IFlowEnvironment flowEnvironment,SingleFlipflopNode singleFlipFlopNode) private async Task FlipflopExecute(IFlowEnvironment flowEnvironment,SingleFlipflopNode singleFlipFlopNode)
{ {
var context = new DynamicContext(SereinIOC, flowEnvironment); CancellationTokenSource cts = null;
var context = new DynamicContext(SereinIOC, flowEnvironment); // 启动全局触发器时新建上下文
MethodDetails md = singleFlipFlopNode.MethodDetails; MethodDetails md = singleFlipFlopNode.MethodDetails;
var del = md.MethodDelegate; var del = md.MethodDelegate;
// 设置方法执行的对象
if (md?.ActingInstance == null && md?.ActingInstanceType is not null)
{
md.ActingInstance ??= context.SereinIoc.GetOrRegisterInstantiate(md.ActingInstanceType);
}
object?[]? parameters = singleFlipFlopNode.GetParameters(context, singleFlipFlopNode.MethodDetails); // 启动全局触发器时获取入参参数 object?[]? parameters = singleFlipFlopNode.GetParameters(context, singleFlipFlopNode.MethodDetails); // 启动全局触发器时获取入参参数
// 设置委托对象 // 设置委托对象
var func = md.ExplicitDatas.Length == 0 ? var func = md.ExplicitDatas.Length == 0 ?
(Func<object, object, Task<IFlipflopContext>>)del : (Func<object, object, Task<IFlipflopContext>>)del :
(Func<object, object[], Task<IFlipflopContext>>)del; (Func<object, object[], Task<IFlipflopContext>>)del;
bool t = md.ExplicitDatas.Length == 0;
try try
{ {
while (!FlipFlopCts.IsCancellationRequested)
cts = Context.SereinIoc.Get<CancellationTokenSource>(FlipFlopCtsName);
while (!cts.IsCancellationRequested)
{ {
IFlipflopContext flipflopContext = await func.Invoke(md.ActingInstance, parameters);// 开始等待全局触发器的触发
var connectionType = flipflopContext.State.ToContentType(); singleFlipFlopNode.FlowData = await singleFlipFlopNode.ExecutingAsync(context);
if (connectionType != ConnectionType.None) if (singleFlipFlopNode.NextOrientation != ConnectionType.None)
{ {
await GlobalFlipflopExecute(context, singleFlipFlopNode, connectionType); var nextNodes = singleFlipFlopNode.SuccessorNodes[singleFlipFlopNode.NextOrientation];
for (int i = nextNodes.Count - 1; i >= 0; i--)
{
if (nextNodes[i].DebugSetting.IsEnable) // 排除未启用的后继节点
{
nextNodes[i].PreviousNode = singleFlipFlopNode;
await nextNodes[i].StartExecute(context); // 执行流程节点的后继分支
}
}
} }
//if(t)
//{
// IFlipflopContext flipflopContext = await ((Func<object, Task<IFlipflopContext>>)del.Clone()).Invoke(md.ActingInstance);// 开始等待全局触发器的触发
// var connectionType = flipflopContext.State.ToContentType();
// if (connectionType != ConnectionType.None)
// {
// await GlobalFlipflopExecute(context, singleFlipFlopNode, connectionType, cts);
// }
//}
//else
//{
// IFlipflopContext flipflopContext = await ((Func<object, object[], Task<IFlipflopContext>>)del.Clone()).Invoke(md.ActingInstance, parameters);// 开始等待全局触发器的触发
// var connectionType = flipflopContext.State.ToContentType();
// if (connectionType != ConnectionType.None)
// {
// await GlobalFlipflopExecute(context, singleFlipFlopNode, connectionType, cts);
// }
//}
} }
} }
catch (Exception ex) catch (Exception ex)
{ {
await Console.Out.WriteLineAsync(ex.ToString()); await Console.Out.WriteLineAsync(ex.ToString());
} }
finally
{
cts?.Cancel();
}
} }
/// <summary> /// <summary>
@@ -292,15 +363,12 @@ namespace Serein.NodeFlow
/// <param name="singleFlipFlopNode">被触发的全局触发器</param> /// <param name="singleFlipFlopNode">被触发的全局触发器</param>
/// <param name="connectionType">分支类型</param> /// <param name="connectionType">分支类型</param>
/// <returns></returns> /// <returns></returns>
public async Task GlobalFlipflopExecute(IDynamicContext context, SingleFlipflopNode singleFlipFlopNode, ConnectionType connectionType) public async Task GlobalFlipflopExecute(IDynamicContext context, SingleFlipflopNode singleFlipFlopNode,
ConnectionType connectionType, CancellationTokenSource cts)
{ {
if (FlipFlopCts.IsCancellationRequested )
{
return;
}
bool skip = true; bool skip = true;
var cts = context.SereinIoc.GetOrRegisterInstantiate<CancellationTokenSource>();
Stack<NodeModelBase> stack = new Stack<NodeModelBase>(); Stack<NodeModelBase> stack = new Stack<NodeModelBase>();
stack.Push(singleFlipFlopNode); stack.Push(singleFlipFlopNode);
@@ -311,10 +379,10 @@ namespace Serein.NodeFlow
var currentNode = stack.Pop(); var currentNode = stack.Pop();
// 设置方法执行的对象 // 设置方法执行的对象
if (currentNode.MethodDetails?.ActingInstance == null && currentNode.MethodDetails?.ActingInstanceType is not null) //if (currentNode.MethodDetails?.ActingInstance == null && currentNode.MethodDetails?.ActingInstanceType is not null)
{ //{
currentNode.MethodDetails.ActingInstance ??= context.SereinIoc.GetOrRegisterInstantiate(currentNode.MethodDetails.ActingInstanceType); // currentNode.MethodDetails.ActingInstance ??= context.SereinIoc.GetOrRegisterInstantiate(currentNode.MethodDetails.ActingInstanceType);
} //}
// 首先执行上游分支 // 首先执行上游分支
var upstreamNodes = currentNode.SuccessorNodes[ConnectionType.Upstream]; var upstreamNodes = currentNode.SuccessorNodes[ConnectionType.Upstream];
@@ -331,7 +399,8 @@ namespace Serein.NodeFlow
} }
else else
{ {
currentNode.FlowData = await currentNode.ExecutingAsync(context); currentNode.FlowData = await currentNode.ExecutingAsync(context);
if (currentNode.NextOrientation == ConnectionType.None) if (currentNode.NextOrientation == ConnectionType.None)
{ {

12
NodeFlow/Model/SingleActionNode.cs
View File

@@ -15,12 +15,12 @@ namespace Serein.NodeFlow.Model
if (base.MethodDetails.ExplicitDatas.Length > 0) if (base.MethodDetails.ExplicitDatas.Length > 0)
{ {
return MethodDetails.ExplicitDatas return MethodDetails.ExplicitDatas
.Select(it => new Parameterdata .Select(it => new Parameterdata
{ {
State = it.IsExplicitData, State = it.IsExplicitData,
Value = it.DataValue, Value = it.DataValue,
}) })
.ToArray(); .ToArray();
} }
else else
{ {

40
NodeFlow/Model/SingleFlipflopNode.cs
View File

@@ -22,31 +22,49 @@ namespace Serein.NodeFlow.Model
public override async Task<object?> ExecutingAsync(IDynamicContext context) public override async Task<object?> ExecutingAsync(IDynamicContext context)
{ {
#region 执行前中断 #region 执行前中断
if (TryCreateInterruptTask(context, this, out Task<CancelType>? task)) if (DebugSetting.IsInterrupt && TryCreateInterruptTask(context, this, out Task<CancelType>? task)) // 执行触发前
{ {
string guid = this.Guid.ToString();
this.CancelInterruptCallback ??= () => context.FlowEnvironment.ChannelFlowInterrupt.TriggerSignal(guid);
var cancelType = await task!; var cancelType = await task!;
task?.ToString();
await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已{(cancelType == CancelType.Manual ? "手动取消" : "自动取消")}，开始执行后继分支"); await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已{(cancelType == CancelType.Manual ? "手动取消" : "自动取消")}，开始执行后继分支");
} }
#endregion #endregion
MethodDetails md = MethodDetails; MethodDetails md = MethodDetails;
Delegate del = md.MethodDelegate; var del = md.MethodDelegate.Clone();
object instance = md.ActingInstance; object instance = md.ActingInstance;
var haveParameter = md.ExplicitDatas.Length >= 0; // Task<IFlipflopContext>? flipflopTask = null;
try try
{ {
// 调用委托并获取结果 // 调用委托并获取结果
Task<IFlipflopContext> flipflopTask = haveParameter switch Task<IFlipflopContext> flipflopTask = md.ExplicitDatas.Length switch
{ {
true => ((Func<object, object?[]?, Task<IFlipflopContext>>)del).Invoke(instance, GetParameters(context, md)), // 执行流程中的触发器方法时获取入参参数 0 => ((Func<object, Task<IFlipflopContext>>)del).Invoke(md.ActingInstance),
false => ((Func<object, Task<IFlipflopContext>>)del).Invoke(instance), _ => ((Func<object, object?[]?, Task<IFlipflopContext>>)del).Invoke(md.ActingInstance, GetParameters(context, md)), // 执行流程中的触发器方法时获取入参参数
}; };
//object?[]? parameters;
//object? result = null;
//if (haveParameter)
//{
// var data = GetParameters(context, md);
// parameters = [instance, data];
//}
//else
//{
// parameters = [instance];
//}
//flipflopTask = del.DynamicInvoke(parameters) as Task<IFlipflopContext>;
//if (flipflopTask == null)
//{
// throw new FlipflopException(base.MethodDetails.MethodName + "触发器返回值非 Task<IFlipflopContext> 类型");
//}
IFlipflopContext flipflopContext = (await flipflopTask) ?? throw new FlipflopException("没有返回上下文"); IFlipflopContext flipflopContext = (await flipflopTask) ?? throw new FlipflopException("没有返回上下文");
NextOrientation = flipflopContext.State.ToContentType(); NextOrientation = flipflopContext.State.ToContentType();
if(flipflopContext.TriggerData.Type == Library.NodeFlow.Tool.TriggerType.Overtime) if(flipflopContext.TriggerData is null || flipflopContext.TriggerData.Type == Library.NodeFlow.Tool.TriggerType.Overtime)
{ {
throw new FlipflopException(""); throw new FlipflopException(base.MethodDetails.MethodName + "触发器超时触发。Guid"+base.Guid);
} }
return flipflopContext.TriggerData.Value; return flipflopContext.TriggerData.Value;
} }
@@ -62,6 +80,10 @@ namespace Serein.NodeFlow.Model
RuningException = ex; RuningException = ex;
return null; return null;
} }
finally
{
// flipflopTask?.Dispose();
}
} }
internal override Parameterdata[] GetParameterdatas() internal override Parameterdata[] GetParameterdatas()

100
WorkBench/LogWindow.xaml.cs
View File

@@ -5,21 +5,102 @@ namespace Serein.WorkBench
/// <summary> /// <summary>
/// DebugWindow.xaml 的交互逻辑 /// DebugWindow.xaml 的交互逻辑
/// </summary> /// </summary>
using System;
using System.Text;
using System.Threading.Tasks;
using System.Timers;
using System.Windows;
public partial class LogWindow : Window public partial class LogWindow : Window
{ {
private StringBuilder logBuffer = new StringBuilder();
private int logUpdateInterval = 100; // 批量更新的时间间隔（毫秒）
private Timer logUpdateTimer;
private const int MaxLines = 1000; // 最大显示的行数
private bool autoScroll = true; // 自动滚动标识
public LogWindow() public LogWindow()
{ {
InitializeComponent(); InitializeComponent();
// 初始化定时器，用于批量更新日志
logUpdateTimer = new Timer(logUpdateInterval);
logUpdateTimer.Elapsed += (s, e) => FlushLog(); // 定时刷新日志
logUpdateTimer.Start();
// 添加滚动事件处理，判断用户是否手动滚动
// LogTextBox.ScrollChanged += LogTextBox_ScrollChanged;
} }
/// <summary>
/// 添加日志到缓冲区
/// </summary>
public void AppendText(string text) public void AppendText(string text)
{ {
Dispatcher.BeginInvoke(() => lock (logBuffer)
{ {
LogTextBox.AppendText(text); logBuffer.Append(text); // 将日志添加到缓冲区中
LogTextBox.ScrollToEnd(); }
}
/// <summary>
/// 清空日志缓冲区并更新到 TextBox 中
/// </summary>
private void FlushLog()
{
if (logBuffer.Length == 0) return;
Dispatcher.Invoke(() =>
{
lock (logBuffer)
{
LogTextBox.AppendText(logBuffer.ToString());
logBuffer.Clear(); // 清空缓冲区
}
TrimLog(); // 检查并修剪日志长度
ScrollToEndIfNeeded(); // 根据条件滚动到末尾
}); });
} }
/// <summary>
/// 限制日志输出的最大行数，超出时删除旧日志
/// </summary>
private void TrimLog()
{
if (LogTextBox.LineCount > MaxLines)
{
// 删除最早的多余行
LogTextBox.Text = LogTextBox.Text.Substring(LogTextBox.GetCharacterIndexFromLineIndex(LogTextBox.LineCount - MaxLines));
}
}
/// <summary>
/// 检测用户是否手动滚动了文本框
/// </summary>
private void LogTextBox_ScrollChanged(object sender, System.Windows.Controls.ScrollChangedEventArgs e)
{
if (e.ExtentHeightChange == 0) // 用户手动滚动时
{
// 判断是否滚动到底部
// autoScroll = LogTextBox.VerticalOffset == LogTextBox.ScrollableHeight;
}
}
/// <summary>
/// 根据 autoScroll 标志决定是否滚动到末尾
/// </summary>
private void ScrollToEndIfNeeded()
{
if (autoScroll)
{
LogTextBox.ScrollToEnd(); // 仅在需要时滚动到末尾
}
}
/// <summary>
/// 清空日志
/// </summary>
public void Clear() public void Clear()
{ {
Dispatcher.BeginInvoke(() => Dispatcher.BeginInvoke(() =>
@@ -27,15 +108,28 @@ namespace Serein.WorkBench
LogTextBox.Clear(); LogTextBox.Clear();
}); });
} }
/// <summary>
/// 点击清空日志按钮时触发
/// </summary>
private void ClearLog_Click(object sender, RoutedEventArgs e) private void ClearLog_Click(object sender, RoutedEventArgs e)
{ {
LogTextBox.Clear(); LogTextBox.Clear();
} }
/// <summary>
/// 窗口关闭事件，隐藏窗体而不是关闭
/// </summary>
private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e) private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{ {
//logUpdateTimer?.Stop();
//logUpdateTimer?.Close();
//logUpdateTimer?.Dispose();
logBuffer?.Clear();
Clear();
e.Cancel = true; // 取消关闭操作 e.Cancel = true; // 取消关闭操作
this.Hide(); // 隐藏窗体而不是关闭 this.Hide(); // 隐藏窗体而不是关闭
} }
} }
} }

123
WorkBench/MainWindow.xaml.cs
View File

@@ -87,6 +87,7 @@ namespace Serein.WorkBench
/// 标记是否正在拖动画布 /// 标记是否正在拖动画布
/// </summary> /// </summary>
private bool IsCanvasDragging; private bool IsCanvasDragging;
private bool IsSelectDragging;
/// <summary> /// <summary>
/// 当前选取的控件 /// 当前选取的控件
@@ -823,8 +824,9 @@ namespace Serein.WorkBench
} }
} }
if (IsSelectControl /*&& e.LeftButton == MouseButtonState.Pressed*/) // 正在选取节点 if (IsSelectControl) // 正在选取节点
{ {
IsSelectDragging = e.LeftButton == MouseButtonState.Pressed;
// 获取当前鼠标位置 // 获取当前鼠标位置
Point currentPoint = e.GetPosition(FlowChartCanvas); Point currentPoint = e.GetPosition(FlowChartCanvas);
@@ -1407,6 +1409,36 @@ namespace Serein.WorkBench
/// <param name="e"></param> /// <param name="e"></param>
private void FlowChartCanvas_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) private void FlowChartCanvas_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{ {
if (!IsSelectControl)
{
// 进入选取状态
IsSelectControl = true;
IsSelectDragging = false; // 初始化为非拖动状态
// 记录鼠标起始点
startSelectControolPoint = e.GetPosition(FlowChartCanvas);
// 初始化选取矩形的位置和大小
Canvas.SetLeft(SelectionRectangle, startSelectControolPoint.X);
Canvas.SetTop(SelectionRectangle, startSelectControolPoint.Y);
SelectionRectangle.Width = 0;
SelectionRectangle.Height = 0;
// 显示选取矩形
SelectionRectangle.Visibility = Visibility.Visible;
SelectionRectangle.ContextMenu ??= ConfiguerSelectionRectangle();
// 捕获鼠标，以便在鼠标移动到Canvas外部时仍能处理事件
FlowChartCanvas.CaptureMouse();
}
else
{
// 如果已经是选取状态，单击则认为结束框选
CompleteSelection();
}
e.Handled = true; // 防止事件传播影响其他控件
return;
// 如果正在选取状态，再次点击画布时自动确定选取范围，否则进入选取状态 // 如果正在选取状态，再次点击画布时自动确定选取范围，否则进入选取状态
if (IsSelectControl) if (IsSelectControl)
{ {
@@ -1467,14 +1499,71 @@ namespace Serein.WorkBench
} }
/// <summary>
/// 在画布中释放鼠标按下，结束选取状态
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FlowChartCanvas_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
if (IsSelectControl)
{
// 松开鼠标时判断是否为拖动操作
if (IsSelectDragging)
{
// 完成拖动框选
CompleteSelection();
}
// 释放鼠标捕获
FlowChartCanvas.ReleaseMouseCapture();
}
e.Handled = true;
}
/// 完成选取操作
/// </summary>
private void CompleteSelection()
{
IsSelectControl = false;
// 隐藏选取矩形
SelectionRectangle.Visibility = Visibility.Collapsed;
// 获取选取范围
Rect selectionArea = new Rect(Canvas.GetLeft(SelectionRectangle),
Canvas.GetTop(SelectionRectangle),
SelectionRectangle.Width,
SelectionRectangle.Height);
// 处理选取范围内的控件
// selectNodeControls.Clear();
foreach (UIElement element in FlowChartCanvas.Children)
{
Rect elementBounds = new Rect(Canvas.GetLeft(element), Canvas.GetTop(element),
element.RenderSize.Width, element.RenderSize.Height);
if (selectionArea.Contains(elementBounds))
{
if (element is NodeControlBase control)
{
selectNodeControls.Add(control);
}
}
}
// 选中后的操作
SelectedNode();
}
private ContextMenu ConfiguerSelectionRectangle() private ContextMenu ConfiguerSelectionRectangle()
{ {
var contextMenu = new ContextMenu(); var contextMenu = new ContextMenu();
contextMenu.Items.Add(CreateMenuItem("删除", (s, e) => contextMenu.Items.Add(CreateMenuItem("删除", (s, e) =>
{ {
if(selectNodeControls.Count > 0) if (selectNodeControls.Count > 0)
{ {
foreach(var node in selectNodeControls.ToArray()) foreach (var node in selectNodeControls.ToArray())
{ {
var guid = node?.ViewModel?.Node?.Guid; var guid = node?.ViewModel?.Node?.Guid;
if (!string.IsNullOrEmpty(guid)) if (!string.IsNullOrEmpty(guid))
@@ -1488,25 +1577,11 @@ namespace Serein.WorkBench
return contextMenu; return contextMenu;
// nodeControl.ContextMenu = contextMenu; // nodeControl.ContextMenu = contextMenu;
} }
/// <summary>
/// 在画布中释放鼠标按下，结束选取状态
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FlowChartCanvas_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
{
if (IsSelectControl)
{
}
}
private void SelectedNode() private void SelectedNode()
{ {
if(selectNodeControls.Count == 0) if(selectNodeControls.Count == 0)
{ {
Console.WriteLine($"没有选择控件"); //Console.WriteLine($"没有选择控件");
SelectionRectangle.Visibility = Visibility.Collapsed; SelectionRectangle.Visibility = Visibility.Collapsed;
return; return;
} }
@@ -1514,7 +1589,7 @@ namespace Serein.WorkBench
foreach (var node in selectNodeControls) foreach (var node in selectNodeControls)
{ {
node.ViewModel.Selected(); node.ViewModel.Selected();
node.ViewModel.CancelSelect(); // node.ViewModel.CancelSelect();
node.BorderBrush = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFC700")); node.BorderBrush = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFC700"));
node.BorderThickness = new Thickness(4); node.BorderThickness = new Thickness(4);
} }
@@ -1849,8 +1924,8 @@ namespace Serein.WorkBench
await FlowEnvironment.StartAsync(); // 快 await FlowEnvironment.StartAsync(); // 快
//await Task.Run( FlowEnvironment.StartAsync); // 上下文多次切换的场景中吗慢了1/5 //await Task.Run( FlowEnvironment.StartAsync); // 上下文多次切换的场景中慢了1/10,定时器精度丢失
//await Task.Factory.StartNew(FlowEnvironment.StartAsync); // 慢了1/5 //await Task.Factory.StartNew(FlowEnvironment.StartAsync); // 慢了1/5,定时器精度丢失
} }
/// <summary> /// <summary>
@@ -1975,6 +2050,11 @@ namespace Serein.WorkBench
/// <param name="e"></param> /// <param name="e"></param>
private void Window_PreviewKeyDown(object sender, KeyEventArgs e) private void Window_PreviewKeyDown(object sender, KeyEventArgs e)
{ {
if (e.Key == Key.Tab)
{
e.Handled = true; // 禁止默认的Tab键行为
}
if (e.KeyStates == Keyboard.GetKeyStates(Key.Escape)) if (e.KeyStates == Keyboard.GetKeyStates(Key.Escape))
//if (Keyboard.Modifiers == ModifierKeys.Shift) //if (Keyboard.Modifiers == ModifierKeys.Shift)
{ {
@@ -1984,6 +2064,7 @@ namespace Serein.WorkBench
EndConnection(); EndConnection();
SelectionRectangle.Visibility = Visibility.Collapsed; SelectionRectangle.Visibility = Visibility.Collapsed;
CancelSelectNode(); CancelSelectNode();
} }
} }

2
WorkBench/Node/NodeControlViewModelBase.cs
View File

@@ -94,7 +94,7 @@ namespace Serein.WorkBench.Node.ViewModel
// } // }
//} //}
public event PropertyChangedEventHandler PropertyChanged; public event PropertyChangedEventHandler? PropertyChanged;
protected void OnPropertyChanged([CallerMemberName] string propertyName = null) protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
{ {
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName)); PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));

61
WorkBench/tool/LogTextWriter.cs
View File

@@ -1,6 +1,7 @@
using System.Collections.Concurrent; using System.Collections.Concurrent;
using System.IO; using System.IO;
using System.Text; using System.Text;
using System.Threading.Channels;
namespace Serein.WorkBench.tool namespace Serein.WorkBench.tool
{ {
@@ -9,21 +10,20 @@ namespace Serein.WorkBench.tool
/// </summary> /// </summary>
public class LogTextWriter : TextWriter public class LogTextWriter : TextWriter
{ {
private readonly Action<string> logAction; private readonly Action<string> logAction; // 更新日志UI的委托
private readonly StringWriter stringWriter = new(); private readonly StringWriter stringWriter = new(); // 缓存日志内容
private readonly BlockingCollection<string> logQueue = new(); private readonly Channel<string> logChannel = Channel.CreateUnbounded<string>(); // 日志管道
private readonly Task logTask; private readonly Action clearTextBoxAction; // 清空日志UI的委托
private int writeCount = 0; // 写入计数器
// 用于计数的字段 private const int maxWrites = 500; // 写入最大计数
private int writeCount = 0;
private const int maxWrites = 500;
private readonly Action clearTextBoxAction;
public LogTextWriter(Action<string> logAction, Action clearTextBoxAction) public LogTextWriter(Action<string> logAction, Action clearTextBoxAction)
{ {
this.logAction = logAction; this.logAction = logAction;
this.clearTextBoxAction = clearTextBoxAction; this.clearTextBoxAction = clearTextBoxAction;
logTask = Task.Run(ProcessLogQueue); // 异步处理日志
// 异步启动日志处理任务，不阻塞主线程
Task.Run(ProcessLogQueueAsync);
} }
public override Encoding Encoding => Encoding.UTF8; public override Encoding Encoding => Encoding.UTF8;
@@ -54,39 +54,32 @@ namespace Serein.WorkBench.tool
EnqueueLog(); EnqueueLog();
} }
// 将日志加入通道
private void EnqueueLog() private void EnqueueLog()
{ {
logQueue.Add(stringWriter.ToString()); var log = stringWriter.ToString();
stringWriter.GetStringBuilder().Clear(); stringWriter.GetStringBuilder().Clear();
}
private async Task ProcessLogQueue() if (!logChannel.Writer.TryWrite(log))
{
foreach (var log in logQueue.GetConsumingEnumerable())
{ {
// 异步执行日志输出操作 // 如果写入失败（不太可能），则直接丢弃日志或处理
await Task.Run(() =>
{
logAction(log);
// 计数器增加
writeCount++;
if (writeCount >= maxWrites)
{
// 计数器达到50，清空文本框
clearTextBoxAction?.Invoke();
writeCount = 0; // 重置计数器
}
});
} }
} }
public new void Dispose() // 异步处理日志队列
private async Task ProcessLogQueueAsync()
{ {
logQueue.CompleteAdding(); await foreach (var log in logChannel.Reader.ReadAllAsync()) // 异步读取日志通道
logTask.Wait(); {
base.Dispose(); logAction?.Invoke(log); // 执行日志写入到UI的委托
writeCount++;
if (writeCount >= maxWrites)
{
clearTextBoxAction?.Invoke(); // 清空文本框
writeCount = 0; // 重置计数器
}
}
} }
} }
} }