zhusenlin/serein-flow
1
0
Fork 0
mirror of https://gitee.com/langsisi_admin/serein-flow synced 2026-03-20 00:06:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
fengjiayi
2024-12-26 16:42:05 +08:00
parent 56b22be8c0
commit 7a6f8c407b
37 changed files with 880 additions and 1127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Library.Core/FlipflopContext.cs
View File

@@ -1,4 +1,5 @@
using Serein.Library.Api;
using Serein.Library.Utils;
namespace Serein.Library.Core
{

1
Library.Framework/FlipflopContext.cs
View File

@@ -1,4 +1,5 @@
using Serein.Library.Api;
using Serein.Library.Utils;
using System;
using System.Threading.Tasks;

1
Library/Api/IFlipflopContext.cs
View File

@@ -1,4 +1,5 @@
using Serein.Library;
using Serein.Library.Utils;
namespace Serein.Library.Api

21
Library/Api/IFlowEnvironment.cs
View File

@@ -6,7 +6,6 @@ using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.Library.Api
{
@@ -203,7 +202,7 @@ namespace Serein.Library.Api
/// <summary>
/// 移除
/// </summary>
Remote,
Remove,
}
/// <summary>
@@ -311,9 +310,9 @@ namespace Serein.Library.Api
//}
/// <summary>
/// 节点Model对象，目前需要手动转换对应的类型
/// 节点Model对象
/// </summary>
public object NodeModel { get; private set; }
public NodeModelBase NodeModel { get; private set; }
public PositionOfUI Position { get; private set; }
//public bool IsAddInRegion { get; private set; }
public string RegeionGuid { get; private set; }
@@ -934,13 +933,17 @@ namespace Serein.Library.Api
void TerminateFlipflopNode(string nodeGuid);
/// <summary>
#region 节点中断、表达式
#if false
/// <summary>
/// 设置节点中断
/// </summary>
/// <param name="nodeGuid">更改中断状态的节点Guid</param>
/// <param name="isInterrup">是否中断</param>
/// <returns></returns>
Task<bool> SetNodeInterruptAsync(string nodeGuid,bool isInterrup);
Task<bool> SetNodeInterruptAsync(string nodeGuid, bool isInterrup);
/// <summary>
/// 添加作用于某个对象的中断表达式
@@ -955,7 +958,7 @@ namespace Serein.Library.Api
/// </summary>
/// <param name="key">需要监视的对象</param>
/// <param name="isMonitor">是否启用监视</param>
void SetMonitorObjState(string key,bool isMonitor);
void SetMonitorObjState(string key, bool isMonitor);
/// <summary>
/// 检查一个对象是否处于监听状态，如果是，则传出与该对象相关的表达式（用于中断），如果不是，则返回false。
@@ -971,7 +974,9 @@ namespace Serein.Library.Api
/// <param name="signal"></param>
/// <param name="interruptClass"></param>
/// <returns></returns>
Task<CancelType> GetOrCreateGlobalInterruptAsync();
Task<CancelType> InterruptNode();
#endif
#endregion
/// <summary>
/// （用于远程）通知节点属性变更

12
Library/Api/IFlowTrigger.cs
View File

@@ -1,11 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Serein.Library.Utils;
using System;
using System.Threading.Tasks;
namespace Serein.Library.Api
{
/// <summary>
/// 触发器接口
/// </summary>

4
Library/Api/INodeContainer.cs
View File

@@ -15,13 +15,13 @@ namespace Serein.Library.Api
/// 放置一个节点
/// </summary>
/// <param name="nodeModel"></param>
void PlaceNode(NodeModelBase nodeModel);
bool PlaceNode(NodeModelBase nodeModel);
/// <summary>
/// 取出一个节点
/// </summary>
/// <param name="nodeModel"></param>
void TakeOutNode(NodeModelBase nodeModel);
bool TakeOutNode(NodeModelBase nodeModel);
/// <summary>
/// 取出所有节点（用于删除容器）

5
Library/FlowNode/NodeDebugSetting.cs
View File

@@ -2,7 +2,6 @@
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.Library
{
@@ -42,7 +41,7 @@ namespace Serein.Library
/// <summary>
/// 中断级别，暂时停止继续执行后继分支。
/// </summary>
[PropertyInfo(IsNotification = true, CustomCodeAtEnd = "NodeModel?.Env?.SetNodeInterruptAsync(NodeModel?.Guid, value);")] // CustomCode = "NodeModel?.Env?.SetNodeInterruptAsync(NodeModel?.Guid, value);"
[PropertyInfo(IsNotification = true, CustomCodeAtEnd = "// NodeModel?.Env?.SetNodeInterruptAsync(NodeModel?.Guid, value);")] // CustomCode = "NodeModel?.Env?.SetNodeInterruptAsync(NodeModel?.Guid, value);"
private bool _isInterrupt = false;
/// <summary>
@@ -55,7 +54,7 @@ namespace Serein.Library
/// 中断Task（用来中断）
/// </summary>
[PropertyInfo]
private Func<Task<CancelType>> _getInterruptTask;
private Func<Task> _getInterruptTask;
}

364
Library/FlowNode/NodeModelBaseFunc.cs
View File

@@ -16,7 +16,6 @@ using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.Library
{
@@ -366,16 +365,15 @@ namespace Serein.Library
/// <returns>节点传回数据对象</returns>
public virtual async Task<object> ExecutingAsync(IDynamicContext context)
{
if(context.NextOrientation == ConnectionInvokeType.IsError)
{
Console.WriteLine("");
}
//if(context.NextOrientation == ConnectionInvokeType.IsError)
//{
//}
#region 调试中断
if (DebugSetting.IsInterrupt) // 执行触发检查是否需要中断
{
var cancelType = await this.DebugSetting.GetInterruptTask(); // 等待中断结束
await Console.Out.WriteLineAsync($"[{this.MethodDetails?.MethodName}]中断已{cancelType}，开始执行后继分支");
//var cancelType = await this.DebugSetting.GetInterruptTask(); // 等待中断结束
await Console.Out.WriteLineAsync($"[{this.MethodDetails?.MethodName}]中断已取消，开始执行后继分支");
}
#endregion
@@ -394,7 +392,7 @@ namespace Serein.Library
md.ActingInstance = context.Env.IOC.Get(md.ActingInstanceType);
}
object[] args = await GetParametersAsync(context, this);
object[] args = await GetParametersAsync(context);
var result = await dd.InvokeAsync(md.ActingInstance, args);
return result;
@@ -403,296 +401,50 @@ namespace Serein.Library
/// <summary>
/// 获取对应的参数数组
/// </summary>
public static async Task<object[]> GetParametersAsync(IDynamicContext context,
NodeModelBase nodeModel)
public async Task<object[]> GetParametersAsync(IDynamicContext context)
{
// 用正确的大小初始化参数数组
var md = nodeModel.MethodDetails;
if (md.ParameterDetailss.Length == 0)
if (MethodDetails.ParameterDetailss.Length == 0)
{
return null;// md.ActingInstance
return new object[0];// md.ActingInstance
}
object[] parameters;
object[] args;
Array paramsArgs = null; // 初始化可选参数
int paramsArgIndex = 0; // 可选参数下标，与 object[] paramsArgs 一起使用
if (md.ParamsArgIndex >= 0)
if (MethodDetails.ParamsArgIndex >= 0) // 存在可变入参参数
{
// 存在可变入参参数
var paramsArgType = md.ParameterDetailss[md.ParamsArgIndex].DataType; // 获取可变参数的参数类型
// 可变参数数组长度 = 方法参数个数 - （ 可选入参下标 + 1 ）
int paramsLength = md.ParameterDetailss.Length - md.ParamsArgIndex;
var paramsArgType = MethodDetails.ParameterDetailss[MethodDetails.ParamsArgIndex].DataType; // 获取可变参数的参数类型
int paramsLength = MethodDetails.ParameterDetailss.Length - MethodDetails.ParamsArgIndex; // 可变参数数组长度 = 方法参数个数 - （ 可选入参下标 + 1 ）
paramsArgs = Array.CreateInstance(paramsArgType, paramsLength);// 可变参数
parameters = new object[md.ParamsArgIndex+1]; // 调用方法的入参数组
parameters[md.ParamsArgIndex] = paramsArgs; // 如果存在可选参数，入参参数最后一项则为可变参数
args = new object[MethodDetails.ParamsArgIndex + 1]; // 调用方法的入参数组
args[MethodDetails.ParamsArgIndex] = paramsArgs; // 如果存在可选参数，入参参数最后一项则为可变参数
}
else
{
// 不存在可选参数
parameters = new object[md.ParameterDetailss.Length]; // 调用方法的入参数组
args = new object[MethodDetails.ParameterDetailss.Length]; // 调用方法的入参数组
}
bool hasParams = false;
for (int i = 0; i < md.ParameterDetailss.Length; i++)
for (int i = 0; i < args.Length; i++) {
var pd = MethodDetails.ParameterDetailss[i];
args[i] = await pd.ToMethodArgData(context); // 获取数据
}
if(MethodDetails.ParamsArgIndex >= 0)
{
var pd = md.ParameterDetailss[i]; // 方法入参描述
var argDataType = pd.DataType;
// 入参参数下标循环到可选参数时，开始写入到可选参数数组
if (paramsArgs != null && i >= md.ParamsArgIndex)
for (int i = 0; i < paramsArgs.Length; i++)
{
// 控制参数赋值方向：
// true => paramsArgs
// false => parameters
hasParams = true;
var pd = MethodDetails.ParameterDetailss[paramsArgIndex + i];
var data = await pd.ToMethodArgData(context); // 获取数据
paramsArgs.SetValue(data, i);// 设置到数组中
}
#region 获取基础的上下文数据
if (argDataType == typeof(IFlowEnvironment)) // 获取流程上下文
{
parameters[i] = nodeModel.Env;
continue;
}
if (argDataType == typeof(IDynamicContext)) // 获取流程上下文
{
parameters[i] = context;
continue;
}
#endregion
#region 确定[预入参]数据
object inputParameter; // 存放解析的临时参数
if (pd.IsExplicitData && !pd.DataValue.StartsWith("@", StringComparison.OrdinalIgnoreCase)) // 判断是否使用显示的输入参数
{
// 使用输入的固定值
inputParameter = pd.DataValue;
}
else
{
#region （默认的）从运行时上游节点获取其返回值
if (pd.ArgDataSourceType == ConnectionArgSourceType.GetPreviousNodeData)
{
var previousNode = context.GetPreviousNode(nodeModel);
if (previousNode is null)
{
inputParameter = null;
}
else
{
inputParameter = context.GetFlowData(previousNode.Guid); // 当前传递的数据
}
}
#endregion
#region 从指定节点获取其返回值
else if (pd.ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeData)
{
// 获取指定节点的数据
// 如果指定节点没有被执行，会返回null
// 如果执行过，会获取上一次执行结果作为预入参数据
inputParameter = context.GetFlowData(pd.ArgDataSourceNodeGuid);
}
#endregion
#region 立刻执行指定节点，然后获取返回值
else if (pd.ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeDataOfInvoke)
{
// 立刻调用对应节点获取数据。
try
{
var result = await context.Env.InvokeNodeAsync(context, pd.ArgDataSourceNodeGuid);
inputParameter = result;
}
catch (Exception ex)
{
context.NextOrientation = ConnectionInvokeType.IsError;
context.ExceptionOfRuning = ex;
throw;
}
}
#endregion
#region 意料之外的参数
else
{
throw new Exception("节点执行方法获取入参参数时，ConnectionArgSourceType枚举是意外的枚举值");
}
#endregion
}
#region 处理 @Get / @DTC 表达式 （Data type conversion） / @Data (全局数据)
if (pd.IsExplicitData)
{
// @Get 表达式 （从上一节点获取对象）
if (pd.DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase))
{
inputParameter = SerinExpressionEvaluator.Evaluate(pd.DataValue, inputParameter, out _);
}
// @DTC 表达式 （Data type conversion）
if (pd.DataValue.StartsWith("@dtc", StringComparison.OrdinalIgnoreCase))
{
inputParameter = SerinExpressionEvaluator.Evaluate(pd.DataValue, inputParameter, out _);
}
// @Data 表达式 （获取全局数据）
if (pd.DataValue.StartsWith("@data", StringComparison.OrdinalIgnoreCase))
{
inputParameter = SerinExpressionEvaluator.Evaluate(pd.DataValue, inputParameter, out _);
}
}
#endregion
#region 对于非值类型的null检查
if (!argDataType.IsValueType && inputParameter is null)
{
parameters[i] = null;
throw new Exception($"[arg{pd.Index}][{pd.Name}][{argDataType}]参数不能为null");
continue;
}
#endregion
#endregion
//#region 入参存在取值转换器，调用对应的转换器获取入参数据，如果获取成功（不为null）会跳过循环
//if (pd.ExplicitType.IsEnum && !(pd.Convertor is null))
//{
// //var resultEnum = Enum.ToObject(ed.ExplicitType, ed.DataValue);
// var resultEnum = Enum.Parse(pd.ExplicitType, pd.DataValue);
// var value = pd.Convertor(resultEnum);
// if (value is null)
// {
// throw new InvalidOperationException("转换器调用失败");
// }
// else
// {
// if (hasParams)
// {
// paramsArgs.SetValue(value, paramsArgIndex++);
// // 处理可选参数
// //paramsArgs[paramsArgIndex++] = value;
// }
// else
// {
// parameters[i] = value;
// }
// continue;
// }
//}
//#endregion
#region 入参存在基于BinValue的类型转换器，获取枚举转换器中记录的类型，如果获取成功（不为null）会跳过循环
// 入参存在基于BinValue的类型转换器，获取枚举转换器中记录的类型
if (pd.ExplicitType.IsEnum && argDataType != pd.ExplicitType)
{
var resultEnum = Enum.Parse(pd.ExplicitType, pd.DataValue);
// 获取绑定的类型
var type = EnumHelper.GetBoundValue(pd.ExplicitType, resultEnum, attr => attr.Value);
if (type is Type enumBindType && !(enumBindType is null))
{
var value = nodeModel.Env.IOC.Instantiate(enumBindType);
if (value is null)
{
}
else
{
if (hasParams)
{
// 处理可选参数
paramsArgs.SetValue(value, paramsArgIndex++);
//paramsArgs[paramsArgIndex++] = value;
}
else
{
parameters[i] = value;
}
continue;
}
}
}
#endregion
#region 对入参数据尝试进行转换
object tmpVaue = null; // 临时存放数据，最后才判断是否放置可选参数数组
var inputParameterType = inputParameter.GetType();
if (inputParameterType == argDataType)
{
tmpVaue = inputParameter; // 类型一致无需转换，直接装入入参数组
}
else if (argDataType.IsValueType)
{
// 值类型
var valueStr = inputParameter?.ToString();
tmpVaue = valueStr.ToValueData(argDataType); // 类型不一致，尝试进行转换，如果转换失败返回类型对应的默认值
}
else
{
// 引用类型
if (argDataType == typeof(string)) // 转为字符串
{
var valueStr = inputParameter?.ToString();
tmpVaue = valueStr;
}
else if(argDataType.IsSubclassOf(inputParameterType)) // 入参类型 是 预入参数据类型 的 子类/实现类
{
// 方法入参中，父类不能隐式转为子类，这里需要进行强制转换
tmpVaue = ObjectConvertHelper.ConvertParentToChild(inputParameter, argDataType);
}
else if(argDataType.IsAssignableFrom(inputParameterType)) // 入参类型 是 预入参数据类型 的 父类/接口
{
tmpVaue = inputParameter;
}
// 集合类型
//else if(inputParameter is IEnumerable collection)
//{
// var enumerableMethods = typeof(Enumerable).GetMethods(); // 获取所有的 Enumerable 扩展方法
// MethodInfo conversionMethod;
// if (argDataType.IsArray) // 转为数组
// {
// parameters[i] = inputParameter;
// conversionMethod = enumerableMethods.FirstOrDefault(m => m.Name == "ToArray" && m.IsGenericMethodDefinition);
// }
// else if (argDataType.GetGenericTypeDefinition() == typeof(List<>)) // 转为集合
// {
// conversionMethod = enumerableMethods.FirstOrDefault(m => m.Name == "ToList" && m.IsGenericMethodDefinition);
// }
// else
// {
// throw new InvalidOperationException("输入对象不是集合或目标类型不支持（目前仅支持Array、List的自动转换）");
// }
// var genericMethod = conversionMethod.MakeGenericMethod(argDataType);
// var result = genericMethod.Invoke(null, new object[] { collection });
// parameters[i] = result;
//}
}
if (hasParams)
{
// 处理可选参数
paramsArgs.SetValue(tmpVaue, paramsArgIndex++);
//paramsArgs[paramsArgIndex++] = tmpVaue;
}
else
{
parameters[i] = tmpVaue;
}
#endregion
args[args.Length - 1] = paramsArgs;
}
return parameters;
return args;
}
/// <summary>
/// 更新节点数据，并检查监视表达式是否生效
/// </summary>
@@ -733,37 +485,37 @@ namespace Serein.Library
{
return;
}
(var isMonitor, var exps) = await context.Env.CheckObjMonitorStateAsync(key);
if (isMonitor) // 如果新的数据处于查看状态，通知UI进行更新？交给运行环境判断？
{
context.Env.MonitorObjectNotification(nodeModel.Guid, data, sourceType); // 对象处于监视状态，通知UI更新数据显示
if (exps.Length > 0)
{
// 表达式环境下判断是否需要执行中断
bool isExpInterrupt = false;
string exp = "";
// 判断执行监视表达式，直到为 true 时退出
for (int i = 0; i < exps.Length && !isExpInterrupt; i++)
{
exp = exps[i];
if (string.IsNullOrEmpty(exp)) continue;
// isExpInterrupt = SereinConditionParser.To(data, exp);
}
//(var isMonitor, var exps) = await context.Env.CheckObjMonitorStateAsync(key);
//if (isMonitor) // 如果新的数据处于查看状态，通知UI进行更新？交给运行环境判断？
//{
// context.Env.MonitorObjectNotification(nodeModel.Guid, data, sourceType); // 对象处于监视状态，通知UI更新数据显示
// if (exps.Length > 0)
// {
// // 表达式环境下判断是否需要执行中断
// bool isExpInterrupt = false;
// string exp = "";
// // 判断执行监视表达式，直到为 true 时退出
// for (int i = 0; i < exps.Length && !isExpInterrupt; i++)
// {
// exp = exps[i];
// if (string.IsNullOrEmpty(exp)) continue;
// // isExpInterrupt = SereinConditionParser.To(data, exp);
// }
if (isExpInterrupt) // 触发中断
{
nodeModel.DebugSetting.IsInterrupt = true;
if (await context.Env.SetNodeInterruptAsync(nodeModel.Guid,true))
{
context.Env.TriggerInterrupt(nodeModel.Guid, exp, InterruptTriggerEventArgs.InterruptTriggerType.Exp);
var cancelType = await nodeModel.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{data}]中断已{cancelType}，开始执行后继分支");
nodeModel.DebugSetting.IsInterrupt = false;
}
}
}
// if (isExpInterrupt) // 触发中断
// {
// nodeModel.DebugSetting.IsInterrupt = true;
// if (await context.Env.SetNodeInterruptAsync(nodeModel.Guid,true))
// {
// context.Env.TriggerInterrupt(nodeModel.Guid, exp, InterruptTriggerEventArgs.InterruptTriggerType.Exp);
// var cancelType = await nodeModel.DebugSetting.GetInterruptTask();
// await Console.Out.WriteLineAsync($"[{data}]中断已{cancelType}，开始执行后继分支");
// nodeModel.DebugSetting.IsInterrupt = false;
// }
// }
// }
}
//}
}
///// <summary>

139
Library/FlowNode/ParameterDetails.cs
View File

@@ -1,8 +1,11 @@
using Serein.Library.Api;
using Serein.Library.Utils;
using Serein.Library.Utils.SereinExpression;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
namespace Serein.Library
{
@@ -111,7 +114,6 @@ namespace Serein.Library
{
}
/// <summary>
/// 为节点实例化新的入参描述
@@ -178,6 +180,141 @@ namespace Serein.Library
return pd;
}
/// <summary>
/// 转为方法入参数据
/// </summary>
/// <returns></returns>
public async ValueTask<object> ToMethodArgData(IDynamicContext context)
{
var nodeModel = NodeModel;
var env = nodeModel.Env;
#region 显然的流程基本类型
// 返回运行环境
if (DataType == typeof(IFlowEnvironment))
{
return env;
}
// 返回流程上下文
if (DataType == typeof(IDynamicContext))
{
return context;
}
// 显式设置的参数
if (IsExplicitData && !DataValue.StartsWith("@", StringComparison.OrdinalIgnoreCase))
{
return DataValue.ToConvert(DataType); // 并非表达式，同时是显式设置的参数
}
#endregion
#region “枚举-类型”转换器
if (ExplicitType.IsEnum && DataType != ExplicitType)
{
var resultEnum = Enum.Parse(ExplicitType, DataValue);
// 获取绑定的类型
var type = EnumHelper.GetBoundValue(ExplicitType, resultEnum, attr => attr.Value);
if (type is Type enumBindType && !(enumBindType is null))
{
var value = nodeModel.Env.IOC.Instantiate(enumBindType);
return value;
}
}
#endregion
// 需要获取预入参数据
object inputParameter;
#region （默认的）从运行时上游节点获取其返回值
if (ArgDataSourceType == ConnectionArgSourceType.GetPreviousNodeData)
{
var previousNode = context.GetPreviousNode(nodeModel);
if (previousNode is null)
{
inputParameter = null;
}
else
{
inputParameter = context.GetFlowData(previousNode.Guid); // 当前传递的数据
}
}
#endregion
#region 从指定节点获取其返回值
else if (ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeData)
{
// 获取指定节点的数据
// 如果指定节点没有被执行，会返回null
// 如果执行过，会获取上一次执行结果作为预入参数据
inputParameter = context.GetFlowData(ArgDataSourceNodeGuid);
}
#endregion
#region 立刻执行指定节点，然后获取返回值
else if (ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeDataOfInvoke)
{
// 立刻调用对应节点获取数据。
try
{
var result = await env.InvokeNodeAsync(context, ArgDataSourceNodeGuid);
inputParameter = result;
}
catch (Exception ex)
{
context.NextOrientation = ConnectionInvokeType.IsError;
context.ExceptionOfRuning = ex;
throw;
}
}
#endregion
#region 意料之外的参数
else
{
throw new Exception("节点执行方法获取入参参数时，ConnectionArgSourceType枚举是意外的枚举值");
}
#endregion
#region 判断是否执行表达式
if (IsExplicitData)
{
// @Get 表达式 （从上一节点获取对象）
if (DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase))
{
inputParameter = SerinExpressionEvaluator.Evaluate(DataValue, inputParameter, out _);
}
// @DTC 表达式 （Data type conversion）
else if (DataValue.StartsWith("@dtc", StringComparison.OrdinalIgnoreCase))
{
inputParameter = SerinExpressionEvaluator.Evaluate(DataValue, inputParameter, out _);
}
// @Data 表达式 （获取全局数据）
else if (DataValue.StartsWith("@data", StringComparison.OrdinalIgnoreCase))
{
inputParameter = SerinExpressionEvaluator.Evaluate(DataValue, inputParameter, out _);
}
}
#endregion
// 对引用类型检查 null
if (!DataType.IsValueType && inputParameter is null)
{
throw new Exception($"[arg{Index}][{Name}][{DataType}]参数不能为null");
}
if (DataType == typeof(string)) // 转为字符串
{
return inputParameter.ToString();
}
var inputParameterType = inputParameter.GetType();
if (DataType.IsSubclassOf(inputParameterType)) // 入参类型 是 预入参数据类型 的 子类/实现类
{
// 方法入参中，父类不能隐式转为子类，这里需要进行强制转换
return ObjectConvertHelper.ConvertParentToChild(inputParameter, DataType);
}
if (DataType.IsAssignableFrom(inputParameterType)) // 入参类型 是 预入参数据类型 的 父类/接口
{
return inputParameter;
}
throw new Exception($"[arg{Index}][{Name}][{DataType}]入参类型不符合，当前预入参类型为{inputParameterType}");
}
public override string ToString()
{
return $"[{this.Index}] {this.Name} : {this.ExplicitType?.FullName} -> {this.DataType?.FullName}";

2
Library/Network/WebSocket/Handle/Attribute.cs
View File

@@ -9,7 +9,7 @@ using System.Threading.Tasks;
namespace Serein.Library.Network.WebSocketCommunication.Handle
{
/// <summary>
/// 表示参数可以为空(Net462不能使用NutNull的情况）
/// 表示参数不能为空(Net462不能使用NutNull的情况）
/// </summary>
public sealed class NeedfulAttribute : Attribute
{

2
Library/Serein.Library.csproj
View File

@@ -38,6 +38,8 @@
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.ObjectPool" Version="9.0.0" />
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
<PackageReference Include="System.Reactive" Version="6.0.1" />
<PackageReference Include="System.Threading.Channels" Version="8.0.0" />

353
Library/Utils/ChannelFlowInterrupt.cs
View File

@@ -1,353 +0,0 @@
#region plan 2
using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Channels;
using System.Threading.Tasks;
namespace Serein.Library.Utils
{
/// <summary>
/// 流程中断管理
/// </summary>
public class ChannelFlowInterrupt
{
/// <summary>
/// 中断取消类型
/// </summary>
public enum CancelType
{
Manual,
Error,
Overtime
}
// 使用并发字典管理每个信号对应的 Channel
private readonly ConcurrentDictionary<string, Channel<CancelType>> _channels = new ConcurrentDictionary<string, Channel<CancelType>>();
/// <summary>
/// 创建信号并指定超时时间，到期后自动触发（异步方法）
/// </summary>
/// <param name="signal">信号标识符</param>
/// <param name="outTime">超时时间</param>
/// <returns>等待任务</returns>
public async Task<CancelType> GetCreateChannelWithTimeoutAsync(string signal, TimeSpan outTime)
{
var channel = GetOrCreateChannel(signal);
var cts = new CancellationTokenSource();
// 异步任务：超时后自动触发信号
_ = Task.Run(async () =>
{
try
{
await Task.Delay(outTime, cts.Token);
if (!cts.Token.IsCancellationRequested)
{
await channel.Writer.WriteAsync(CancelType.Overtime);
}
}
catch (OperationCanceledException)
{
// 超时任务被取消
}
finally
{
cts?.Dispose();
}
}, cts.Token);
// 等待信号传入（超时或手动触发）
try
{
var result = await channel.Reader.ReadAsync();
return result;
}
catch
{
return CancelType.Error;
}
}
/// <summary>
/// 创建信号，直到手动触发（异步方法）
/// </summary>
/// <param name="signal">信号标识符</param>
/// <returns>等待任务</returns>
public async Task<CancelType> GetOrCreateChannelAsync(string signal)
{
try
{
var channel = GetOrCreateChannel(signal);
// 等待信号传入（超时或手动触发）
var result = await channel.Reader.ReadAsync();
return result;
}
catch
{
return CancelType.Manual;
}
}
/// <summary>
/// 创建信号并指定超时时间，到期后自动触发（同步阻塞方法）
/// </summary>
/// <param name="signal">信号标识符</param>
/// <param name="timeout">超时时间</param>
public async Task<CancelType> CreateChannelWithTimeoutSync(string signal, TimeSpan timeout)
{
var channel = GetOrCreateChannel(signal);
var cts = new CancellationTokenSource();
CancellationToken token = cts.Token;
// 异步任务：超时后自动触发信号
_ = Task.Run(async () =>
{
try
{
await Task.Delay(timeout, token);
await channel.Writer.WriteAsync(CancelType.Overtime);
}
catch (OperationCanceledException ex)
{
// 任务被取消
await Console.Out.WriteLineAsync(ex.Message);
}
});
// 同步阻塞直到信号触发或超时
var result = await channel.Reader.ReadAsync();
return result;
}
/// <summary>
/// 触发信号
/// </summary>
/// <param name="signal">信号字符串</param>
/// <returns>是否成功触发</returns>
public bool TriggerSignal(string signal)
{
//if (_channels.TryGetValue(signal, out var channel))
//{
// // 手动触发信号
// channel.Writer.TryWrite(CancelType.Manual);
// return true;
//}
//return false;
try
{
if (_channels.TryGetValue(signal, out var channel))
{
// 手动触发信号
channel.Writer.TryWrite(CancelType.Manual);
// 完成写入，标记该信号通道不再接受新写入
channel.Writer.Complete();
// 触发后移除信号
_channels.TryRemove(signal, out _);
return true;
}
return false;
}
catch
{
return false;
}
}
/// <summary>
/// 取消所有任务
/// </summary>
public void CancelAllTasks()
{
foreach (var channel in _channels.Values)
{
try
{
channel.Writer.Complete();
}
finally
{
}
}
_channels.Clear();
}
/// <summary>
/// 获取或创建指定信号的 Channel
/// </summary>
/// <param name="signal">信号字符串</param>
/// <returns>对应的 Channel</returns>
private Channel<CancelType> GetOrCreateChannel(string signal)
{
return _channels.GetOrAdd(signal, _ => Channel.CreateUnbounded<CancelType>());
}
}
}
#endregion
#region plan 3
//using System;
//using System.Collections.Concurrent;
//using System.Threading;
//using System.Threading.Channels;
//using System.Threading.Tasks;
//namespace Serein.Library.Utils
//{
// /// <summary>
// /// 流程中断管理类，提供了基于 Channel 的异步中断机制
// /// </summary>
// public class ChannelFlowInterrupt
// {
// /// <summary>
// /// 中断取消类型
// /// </summary>
// public enum CancelType
// {
// Manual, // 手动触发
// Overtime, // 超时触发
// Discard // 丢弃触发
// }
// // 使用并发字典管理每个信号对应的 Channel 和状态
// private readonly ConcurrentDictionary<string, (Channel<CancelType> Channel, bool IsCancelled, bool IsDiscardMode)> _channels
// = new ConcurrentDictionary<string, (Channel<CancelType>, bool, bool)>();
// // 锁对象，用于保护并发访问
// private readonly object _lock = new object();
// /// <summary>
// /// 创建带有超时功能的信号，超时后自动触发
// /// </summary>
// public async Task<CancelType> GetCreateChannelWithTimeoutAsync(string signal, TimeSpan outTime)
// {
// var (channel, isCancelled, isDiscardMode) = GetOrCreateChannel(signal);
// // 如果信号已取消或在丢弃模式下，立即返回丢弃类型
// if (isCancelled || isDiscardMode) return CancelType.Discard;
// var cts = new CancellationTokenSource();
// _ = Task.Run(async () =>
// {
// try
// {
// await Task.Delay(outTime, cts.Token);
// if (!cts.Token.IsCancellationRequested && !isCancelled)
// {
// await channel.Writer.WriteAsync(CancelType.Overtime);
// }
// }
// catch (OperationCanceledException)
// {
// // 处理任务取消的情况
// }
// finally
// {
// cts.Dispose();
// }
// }, cts.Token);
// return await channel.Reader.ReadAsync();
// }
// /// <summary>
// /// 创建或获取现有信号，等待手动触发
// /// </summary>
// public async Task<CancelType> GetOrCreateChannelAsync(string signal)
// {
// var (channel, isCancelled, isDiscardMode) = GetOrCreateChannel(signal);
// // 如果信号已取消或在丢弃模式下，立即返回丢弃类型
// if (isCancelled || isDiscardMode) return CancelType.Discard;
// return await channel.Reader.ReadAsync();
// }
// /// <summary>
// /// 触发信号并将其移除
// /// </summary>
// public bool TriggerSignal(string signal)
// {
// lock (_lock)
// {
// if (_channels.TryGetValue(signal, out var channelInfo))
// {
// var (channel, isCancelled, isDiscardMode) = channelInfo;
// // 如果信号未被取消，则触发并标记为已取消
// if (!isCancelled)
// {
// channel.Writer.TryWrite(CancelType.Manual);
// _channels[signal] = (channel, true, false); // 标记为已取消
// _channels.TryRemove(signal, out _); // 从字典中移除信号
// return true;
// }
// }
// }
// return false;
// }
// /// <summary>
// /// 启用丢弃模式，所有后续获取的信号将直接返回丢弃类型
// /// </summary>
// /// <param name="signal">信号标识符</param>
// public void EnableDiscardMode(string signal,bool state = true)
// {
// lock (_lock)
// {
// if (_channels.TryGetValue(signal, out var channelInfo))
// {
// var (channel, isCancelled, _) = channelInfo;
// _channels[signal] = (channel, isCancelled, state); // 标记为丢弃模式
// }
// }
// }
// /// <summary>
// /// 取消所有任务
// /// </summary>
// public void CancelAllTasks()
// {
// foreach (var (channel, _, _) in _channels.Values)
// {
// try
// {
// channel.Writer.Complete();
// }
// catch
// {
// // 忽略完成时的异常
// }
// }
// _channels.Clear();
// }
// /// <summary>
// /// 获取或创建指定信号的 Channel 通道
// /// </summary>
// private (Channel<CancelType>, bool, bool) GetOrCreateChannel(string signal)
// {
// lock (_lock)
// {
// return _channels.GetOrAdd(signal, _ => (Channel.CreateUnbounded<CancelType>(), false, false));
// }
// }
// }
//}
#endregion

57
Library/Utils/TaskFlowTrigger.cs → Library/Utils/FlowTrigger/ChannelFlowInterrupt.cs
View File

@@ -10,41 +10,15 @@ using System.Threading.Channels;
using System.Threading.Tasks;
using System.Transactions;
namespace Serein.Library
namespace Serein.Library.Utils
{
/// <summary>
/// 触发类型
/// </summary>
public enum TriggerDescription
{
/// <summary>
/// 外部触发
/// </summary>
External,
/// <summary>
/// 超时触发
/// </summary>
Overtime,
/// <summary>
/// 触发了，但类型不一致
/// </summary>
TypeInconsistency
}
public class TriggerResult<TResult>
{
public TriggerDescription Type { get; set; }
public TResult Value { get; set; }
}
/// <summary>
/// 信号触发器类，带有消息广播功能。
/// 使用枚举作为标记，创建
/// </summary>
public class TaskFlowTrigger<TSignal> : IFlowTrigger<TSignal> where TSignal : struct, Enum
public class ValueTaskFlowTrigger<TSignal>
{
// 使用并发字典管理每个信号对应的广播列表
private readonly ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>> _subscribers = new ConcurrentDictionary<TSignal, Subject<TriggerResult<object>>>();
@@ -73,7 +47,7 @@ namespace Serein.Library
}
/// <summary>
/// 等待触发器并指定超时的时间
/// </summary>
@@ -81,7 +55,7 @@ namespace Serein.Library
/// <param name="signal">等待信号</param>
/// <param name="outTime">超时时间</param>
/// <returns></returns>
public async Task<TriggerResult<TResult>> WaitTriggerWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime)
public async ValueTask<TriggerResult<TResult>> WaitTriggerWithTimeoutAsync<TResult>(TSignal signal, TimeSpan outTime)
{
var subject = GetOrCreateSubject(signal);
var cts = new CancellationTokenSource();
@@ -121,13 +95,14 @@ namespace Serein.Library
/// <typeparam name="TResult"></typeparam>
/// <param name="signal"></param>
/// <returns></returns>
public async Task<TriggerResult<TResult>> WaitTriggerAsync<TResult>(TSignal signal)
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)
if (result.Value is TResult data)
{
return new TriggerResult<TResult>()
{
@@ -184,23 +159,5 @@ namespace Serein.Library
/// <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);
}
}
}

6
Library/Utils/ChannelFlowTrigger.cs → Library/Utils/FlowTrigger/ChannelFlowTrigger.cs
View File

@@ -1,6 +1,4 @@

using Serein.Library.Api;
using Serein.Library.Api;
using System;
using System.Collections.Concurrent;
using System.Threading;
@@ -13,7 +11,7 @@ namespace Serein.Library.Utils
public class ChannelFlowTrigger<TSignal> : IFlowTrigger<TSignal>
public class ChannelFlowTrigger<TSignal> : IFlowTrigger<TSignal>
{
// 使用并发字典管理每个枚举信号对应的 Channel
private readonly ConcurrentDictionary<TSignal, Channel<TriggerResult<object>>> _channels = new ConcurrentDictionary<TSignal, Channel<TriggerResult<object>>>();

160
Library/Utils/FlowTrigger/TaskFlowTrigger.cs Normal file
View File

@@ -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);
}
}
}

112
Library/Utils/FlowTrigger/TriggerResult.cs Normal file
View File

@@ -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
}
}

1
Net462DllTest/Trigger/PrakingDevice.cs
View File

@@ -1,5 +1,6 @@
using Net462DllTest.LogicControl;
using Serein.Library;
using Serein.Library.Utils.FlowTrigger;
namespace Net462DllTest.Trigger
{

1
Net462DllTest/Trigger/SiemensPlcDevice.cs
View File

@@ -8,6 +8,7 @@ using Net462DllTest.Signal;
using Net462DllTest.Utils;
using Serein.Library;
using Serein.Library.Utils;
using Serein.Library.Utils.FlowTrigger;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;

1
Net462DllTest/Trigger/ViewManagement.cs
View File

@@ -9,6 +9,7 @@ using System.Threading;
using System.Windows.Forms;
using System.Windows.Threading;
using Serein.Library.Utils;
using Serein.Library.Utils.FlowTrigger;
namespace Net462DllTest.Trigger
{

366
NodeFlow/Env/FlowEnvironment.cs
View File

@@ -14,13 +14,13 @@ using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Numerics;
using System.Reactive;
using System.Reflection;
using System.Reflection.Metadata.Ecma335;
using System.Runtime.Loader;
using System.Security.AccessControl;
using System.Text;
using System.Xml.Linq;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.NodeFlow.Env
{
@@ -31,7 +31,7 @@ namespace Serein.NodeFlow.Env
/// <summary>
/// 运行环境
/// </summary>
public class FlowEnvironment : IFlowEnvironment, ISereinIOC
public class FlowEnvironment : IFlowEnvironment, ISereinIOC
{
/// <summary>
/// 节点的命名空间
@@ -47,7 +47,6 @@ namespace Serein.NodeFlow.Env
public FlowEnvironment(UIContextOperation uiContextOperation)
{
this.sereinIOC = new SereinIOC();
this.ChannelFlowInterrupt = new ChannelFlowInterrupt();
this.IsGlobalInterrupt = false;
this.flowStarter = null;
this.sereinIOC.OnIOCMembersChanged += e =>
@@ -244,10 +243,10 @@ namespace Serein.NodeFlow.Env
/// </summary>
public bool IsGlobalInterrupt { get; set; }
/// <summary>
/// 流程中断器
/// </summary>
public ChannelFlowInterrupt ChannelFlowInterrupt { get; set; }
///// <summary>
///// 流程中断器
///// </summary>
//public ChannelFlowInterrupt ChannelFlowInterrupt { get; set; }
/// <summary>
/// <para>单例模式IOC容器，内部维护了一个实例字典，默认使用类型的FullName作为Key，如果以“接口-实现类”的方式注册，那么将使用接口类型的FullName作为Key。</para>
@@ -377,7 +376,6 @@ namespace Serein.NodeFlow.Env
/// <returns></returns>
public async Task<bool> StartFlowAsync()
{
ChannelFlowInterrupt?.CancelAllTasks();
flowStarter = new FlowStarter();
var nodes = NodeModels.Values.ToList();
@@ -453,7 +451,7 @@ namespace Serein.NodeFlow.Env
/// <returns></returns>
public async Task<object> InvokeNodeAsync(IDynamicContext context, string nodeGuid)
{
object result = true;
object result = new Unit();
if (this.NodeModels.TryGetValue(nodeGuid, out var model))
{
result = await model.ExecutingAsync(context);
@@ -466,7 +464,6 @@ namespace Serein.NodeFlow.Env
/// </summary>
public Task<bool> ExitFlowAsync()
{
ChannelFlowInterrupt?.CancelAllTasks();
flowStarter?.Exit();
UIContextOperation?.Invoke(() => OnFlowRunComplete?.Invoke(new FlowEventArgs()));
flowStarter = null;
@@ -555,8 +552,11 @@ namespace Serein.NodeFlow.Env
LoadLibrary(dllFilePath); // 加载项目文件时加载对应的程序集
}
_ = LoadNodeInfosAsync(projectData.Nodes.ToList());
SetStartNodeAsync(projectData.StartNode);
_ = Task.Run( async () =>
{
await LoadNodeInfosAsync(projectData.Nodes.ToList());
await SetStartNodeAsync(projectData.StartNode);
});
}
@@ -745,7 +745,7 @@ namespace Serein.NodeFlow.Env
/// </summary>
/// <param name="List<NodeInfo>">节点信息</param>
/// <returns></returns>
public Task LoadNodeInfosAsync(List<NodeInfo> nodeInfos)
public async Task LoadNodeInfosAsync(List<NodeInfo> nodeInfos)
{
#region 从NodeInfo创建NodeModel
foreach (NodeInfo? nodeInfo in nodeInfos)
@@ -779,7 +779,7 @@ namespace Serein.NodeFlow.Env
nodeModel.LoadInfo(nodeInfo); // 创建节点model
TryAddNode(nodeModel); // 加载项目时将节点加载到环境中
UIContextOperation?.Invoke(() =>
await UIContextOperation.InvokeAsync(() =>
OnNodeCreate?.Invoke(new NodeCreateEventArgs(nodeModel, nodeInfo.Position))); // 添加到UI上
}
#endregion
@@ -798,77 +798,92 @@ namespace Serein.NodeFlow.Env
foreach (NodeInfo nodeInfo in needPlaceNodeInfos)
{
if (NodeModels.TryGetValue(nodeInfo.Guid, out var nodeMoel) &&
if (NodeModels.TryGetValue(nodeInfo.Guid, out var nodeModel) &&
NodeModels.TryGetValue(nodeInfo.ParentNodeGuid, out var containerNode)
&& containerNode is INodeContainer nodeContainer)
{
nodeMoel.ContainerNode = containerNode; // 放置节点
containerNode.ChildrenNode.Add(nodeMoel);
nodeContainer.PlaceNode(nodeMoel);
UIContextOperation?.Invoke(() => OnNodePlace?.Invoke(
new NodePlaceEventArgs(nodeMoel.Guid, containerNode.Guid)));
var result = nodeContainer.PlaceNode(nodeModel);
if (result)
{
await UIContextOperation.InvokeAsync(() => OnNodePlace?.Invoke(
new NodePlaceEventArgs(nodeModel.Guid, containerNode.Guid)));
}
}
}
#endregion
_ = Task.Run(async () =>
#region 确定节点之间的方法调用关系
foreach (var nodeInfo in nodeInfos)
{
await Task.Delay(100);
#region 确定节点之间的方法调用关系
foreach (var nodeInfo in nodeInfos)
{
if (!NodeModels.TryGetValue(nodeInfo.Guid, out NodeModelBase? fromNode))
{
// 不存在对应的起始节点
continue;
}
List<(ConnectionInvokeType connectionType, string[] guids)> allToNodes = [(ConnectionInvokeType.IsSucceed,nodeInfo.TrueNodes),
var fromNodeModel = GuidToModel(nodeInfo.Guid);
if (fromNodeModel is null) continue;
List<(ConnectionInvokeType connectionType, string[] guids)> allToNodes = [(ConnectionInvokeType.IsSucceed,nodeInfo.TrueNodes),
(ConnectionInvokeType.IsFail, nodeInfo.FalseNodes),
(ConnectionInvokeType.IsError, nodeInfo.ErrorNodes),
(ConnectionInvokeType.Upstream, nodeInfo.UpstreamNodes)];
List<(ConnectionInvokeType, NodeModelBase[])> fromNodes = allToNodes.Where(info => info.guids.Length > 0)
.Select(info => (info.connectionType,
info.guids.Where(guid => NodeModels.ContainsKey(guid)).Select(guid => NodeModels[guid])
.ToArray()))
.ToList();
// 遍历每种类型的节点分支（四种）
foreach ((ConnectionInvokeType connectionType, NodeModelBase[] toNodes) item in fromNodes)
{
// 遍历当前类型分支的节点（确认连接关系）
foreach (var toNode in item.toNodes)
{
_ = ConnectInvokeOfNode(fromNode, toNode, item.connectionType); // 加载时确定节点间的连接关系
}
}
}
#endregion
#region 确定节点之间的参数调用关系
foreach (var toNode in NodeModels.Values)
foreach ((ConnectionInvokeType connectionType, string[] toNodeGuids) item in allToNodes)
{
if (toNode.MethodDetails.ParameterDetailss == null)
// 遍历当前类型分支的节点（确认连接关系）
foreach (var toNodeGuid in item.toNodeGuids)
{
continue;
}
for (var i = 0; i < toNode.MethodDetails.ParameterDetailss.Length; i++)
{
var pd = toNode.MethodDetails.ParameterDetailss[i];
if (!string.IsNullOrEmpty(pd.ArgDataSourceNodeGuid)
&& NodeModels.TryGetValue(pd.ArgDataSourceNodeGuid, out var fromNode))
{
_ = ConnectArgSourceOfNodeAsync(fromNode, toNode, pd.ArgDataSourceType, pd.Index);
}
var toNodeModel = GuidToModel(toNodeGuid);
if (toNodeModel is null) continue;
var isSuccessful = ConnectInvokeOfNode(fromNodeModel, toNodeModel, item.connectionType); // 加载时确定节点间的连接关系
}
}
#endregion
});
UIContextOperation?.Invoke(() => OnProjectLoaded?.Invoke(new ProjectLoadedEventArgs()));
return Task.CompletedTask;
//List<(ConnectionInvokeType connectionType, string[] guids)> allToNodes = [(ConnectionInvokeType.IsSucceed,nodeInfo.TrueNodes),
// (ConnectionInvokeType.IsFail, nodeInfo.FalseNodes),
// (ConnectionInvokeType.IsError, nodeInfo.ErrorNodes),
// (ConnectionInvokeType.Upstream, nodeInfo.UpstreamNodes)];
//List<(ConnectionInvokeType, NodeModelBase[])> fromNodes = allToNodes.Where(info => info.guids.Length > 0)
// .Select(info => (info.connectionType,
// info.guids.Where(guid => NodeModels.ContainsKey(guid)).Select(guid => NodeModels[guid])
// .ToArray()))
// .ToList();
// 遍历每种类型的节点分支（四种）
//foreach ((ConnectionInvokeType connectionType, NodeModelBase[] toNodes) item in nodeInfo)
//{
// // 遍历当前类型分支的节点（确认连接关系）
// foreach (var toNode in item.toNodes)
// {
// _ = ConnectInvokeOfNode(fromNode, toNode, item.connectionType); // 加载时确定节点间的连接关系
// }
//}
}
#endregion
#region 确定节点之间的参数调用关系
foreach (var toNode in NodeModels.Values)
{
if (toNode.MethodDetails.ParameterDetailss == null)
{
continue;
}
for (var i = 0; i < toNode.MethodDetails.ParameterDetailss.Length; i++)
{
var pd = toNode.MethodDetails.ParameterDetailss[i];
if (!string.IsNullOrEmpty(pd.ArgDataSourceNodeGuid)
&& NodeModels.TryGetValue(pd.ArgDataSourceNodeGuid, out var fromNode))
{
_ = ConnectArgSourceOfNodeAsync(fromNode, toNode, pd.ArgDataSourceType, pd.Index);
}
}
}
#endregion
await UIContextOperation.InvokeAsync(() =>
{
UIContextOperation?.Invoke(() => OnProjectLoaded?.Invoke(new ProjectLoadedEventArgs()));
});
return;
}
/// <summary>
@@ -925,24 +940,28 @@ namespace Serein.NodeFlow.Env
public async Task<bool> PlaceNodeToContainerAsync(string nodeGuid, string containerNodeGuid)
{
// 获取目标节点与容器节点
var nodeMoel = GuidToModel(nodeGuid);
if (nodeMoel is null ) return false;
var nodeModel = GuidToModel(nodeGuid);
if (nodeModel is null ) return false;
if(nodeMoel.ContainerNode is INodeContainer tmpContainer)
if(nodeModel.ContainerNode is INodeContainer tmpContainer)
{
SereinEnv.WriteLine(InfoType.WARN, $"节点放置失败，节点[{nodeGuid}]已经放置于容器节点[{((NodeModelBase)tmpContainer).Guid}]");
return false;
}
var containerNode = GuidToModel(containerNodeGuid);
var containerNode = GuidToModel(containerNodeGuid); // 获取容器节点
if (containerNode is not INodeContainer nodeContainer) return false;
nodeMoel.ContainerNode = containerNode; // 放置节点
containerNode.ChildrenNode.Add(nodeMoel);
nodeContainer.PlaceNode(nodeMoel);
OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
return true;
var result = nodeContainer.PlaceNode(nodeModel); // 放置在容器节点
if (result)
{
_ = UIContextOperation?.InvokeAsync(() =>
{
OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
});
}
return result;
}
/// <summary>
@@ -952,18 +971,24 @@ namespace Serein.NodeFlow.Env
public async Task<bool> TakeOutNodeToContainerAsync(string nodeGuid)
{
// 获取目标节点与容器节点
var nodeMoel = GuidToModel(nodeGuid);
if (nodeMoel is null) return false;
var nodeModel = GuidToModel(nodeGuid);
if (nodeModel is null) return false;
if(nodeMoel.ContainerNode is not INodeContainer nodeContainer)
if(nodeModel.ContainerNode is not INodeContainer nodeContainer)
{
return false;
}
nodeContainer.TakeOutNode(nodeMoel); // 从容器节点取出
nodeMoel.ContainerNode = null; // 取消映射关系
OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
return true;
var result = nodeContainer.TakeOutNode(nodeModel); // 从容器节点取出
if (result)
{
_ = UIContextOperation?.InvokeAsync(() =>
{
OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
});
}
return result;
}
@@ -1000,7 +1025,7 @@ namespace Serein.NodeFlow.Env
remoteNode.Guid,
JunctionOfConnectionType.Invoke,
pCType, // 对应的连接关系
NodeConnectChangeEventArgs.ConnectChangeType.Remote))); // 通知UI
NodeConnectChangeEventArgs.ConnectChangeType.Remove))); // 通知UI
}
}
@@ -1240,149 +1265,6 @@ namespace Serein.NodeFlow.Env
return Task.FromResult(StartNode?.Guid ?? string.Empty);
}
/// <summary>
/// 中断指定节点，并指定中断等级。
/// </summary>
/// <param name="nodeGuid">被中断的目标节点Guid</param>
/// <param name="interruptClass">中断级别</param>
/// <returns>操作是否成功</returns>
public Task<bool> SetNodeInterruptAsync(string nodeGuid, bool isInterrupt)
{
var nodeModel = GuidToModel(nodeGuid);
if (nodeModel is null)
return Task.FromResult(false);
if (!isInterrupt)
{
nodeModel.CancelInterrupt();
}
else if (isInterrupt)
{
nodeModel.DebugSetting.CancelInterruptCallback?.Invoke();
nodeModel.DebugSetting.GetInterruptTask = async () =>
{
TriggerInterrupt(nodeGuid, "", InterruptTriggerEventArgs.InterruptTriggerType.Monitor);
var result = await ChannelFlowInterrupt.GetOrCreateChannelAsync(nodeGuid);
return result;
};
nodeModel.DebugSetting.CancelInterruptCallback = () =>
{
//nodeModel.DebugSetting.IsInterrupt = false;
ChannelFlowInterrupt.TriggerSignal(nodeGuid);
};
}
//nodeModel.DebugSetting.IsInterrupt = true;
if (OperatingSystem.IsWindows())
{
UIContextOperation?.Invoke(() => OnNodeInterruptStateChange?.Invoke(new NodeInterruptStateChangeEventArgs(nodeGuid, isInterrupt)));
}
return Task.FromResult(true);
}
/// <summary>
/// 添加表达式中断
/// </summary>
/// <param name="key">如果是节点，传入Guid；如果是对象，传入类型FullName</param>
/// <param name="expression">合法的条件表达式</param>
/// <returns></returns>
public Task<bool> AddInterruptExpressionAsync(string key, string expression)
{
if (string.IsNullOrEmpty(expression)) return Task.FromResult(false);
if (dictMonitorObjExpInterrupt.TryGetValue(key, out var condition))
{
condition.Clear(); // 暂时
condition.Add(expression);// 暂时
}
else
{
var exps = new List<string>();
exps.Add(expression);
dictMonitorObjExpInterrupt.TryAdd(key, exps);
}
return Task.FromResult(true);
}
/// <summary>
/// 要监视的对象，以及与其关联的表达式
/// </summary>
private ConcurrentDictionary<string, List<string>> dictMonitorObjExpInterrupt = [];
/// <summary>
/// 设置对象的监视状态
/// </summary>
/// <param name="key">如果是节点，传入Guid；如果是对象，传入类型FullName</param>
/// <param name="isMonitor">ture监视对象；false取消对象监视</param>
/// <returns></returns>
public void SetMonitorObjState(string key, bool isMonitor)
{
if (string.IsNullOrEmpty(key)) { return; }
var isExist = dictMonitorObjExpInterrupt.ContainsKey(key);
if (isExist)
{
if (!isMonitor) // 对象存在且需要不监视
{
dictMonitorObjExpInterrupt.Remove(key, out _);
}
}
else
{
if (isMonitor) // 对象不存在且需要监视，添加在集合中。
{
dictMonitorObjExpInterrupt.TryAdd(key, new List<string>()); ;
}
}
}
/// <summary>
/// 检查一个对象是否处于监听状态，如果是，则传出与该对象相关的表达式（用于中断），如果不是，则返回false。
/// </summary>
/// <param name="key"></param>
/// <param name="exps"></param>
/// <returns></returns>
public Task<(bool, string[])> CheckObjMonitorStateAsync(string key)
{
if (string.IsNullOrEmpty(key))
{
var data = (false, Array.Empty<string>());
return Task.FromResult(data);
}
else
{
var isMonitor = dictMonitorObjExpInterrupt.TryGetValue(key, out var exps);
if (exps is null)
{
var data = (isMonitor, Array.Empty<string>());
return Task.FromResult(data);
}
else
{
var data = (isMonitor, exps.ToArray());
return Task.FromResult(data);
}
}
//if (exps is null)
//{
// var data = (isMonitor, Array.Empty<string>());
// return Task.FromResult(data);
//}
//else
//{
// var data = (isMonitor, exps.ToArray());
// return Task.FromResult(data);
//}
}
/// <summary>
/// 启动器调用，运行到某个节点时触发了监视对象的更新（对象预览视图将会自动更新）
/// </summary>
@@ -1406,16 +1288,16 @@ namespace Serein.NodeFlow.Env
}
/// <summary>
/// 环境执行中断
/// </summary>
/// <returns></returns>
public async Task<CancelType> GetOrCreateGlobalInterruptAsync()
{
IsGlobalInterrupt = true;
var result = await ChannelFlowInterrupt.GetOrCreateChannelAsync(EnvName);
return result;
}
///// <summary>
///// 环境执行中断
///// </summary>
///// <returns></returns>
//public async Task InterruptNode()
//{
// IsGlobalInterrupt = true;
// var result = await ChannelFlowInterrupt.GetOrCreateChannelAsync(EnvName);
// return result;
//}
/// <summary>
/// 记录节点更改数据，防止重复更改
@@ -1642,7 +1524,7 @@ namespace Serein.NodeFlow.Env
toNode.Guid,
JunctionOfConnectionType.Invoke,
connectionType,
NodeConnectChangeEventArgs.ConnectChangeType.Remote)));
NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
}
return true;
}
@@ -1670,7 +1552,7 @@ namespace Serein.NodeFlow.Env
JunctionOfConnectionType.Arg,
argIndex,
ConnectionArgSourceType.GetPreviousNodeData,
NodeConnectChangeEventArgs.ConnectChangeType.Remote)));
NodeConnectChangeEventArgs.ConnectChangeType.Remove)));
}
return true;
}

39
NodeFlow/Env/FlowEnvironmentDecorator.cs
View File

@@ -196,16 +196,7 @@ namespace Serein.NodeFlow.Env
currentFlowEnvironment.ActivateFlipflopNode(nodeGuid);
}
public async Task<bool> AddInterruptExpressionAsync(string key, string expression)
{
return await currentFlowEnvironment.AddInterruptExpressionAsync(key, expression);
}
public async Task<(bool, string[])> CheckObjMonitorStateAsync(string key)
{
return await currentFlowEnvironment.CheckObjMonitorStateAsync(key);
}
/// <summary>
@@ -329,11 +320,7 @@ namespace Serein.NodeFlow.Env
return await currentFlowEnvironment.GetEnvInfoAsync();
}
public async Task<ChannelFlowInterrupt.CancelType> GetOrCreateGlobalInterruptAsync()
{
return await currentFlowEnvironment.GetOrCreateGlobalInterruptAsync();
}
public async Task<SereinProjectData> GetProjectInfoAsync()
{
return await currentFlowEnvironment.GetProjectInfoAsync();
@@ -439,6 +426,24 @@ namespace Serein.NodeFlow.Env
currentFlowEnvironment.WriteLine(type, message, @class);
}
#region MyRegion
#if false
public async Task<bool> AddInterruptExpressionAsync(string key, string expression)
{
return await currentFlowEnvironment.AddInterruptExpressionAsync(key, expression);
}
public async Task<(bool, string[])> CheckObjMonitorStateAsync(string key)
{
return await currentFlowEnvironment.CheckObjMonitorStateAsync(key);
}
public async Task<ChannelFlowInterrupt.CancelType> GetOrCreateGlobalInterruptAsync()
{
return await currentFlowEnvironment.InterruptNode();
}
public void SetMonitorObjState(string key, bool isMonitor)
{
currentFlowEnvironment.SetMonitorObjState(key, isMonitor);
@@ -447,8 +452,10 @@ namespace Serein.NodeFlow.Env
public async Task<bool> SetNodeInterruptAsync(string nodeGuid, bool isInterrupt)
{
return await currentFlowEnvironment.SetNodeInterruptAsync(nodeGuid, isInterrupt);
}
}
#endif
#endregion
public async Task<string> SetStartNodeAsync(string nodeGuid)
{
return await currentFlowEnvironment.SetStartNodeAsync(nodeGuid);

21
NodeFlow/Env/MsgControllerOfClient.cs
View File

@@ -188,6 +188,27 @@ namespace Serein.NodeFlow.Env
{
_ = remoteFlowEnvironment.InvokeTriggerAsync(msgId, state);
}
/// <summary>
/// 放置节点
/// </summary>
/// <param name="msgId"></param>
/// <param name="state"></param>
[AutoSocketHandle(ThemeValue = EnvMsgTheme.PlaceNode, IsReturnValue = false)]
public void PlaceNode([UseMsgId] string msgId, bool state)
{
_ = remoteFlowEnvironment.InvokeTriggerAsync(msgId, state);
}
/// <summary>
/// 取出节点
/// </summary>
/// <param name="msgId"></param>
/// <param name="state"></param>
[AutoSocketHandle(ThemeValue = EnvMsgTheme.TakeOutNode, IsReturnValue = false)]
public void TakeOutNode([UseMsgId] string msgId, bool state)
{
_ = remoteFlowEnvironment.InvokeTriggerAsync(msgId, state);
}
/// <summary>
/// 创建节点之间的调用关系

43
NodeFlow/Env/MsgControllerOfServer.cs
View File

@@ -4,6 +4,7 @@ using Serein.Library.Api;
using Serein.Library.Network.WebSocketCommunication;
using Serein.Library.Network.WebSocketCommunication.Handle;
using Serein.Library.Utils;
using System.Diagnostics.CodeAnalysis;
namespace Serein.NodeFlow.Env
{
@@ -267,7 +268,6 @@ namespace Serein.NodeFlow.Env
}
/// <summary>
/// 退出远程环境
/// </summary>
@@ -298,6 +298,7 @@ namespace Serein.NodeFlow.Env
public void LoadDll(string dllPath)
{
}
/// <summary>
/// 移除DLL
/// </summary>
@@ -334,9 +335,30 @@ namespace Serein.NodeFlow.Env
[AutoSocketHandle(ThemeValue = EnvMsgTheme.RemoveNode)]
public async Task<object> RemoveNode(string nodeGuid)
{
//var result = environment.RemoveNodeAsync(nodeGuid).GetAwaiter().GetResult();
var result = await environment.RemoveNodeAsync(nodeGuid);
//return result;
return new { state = result };
}
/// <summary>
/// 远程从远程环境移除节点
/// </summary>
/// <param name="nodeGuid"></param>
/// <param name="containerNodeGuid"></param>
/// <exception cref="NotImplementedException"></exception>
[AutoSocketHandle(ThemeValue = EnvMsgTheme.PlaceNode)]
public async Task<object> PlaceNode(string nodeGuid, string containerNodeGuid)
{
var result = await environment.PlaceNodeToContainerAsync(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)
{
var result = await environment.TakeOutNodeToContainerAsync(nodeGuid);
return new { state = result };
}
@@ -528,12 +550,13 @@ namespace Serein.NodeFlow.Env
/// </summary>
/// <param name="nodeGuid"></param>
[AutoSocketHandle(ThemeValue = EnvMsgTheme.SetStartNode)]
public void SetStartNode(string nodeGuid)
public async Task<string> SetStartNode([NotNull]string nodeGuid)
{
environment.SetStartNodeAsync(nodeGuid);
return await environment.SetStartNodeAsync(nodeGuid);
}
#if false
/// <summary>
/// 中断指定节点，并指定中断等级。
@@ -544,10 +567,9 @@ namespace Serein.NodeFlow.Env
[AutoSocketHandle(ThemeValue = EnvMsgTheme.SetNodeInterrupt)]
public async Task<bool> SetNodeInterruptAsync(string nodeGuid, bool isInterrupt)
{
return await this.environment.SetNodeInterruptAsync(nodeGuid, isInterrupt);
return false;
// return await this.environment.SetNodeInterruptAsync(nodeGuid, isInterrupt);
}
@@ -573,7 +595,8 @@ namespace Serein.NodeFlow.Env
public void SetMonitorObjState(string key, bool isMonitor)
{
environment.SetMonitorObjState(key, isMonitor);
}
}
#endif
/// <summary>

59
NodeFlow/Env/RemoteFlowEnvironment.cs
View File

@@ -12,8 +12,6 @@ using System.Threading.Channels;
namespace Serein.NodeFlow.Env
{
/// <summary>
/// 远程流程环境
/// </summary>
@@ -638,7 +636,7 @@ namespace Serein.NodeFlow.Env
toNodeGuid,
JunctionOfConnectionType.Invoke,
invokeType,
NodeConnectChangeEventArgs.ConnectChangeType.Remote));
NodeConnectChangeEventArgs.ConnectChangeType.Remove));
});
}
return result;
@@ -667,7 +665,7 @@ namespace Serein.NodeFlow.Env
JunctionOfConnectionType.Arg,
argIndex,
ConnectionArgSourceType.GetPreviousNodeData,
NodeConnectChangeEventArgs.ConnectChangeType.Remote)); // 通知UI
NodeConnectChangeEventArgs.ConnectChangeType.Remove)); // 通知UI
});
}
return result;
@@ -819,7 +817,20 @@ namespace Serein.NodeFlow.Env
});
if (isSuuccess)
{
OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
var nodeModel = GuidToModel(nodeGuid); // 获取目标节点
if (nodeModel is null) return false;
var containerNode = GuidToModel(containerNodeGuid); // 获取容器节点
if (containerNode is not INodeContainer nodeContainer) return false;
var result = nodeContainer.PlaceNode(nodeModel);
if (result)
{
// 通知UI更改
UIContextOperation.Invoke(() =>
{
OnNodePlace?.Invoke(new NodePlaceEventArgs(nodeGuid, containerNodeGuid)); // 通知UI更改节点放置位置
});
}
return result;
}
return isSuuccess;
}
@@ -836,7 +847,22 @@ namespace Serein.NodeFlow.Env
});
if (isSuuccess)
{
OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
var nodeModel = GuidToModel(nodeGuid); // 获取目标节点
if (nodeModel is null) return false;
if (nodeModel.ContainerNode is not INodeContainer nodeContainer)
{
return false;
}
var result = nodeContainer.TakeOutNode(nodeModel); // 从容器节点取出
if (result)
{
// 通知UI更改
UIContextOperation.Invoke(() =>
{
OnNodeTakeOut?.Invoke(new NodeTakeOutEventArgs(nodeGuid)); // 重新放置在画布上
});
}
return result;
}
return isSuuccess;
}
@@ -1027,7 +1053,20 @@ namespace Serein.NodeFlow.Env
#region 私有方法
private NodeModelBase? GuidToModel(string nodeGuid)
{
if (string.IsNullOrEmpty(nodeGuid))
{
//throw new ArgumentNullException("not contains - Guid没有对应节点:" + (nodeGuid));
return null;
}
if (!NodeModels.TryGetValue(nodeGuid, out NodeModelBase? nodeModel) || nodeModel is null)
{
//throw new ArgumentNullException("null - Guid存在对应节点,但节点为null:" + (nodeGuid));
return null;
}
return nodeModel;
}
private bool TryAddNode(NodeModelBase nodeModel)
{
NodeModels[nodeModel.Guid] = nodeModel;
@@ -1190,11 +1229,7 @@ namespace Serein.NodeFlow.Env
return null;
}
public async Task<ChannelFlowInterrupt.CancelType> GetOrCreateGlobalInterruptAsync()
{
this.WriteLine(InfoType.INFO, "远程环境尚未实现的接口：GetOrCreateGlobalInterruptAsync");
return ChannelFlowInterrupt.CancelType.Error;
}
public bool TryGetMethodDetailsInfo(string libraryName, string methodName, out MethodDetailsInfo mdInfo)
{

10
NodeFlow/FlowStarter.cs
View File

@@ -403,8 +403,8 @@ namespace Serein.NodeFlow
context.SetPreviousNode(nextNodes[i], singleFlipFlopNode);
if (nextNodes[i].DebugSetting.IsInterrupt) // 执行触发前
{
var cancelType = await nextNodes[i].DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{nextNodes[i].MethodDetails.MethodName}]中断已{cancelType}，开始执行后继分支");
await nextNodes[i].DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{nextNodes[i].MethodDetails.MethodName}]中断已取消，开始执行后继分支");
}
await nextNodes[i].StartFlowAsync(context); // 启动执行触发器后继分支的节点
}
@@ -421,8 +421,8 @@ namespace Serein.NodeFlow
context.SetPreviousNode(nextNodes[i], singleFlipFlopNode);
if (nextNodes[i].DebugSetting.IsInterrupt) // 执行触发前
{
var cancelType = await nextNodes[i].DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{nextNodes[i].MethodDetails.MethodName}]中断已{cancelType}，开始执行后继分支");
await nextNodes[i].DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{nextNodes[i].MethodDetails.MethodName}]中断已取消，开始执行后继分支");
}
await nextNodes[i].StartFlowAsync(context); // 启动执行触发器后继分支的节点
}
@@ -442,7 +442,7 @@ namespace Serein.NodeFlow
catch (Exception ex)
{
SereinEnv.WriteLine(InfoType.ERROR, $"触发器[{singleFlipFlopNode.Guid}]异常。"+ ex.Message);
await Task.Delay(100);
await Task.Delay(1000);
}
}

9
NodeFlow/Model/SingleActionNode.cs
View File

@@ -14,14 +14,5 @@ namespace Serein.NodeFlow.Model
}
/// <summary>
/// 执行方法
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override Task<object> ExecutingAsync(IDynamicContext context)
{
return base.ExecutingAsync(context);
}
}
}

7
NodeFlow/Model/SingleFlipflopNode.cs
View File

@@ -1,7 +1,6 @@
using Serein.Library.Api;
using Serein.Library;
using Serein.Library.Utils;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.NodeFlow.Model
{
@@ -28,8 +27,8 @@ namespace Serein.NodeFlow.Model
if (DebugSetting.IsInterrupt) // 执行触发前
{
string guid = this.Guid.ToString();
var cancelType = await this.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已{cancelType}，开始执行后继分支");
await this.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{this.MethodDetails.MethodName}]中断已取消，开始执行后继分支");
}
#endregion
@@ -40,7 +39,7 @@ namespace Serein.NodeFlow.Model
}
object instance = md.ActingInstance;
var args = await GetParametersAsync(context, this);
var args = await GetParametersAsync(context);
// 因为这里会返回不确定的泛型 IFlipflopContext<TRsult>
// 而我们只需要获取到 State 和 Value（返回的数据）
// 所以使用 dynamic 类型接收

59
NodeFlow/Model/SingleGlobalDataNode.cs
View File

@@ -23,7 +23,7 @@ namespace Serein.NodeFlow.Model
/// <summary>
/// 表达式
/// </summary>
[PropertyInfo(IsNotification = true, CustomCodeAtStart = "ChangeName(value);")]
[PropertyInfo(IsNotification = true, CustomCodeAtStart = "// ChangeName(value);")]
private string _keyName;
}
@@ -52,42 +52,51 @@ namespace Serein.NodeFlow.Model
private NodeModelBase? DataNode;
public void PlaceNode(NodeModelBase nodeModel)
public bool PlaceNode(NodeModelBase nodeModel)
{
// 全局数据节点只有一个子控件
if (DataNode is not null)
if(DataNode is null)
{
_ = Task.Run(async () =>
{
await this.Env.RemoveNodeAsync(DataNode?.Guid);
DataNode = nodeModel;
});
// 放置节点
nodeModel.ContainerNode = this;
ChildrenNode.Add(nodeModel);
DataNode = nodeModel;
return true;
}
else
{
DataNode = nodeModel;
// 全局数据节点只有一个子控件
return false;
}
}
public void TakeOutAll()
public bool TakeOutNode(NodeModelBase nodeModel)
{
if (ChildrenNode.Contains(nodeModel))
{
ChildrenNode.Remove(nodeModel);
nodeModel.ContainerNode = null;
DataNode = null;
return true;
}
else
{
return false;
}
}
public async void TakeOutAll()
{
foreach (var nodeModel in ChildrenNode)
{
await nodeModel.Env.TakeOutNodeToContainerAsync(nodeModel.Guid);
}
DataNode = null;
}
public void TakeOutNode(NodeModelBase nodeModel)
{
DataNode = null;
}
/// <summary>
/// 设置数据节点
/// </summary>
/// <param name="dataNode"></param>
//public void SetDataNode(NodeModelBase dataNode)
//{
// DataNodeGuid = dataNode.Guid;
//}
private void ChangeName(string newName)
{
if(SereinEnv.GetFlowGlobalData(_keyName) == null)

2
NodeFlow/Model/SingleScriptNode.cs
View File

@@ -140,7 +140,7 @@ namespace Serein.NodeFlow.Model
/// <returns></returns>
public override async Task<object?> ExecutingAsync(IDynamicContext context)
{
var @params = await NodeModelBase.GetParametersAsync(context, this);
var @params = await GetParametersAsync(context);
ScriptFlowApi.Context= context;
context.AddOrUpdate($"{context.Guid}_{this.Guid}_Params", @params[0]); // 后面再改

2
Serein.Library.MyGenerator/ParameterDetailsPropertyGenerator.cs
View File

@@ -125,7 +125,7 @@ namespace Serein.Library.NodeGenerator
sb.AppendLine($"using System.Collections.Generic;");
sb.AppendLine($"using Serein.Library;");
sb.AppendLine($"using Serein.Library.Api;");
sb.AppendLine($"using static Serein.Library.Utils.ChannelFlowInterrupt;");
//sb.AppendLine($"using static Serein.Library.Utils.ChannelFlowInterrupt;");
sb.AppendLine($"");
sb.AppendLine($"namespace {namespaceName}");
sb.AppendLine("{");

2
WorkBench/App.xaml.cs
View File

@@ -24,7 +24,7 @@ namespace Serein.Workbench
void LoadLocalProject()
{
#if DEBUG
if (1 == 11)
if (1 == 1)
{
// 这里是我自己的测试代码，你可以删除
string filePath;

80
WorkBench/MainWindow.xaml.cs
View File

@@ -198,7 +198,7 @@ namespace Serein.Workbench
EnvDecorator.OnStartNodeChange += FlowEnvironment_StartNodeChangeEvent;
EnvDecorator.OnNodeConnectChange += FlowEnvironment_NodeConnectChangeEvemt;
EnvDecorator.OnNodeCreate += FlowEnvironment_NodeCreateEvent;
EnvDecorator.OnNodeRemove += FlowEnvironment_NodeRemoteEvent;
EnvDecorator.OnNodeRemove += FlowEnvironment_NodeRemoveEvent;
EnvDecorator.OnNodePlace += EnvDecorator_OnNodePlaceEvent;
EnvDecorator.OnNodeTakeOut += EnvDecorator_OnNodeTakeOutEvent;
EnvDecorator.OnFlowRunComplete += FlowEnvironment_OnFlowRunCompleteEvent;
@@ -228,7 +228,7 @@ namespace Serein.Workbench
EnvDecorator.OnStartNodeChange -= FlowEnvironment_StartNodeChangeEvent;
EnvDecorator.OnNodeConnectChange -= FlowEnvironment_NodeConnectChangeEvemt;
EnvDecorator.OnNodeCreate -= FlowEnvironment_NodeCreateEvent;
EnvDecorator.OnNodeRemove -= FlowEnvironment_NodeRemoteEvent;
EnvDecorator.OnNodeRemove -= FlowEnvironment_NodeRemoveEvent;
EnvDecorator.OnNodePlace -= EnvDecorator_OnNodePlaceEvent;
EnvDecorator.OnNodeTakeOut -= EnvDecorator_OnNodeTakeOutEvent;
EnvDecorator.OnFlowRunComplete -= FlowEnvironment_OnFlowRunCompleteEvent;
@@ -247,7 +247,7 @@ namespace Serein.Workbench
}
#region 窗体加载方法
private void Window_Loaded(object sender, RoutedEventArgs e)
private async void Window_Loaded(object sender, RoutedEventArgs e)
{
var currentPath = System.IO.Directory.GetCurrentDirectory(); // 当前目录
var baseLibraryFilePath = Path.Combine(currentPath, FlowLibraryManagement.SereinBaseLibrary);
@@ -260,7 +260,7 @@ namespace Serein.Workbench
{
try
{
_ = Task.Run(() =>
await Task.Run(() =>
{
EnvDecorator.LoadProject(new FlowEnvInfo { Project = App.FlowProjectData }, App.FileDataPath); // 加载项目
});
@@ -553,7 +553,7 @@ namespace Serein.Workbench
if (toNodeControl is FlipflopNodeControl flipflopControl
&& flipflopControl?.ViewModel?.NodeModel is NodeModelBase nodeModel) // 某个节点连接到了触发器，尝试从全局触发器视图中移除该触发器
{
NodeTreeViewer.RemoteGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
NodeTreeViewer.RemoveGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
}
Connections.Add(connection);
fromNodeControl.AddCnnection(connection);
@@ -563,7 +563,7 @@ namespace Serein.Workbench
}
#endregion
#region 移除连接
else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remote) // 移除连接
else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remove) // 移除连接
{
// 需要移除连接
var removeConnections = Connections.Where(c =>
@@ -639,7 +639,7 @@ namespace Serein.Workbench
}
#endregion
#region 移除连接
else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remote) // 移除连接
else if (eventArgs.ChangeType == NodeConnectChangeEventArgs.ConnectChangeType.Remove) // 移除连接
{
// 需要移除连接
var removeConnections = Connections.Where(c => c.Start.MyNode.Guid.Equals(fromNodeGuid)
@@ -674,7 +674,7 @@ namespace Serein.Workbench
/// 节点移除事件
/// </summary>
/// <param name="eventArgs"></param>
private void FlowEnvironment_NodeRemoteEvent(NodeRemoveEventArgs eventArgs)
private void FlowEnvironment_NodeRemoveEvent(NodeRemoveEventArgs eventArgs)
{
var nodeGuid = eventArgs.NodeGuid;
if (!TryGetControl(nodeGuid, out var nodeControl))
@@ -696,7 +696,7 @@ namespace Serein.Workbench
var node = flipflopControl?.ViewModel?.NodeModel;
if (node is not null)
{
NodeTreeViewer.RemoteGlobalFlipFlop(node); // 从全局触发器树树视图中移除
NodeTreeViewer.RemoveGlobalFlipFlop(node); // 从全局触发器树树视图中移除
}
}
@@ -714,23 +714,24 @@ namespace Serein.Workbench
/// <exception cref="NotImplementedException"></exception>
private void FlowEnvironment_NodeCreateEvent(NodeCreateEventArgs eventArgs)
{
if (eventArgs.NodeModel is not NodeModelBase nodeModelBase)
var nodeModel = eventArgs.NodeModel;
if (NodeControls.ContainsKey(nodeModel.Guid))
{
SereinEnv.WriteLine(InfoType.WARN, "OnNodeCreateEvent事件接收到意外的返回值");
SereinEnv.WriteLine(InfoType.WARN, $"OnNodeCreateEvent 事件接收到意外的返回值：节点Guid重复 - {nodeModel.Guid}");
return;
}
PositionOfUI position = eventArgs.Position;
if(!NodeMVVMManagement.TryGetType(nodeModelBase.ControlType, out var nodeMVVM))
if(!NodeMVVMManagement.TryGetType(nodeModel.ControlType, out var nodeMVVM))
{
SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModelBase.ControlType}节点，节点类型尚未注册。");
SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModel.ControlType}节点，节点类型尚未注册。");
return;
}
if(nodeMVVM.ControlType == null
|| nodeMVVM.ViewModelType == null)
{
SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModelBase.ControlType}节点，UI类型尚未注册（请通过 NodeMVVMManagement.RegisterUI() 方法进行注册）。");
SereinEnv.WriteLine(InfoType.INFO, $"无法创建{nodeModel.ControlType}节点，UI类型尚未注册（请通过 NodeMVVMManagement.RegisterUI() 方法进行注册）。");
return;
}
@@ -740,7 +741,7 @@ namespace Serein.Workbench
{
nodeControl = CreateNodeControl(nodeMVVM.ControlType, // 控件UI类型
nodeMVVM.ViewModelType, // 控件VIewModel类型
nodeModelBase, // 控件数据实体
nodeModel, // 控件数据实体
nodeCanvas); // 所在画布
}
catch (Exception ex)
@@ -749,7 +750,7 @@ namespace Serein.Workbench
return;
}
NodeControls.TryAdd(nodeModelBase.Guid, nodeControl); // 添加到
NodeControls.TryAdd(nodeModel.Guid, nodeControl); // 添加到
if (TryPlaceNodeInRegion(nodeControl, position, out var regionControl)) // 判断添加到区域容器
{
// 通知运行环境调用加载节点子项的方法
@@ -764,7 +765,7 @@ namespace Serein.Workbench
#region 节点树视图
if (nodeModelBase.ControlType == NodeControlType.Flipflop)
if (nodeModel.ControlType == NodeControlType.Flipflop)
{
var node = nodeControl?.ViewModel?.NodeModel;
if (node is not null)
@@ -779,7 +780,7 @@ namespace Serein.Workbench
}
/// <summary>
/// 节点父子关系发生改变
/// 放置一个节点
/// </summary>
/// <param name="eventArgs"></param>
/// <exception cref="NotImplementedException"></exception>
@@ -802,6 +803,10 @@ namespace Serein.Workbench
nodeControl.PlaceToContainer(containerControl); // 放置在容器节点中
}
/// <summary>
/// 取出一个节点
/// </summary>
/// <param name="eventArgs"></param>
private void EnvDecorator_OnNodeTakeOutEvent(NodeTakeOutEventArgs eventArgs)
{
string nodeGuid = eventArgs.NodeGuid;
@@ -1170,34 +1175,13 @@ namespace Serein.Workbench
}));
}
#region 右键菜单功能 - 中断
contextMenu.Items.Add(CreateMenuItem("在此中断", async (s, e) =>
{
if ((s is MenuItem menuItem) && menuItem is not null)
{
if (nodeControl?.ViewModel?.NodeModel?.DebugSetting?.IsInterrupt == true)
{
await EnvDecorator.SetNodeInterruptAsync(nodeGuid,false);
nodeControl.ViewModel.IsInterrupt = false;
menuItem.Header = "取消中断";
}
else
{
nodeControl!.ViewModel!.IsInterrupt = true;
await EnvDecorator.SetNodeInterruptAsync(nodeGuid, true);
menuItem.Header = "在此中断";
}
}
}));
#endregion
contextMenu.Items.Add(CreateMenuItem("设为起点", (s, e) => EnvDecorator.SetStartNodeAsync(nodeGuid)));
contextMenu.Items.Add(CreateMenuItem("删除", (s, e) => EnvDecorator.RemoveNodeAsync(nodeGuid)));
contextMenu.Items.Add(CreateMenuItem("删除", async (s, e) =>
{
var result = await EnvDecorator.RemoveNodeAsync(nodeGuid);
}));
#region 右键菜单功能 - 控件对齐
@@ -1642,7 +1626,7 @@ namespace Serein.Workbench
{
if (ViewObjectViewer.MonitorObj is null)
{
EnvDecorator.SetMonitorObjState(key, true); // 通知环境，该节点的数据更新后需要传到UI
// EnvDecorator.SetMonitorObjState(key, true); // 通知环境，该节点的数据更新后需要传到UI
return;
}
if (instance is null)
@@ -1656,8 +1640,8 @@ namespace Serein.Workbench
}
else
{
EnvDecorator.SetMonitorObjState(ViewObjectViewer.MonitorKey,false); // 取消对旧节点的监视
EnvDecorator.SetMonitorObjState(key, true); // 通知环境，该节点的数据更新后需要传到UI
//EnvDecorator.SetMonitorObjState(ViewObjectViewer.MonitorKey,false); // 取消对旧节点的监视
//EnvDecorator.SetMonitorObjState(key, true); // 通知环境，该节点的数据更新后需要传到UI
}
}
#endregion
@@ -2499,7 +2483,7 @@ namespace Serein.Workbench
}
else
{
NodeTreeViewer.RemoteGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
NodeTreeViewer.RemoveGlobalFlipFlop(nodeModel); // 从全局触发器树树视图中移除
}
}
}

2
WorkBench/Themes/NodeTreeViewControl.xaml.cs
View File

@@ -42,7 +42,7 @@ namespace Serein.Workbench.Themes
viewer.RefreshTree();
}
}
public void RemoteGlobalFlipFlop(NodeModelBase nodeModel)
public void RemoveGlobalFlipFlop(NodeModelBase nodeModel)
{
if (globalFlipflopNodes.TryGetValue(nodeModel.Guid, out var viewer))
{

22
WorkBench/Themes/ObjectViewerControl.xaml.cs
View File

@@ -132,17 +132,17 @@ namespace Serein.Workbench.Themes
/// <param name="e"></param>
private async void UpMonitorExpressionButton_Click(object sender, RoutedEventArgs e)
{
if (FlowEnvironment is not null && await FlowEnvironment.AddInterruptExpressionAsync(monitorKey, MonitorExpression)) // 对象预览器尝试添加中断表达式
{
if (string.IsNullOrEmpty(MonitorExpression))
{
ExpressionTextBox.Text = "表达式已清空";
}
else
{
UpMonitorExpressionButton.Content = "更新监视表达式";
}
}
//if (FlowEnvironment is not null && await FlowEnvironment.AddInterruptExpressionAsync(monitorKey, MonitorExpression)) // 对象预览器尝试添加中断表达式
//{
// if (string.IsNullOrEmpty(MonitorExpression))
// {
// ExpressionTextBox.Text = "表达式已清空";
// }
// else
// {
// UpMonitorExpressionButton.Content = "更新监视表达式";
// }
//}
}
private TreeViewItem? LoadTree(object? obj)

4
Workbench/Node/INodeContainerControl.cs
View File

@@ -17,13 +17,13 @@ namespace Serein.Workbench.Node
/// 放置一个节点
/// </summary>
/// <param name="nodeControl"></param>
void PlaceNode(NodeControlBase nodeControl);
bool PlaceNode(NodeControlBase nodeControl);
/// <summary>
/// 取出一个节点
/// </summary>
/// <param name="nodeControl"></param>
void TakeOutNode(NodeControlBase nodeControl);
bool TakeOutNode(NodeControlBase nodeControl);
/// <summary>
/// 取出所有节点（用于删除容器）

22
Workbench/Node/NodeControlBase.cs
View File

@@ -53,8 +53,13 @@ namespace Serein.Workbench.Node.View
public void PlaceToContainer(INodeContainerControl nodeContainerControl)
{
this.nodeContainerControl = nodeContainerControl;
NodeCanvas.Children.Remove(this); // 从画布上移除
nodeContainerControl.PlaceNode(this);
NodeCanvas.Children.Remove(this); // 临时从画布上移除
var result = nodeContainerControl.PlaceNode(this);
if (!result) // 检查是否放置成功，如果不成功，需要重新添加回来
{
NodeCanvas.Children.Add(this); // 从画布上移除
}
}
/// <summary>
@@ -62,8 +67,17 @@ namespace Serein.Workbench.Node.View
/// </summary>
public void TakeOutContainer()
{
nodeContainerControl.TakeOutNode(this);
NodeCanvas.Children.Add(this); // 重新添加到画布上
var result = nodeContainerControl.TakeOutNode(this); // 从控件取出
if (result) // 移除成功时才添加到画布上
{
NodeCanvas.Children.Add(this); // 重新添加到画布上
if (nodeContainerControl is NodeControlBase containerControl)
{
this.ViewModel.NodeModel.Position.X = containerControl.ViewModel.NodeModel.Position.X + containerControl.Width + 10;
this.ViewModel.NodeModel.Position.Y = containerControl.ViewModel.NodeModel.Position.Y;
}
}
}
/// <summary>

15
Workbench/Node/View/GlobalDataControl.xaml.cs
View File

@@ -58,15 +58,24 @@ namespace Serein.Workbench.Node.View
JunctionControlBase[] INodeJunction.ArgDataJunction => throw new NotImplementedException();
public void PlaceNode(NodeControlBase nodeControl)
public bool PlaceNode(NodeControlBase nodeControl)
{
//GlobalDataPanel.Children.Clear();
if (GlobalDataPanel.Children.Contains(nodeControl))
{
return false;
}
GlobalDataPanel.Children.Add(nodeControl);
return true;
}
public void TakeOutNode(NodeControlBase nodeControl)
public bool TakeOutNode(NodeControlBase nodeControl)
{
if (!GlobalDataPanel.Children.Contains(nodeControl))
{
return false;
}
GlobalDataPanel.Children.Remove(nodeControl);
return true;
}
public void TakeOutAll()