尝试使用源生成器规范NodeModel代码逻辑

This commit is contained in:
fengjiayi
2024-10-20 12:10:57 +08:00
parent 9931fa7436
commit e38833a58c
127 changed files with 5173 additions and 1839 deletions

View File

@@ -6,7 +6,7 @@ using System.Text;
using System.Threading.Tasks;
using static Serein.Library.Utils.EmitHelper;
namespace Serein.Library.Entity
namespace Serein.Library
{
/// <summary>
/// Emit创建的委托描述用于WebApi、WebSocket、NodeFlow动态调用方法的场景。
@@ -22,7 +22,7 @@ namespace Serein.Library.Entity
public DelegateDetails(EmitMethodType EmitMethodType, Delegate EmitDelegate)
{
this._emitMethodType = EmitMethodType;
this._emitDelegate = EmitDelegate;
this._emitDelegate = EmitDelegate;
}
/// <summary>
/// 更新委托方法
@@ -37,42 +37,42 @@ namespace Serein.Library.Entity
private Delegate _emitDelegate;
private EmitMethodType _emitMethodType;
/// <summary>
/// <para>普通方法Func&lt;object,object[],object&gt;</para>
/// <para>异步方法Func&lt;object,object[],Task&gt;</para>
/// <para>异步有返回值方法Func&lt;object,object[],Task&lt;object&gt;&gt;</para>
/// </summary>
public Delegate EmitDelegate { get => _emitDelegate; }
/// <summary>
/// 表示Emit构造的委托类型
/// </summary>
public EmitMethodType EmitMethodType { get => _emitMethodType; }
///// <summary>
///// <para>普通方法Func&lt;object,object[],object&gt;</para>
///// <para>异步方法Func&lt;object,object[],Task&gt;</para>
///// <para>异步有返回值方法Func&lt;object,object[],Task&lt;object&gt;&gt;</para>
///// </summary>
//public Delegate EmitDelegate { get => _emitDelegate; }
///// <summary>
///// 表示Emit构造的委托类型
///// </summary>
//public EmitMethodType EmitMethodType { get => _emitMethodType; }
/// <summary>
/// <para>使用的实例必须能够正确调用该委托,传入的参数也必须符合方法入参信息。</para>
/// </summary>
/// <param name="instance">实例</param>
/// <param name="args">入参</param>
/// <param name="instance">拥有符合委托签名的方法信息的实例</param>
/// <param name="args">如果方法没有入参,也需要传入一个空数组</param>
/// <returns>void方法自动返回null</returns>
public async Task<object> InvokeAsync(object instance, object[] args)
{
if(args is null)
{
args = new object[0];
args = Array.Empty<object>();
}
object result = null;
try
{
if (EmitMethodType == EmitMethodType.HasResultTask && EmitDelegate is Func<object, object[], Task<object>> hasResultTask)
if (_emitMethodType == EmitMethodType.HasResultTask && _emitDelegate is Func<object, object[], Task<object>> hasResultTask)
{
result = await hasResultTask(instance, args);
}
else if (EmitMethodType == EmitMethodType.Task && EmitDelegate is Func<object, object[], Task> task)
else if (_emitMethodType == EmitMethodType.Task && _emitDelegate is Func<object, object[], Task> task)
{
await task.Invoke(instance, args);
result = null;
}
else if (EmitMethodType == EmitMethodType.Func && EmitDelegate is Func<object, object[], object> func)
else if (_emitMethodType == EmitMethodType.Func && _emitDelegate is Func<object, object[], object> func)
{
result = func.Invoke(instance, args);
}

View File

@@ -1,143 +0,0 @@
using Serein.Library.Api;
using Serein.Library.Enums;
using System;
using System.Linq;
namespace Serein.Library.Entity
{
/// <summary>
/// 方法描述信息
/// </summary>
public class MethodDetailsInfo
{
/// <summary>
/// 属于哪个DLL文件
/// </summary>
public string LibraryName { get; set; }
/// <summary>
/// 方法名称
/// </summary>
public string MethodName { get; set; }
/// <summary>
/// 节点类型
/// </summary>
public NodeType NodeType { get; set; }
/// <summary>
/// 方法说明
/// </summary>
public string MethodTips { get; set; }
/// <summary>
/// 参数内容
/// </summary>
public ParameterDetailsInfo[] ParameterDetailsInfos { get; set; }
/// <summary>
/// 出参类型
/// </summary>
public string ReturnTypeFullName { get; set; }
}
/// <summary>
/// 每个节点有独自的MethodDetails实例
/// </summary>
public class MethodDetails
{
/// <summary>
/// 转为信息
/// </summary>
/// <returns></returns>
public MethodDetailsInfo ToInfo()
{
return new MethodDetailsInfo
{
MethodName = MethodName,
MethodTips = MethodTips,
NodeType = MethodDynamicType,
ParameterDetailsInfos = this.ParameterDetailss.Select(p => p.ToInfo()).ToArray(),
ReturnTypeFullName = ReturnType.FullName,
};
}
/// <summary>
/// 从DLL拖动出来时拷贝新的实例
/// </summary>
/// <returns></returns>
public MethodDetails Clone()
{
return new MethodDetails
{
ActingInstance = ActingInstance,
ActingInstanceType = ActingInstanceType,
MethodDynamicType = MethodDynamicType,
MethodTips = MethodTips,
ReturnType = ReturnType,
MethodName = MethodName,
MethodLockName = MethodLockName,
IsProtectionParameter = IsProtectionParameter,
ParameterDetailss = ParameterDetailss?.Select(it => it.Clone()).ToArray(),
};
}
/// <summary>
/// 是否保护参数(仅视觉效果参数,不影响运行实现)
/// </summary>
public bool IsProtectionParameter { get; set; } = false;
/// <summary>
/// 作用实例的类型(多个相同的节点将拥有相同的类型)
/// </summary>
public Type ActingInstanceType { get; set; }
/// <summary>
/// 作用实例(多个相同的节点将会共享同一个实例)
/// </summary>
public object ActingInstance { get; set; }
/// <summary>
/// 方法名称
/// </summary>
public string MethodName { get; set; }
/// <summary>
/// 节点类型
/// </summary>
public NodeType MethodDynamicType { get; set; }
/// <summary>
/// 锁名称(暂未实现)
/// </summary>
public string MethodLockName { get; set; }
/// <summary>
/// 方法说明
/// </summary>
public string MethodTips { get; set; }
/// <summary>
/// 参数描述
/// </summary>
public ParameterDetails[] ParameterDetailss { get; set; }
/// <summary>
/// 出参类型
/// </summary>
public Type ReturnType { get; set; }
}
}

View File

@@ -0,0 +1,18 @@
using Serein.Library;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.Library
{
/// <summary>
/// 拖拽创建节点使用的数据
/// </summary>
public class MoveNodeData
{
public NodeControlType NodeControlType { get; set; }
public MethodDetailsInfo MethodDetailsInfo { get; set; }
}
}

View File

@@ -4,7 +4,7 @@ using System.Text;
using System.Threading.Tasks;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.Library.Entity
namespace Serein.Library
{
/// <summary>
/// 节点调试设置,用于中断节点的运行
@@ -12,7 +12,7 @@ namespace Serein.Library.Entity
public class NodeDebugSetting
{
/// <summary>
/// 是否使能(调试中断功能)
/// 是否使能
/// </summary>
public bool IsEnable { get; set; } = true;
@@ -48,10 +48,6 @@ namespace Serein.Library.Entity
/// </summary>
Branch,
/// <summary>
/// 分组中断,中断进入指定节点分组的分支。(暂未实现相关)
/// </summary>
// Group,
/// <summary>
/// 全局中断,中断全局所有节点的运行。(暂未实现相关)
/// </summary>
Global,

View File

@@ -3,19 +3,31 @@ using System.Collections.Generic;
using System.Reflection;
using System.Text;
namespace Serein.Library.Entity
namespace Serein.Library
{
/// <summary>
/// 节点DLL依赖类如果一个项目中引入了多个DLL需要放置在同一个文件夹中
/// </summary>
public class NodeLibrary
{
/// <summary>
/// 文件名
/// </summary>
public string FileName { get; set; }
/// <summary>
/// 路径
/// </summary>
public string Path { get; set; }
public string FilePath { get; set; }
public string Name{ get; set; }
/// <summary>
/// 依赖类的名称
/// </summary>
public string FullName{ get; set; }
/// <summary>
/// 对应的程序集
/// </summary>
public Assembly Assembly { get; set; }
}

View File

@@ -1,225 +0,0 @@
using Serein.Library.Api;
using Serein.Library.Entity;
using Serein.Library.Enums;
using System;
using System.Collections.Generic;
using System.Threading;
namespace Serein.NodeFlow.Base
{
/// <summary>
/// 节点基类(数据):条件控件,动作控件,条件区域,动作区域
/// </summary>
public abstract partial class NodeModelBase : IDynamicFlowNode
{
public NodeModelBase()
{
PreviousNodes = new Dictionary<ConnectionType, List<NodeModelBase>>();
SuccessorNodes = new Dictionary<ConnectionType, List<NodeModelBase>>();
foreach (ConnectionType ctType in NodeStaticConfig.ConnectionTypes)
{
PreviousNodes[ctType] = new List<NodeModelBase>();
SuccessorNodes[ctType] = new List<NodeModelBase>();
}
DebugSetting = new NodeDebugSetting();
}
/// <summary>
/// 调试功能
/// </summary>
public NodeDebugSetting DebugSetting { get; set; }
/// <summary>
/// 节点对应的控件类型
/// </summary>
public NodeControlType ControlType { get; set; }
/// <summary>
/// 方法描述对应DLL的方法
/// </summary>
public MethodDetails MethodDetails { get; set; }
/// <summary>
/// 节点guid
/// </summary>
public string Guid { get; set; }
/// <summary>
/// 显示名称
/// </summary>
public string DisplayName { get; set; } = string.Empty;
/// <summary>
/// 是否为起点控件
/// </summary>
public bool IsStart { get; set; }
/// <summary>
/// 运行时的上一节点
/// </summary>
public NodeModelBase PreviousNode { get; set; }
/// <summary>
/// 不同分支的父节点
/// </summary>
public Dictionary<ConnectionType,List<NodeModelBase>> PreviousNodes { get; }
/// <summary>
/// 不同分支的子节点
/// </summary>
public Dictionary<ConnectionType,List<NodeModelBase>> SuccessorNodes { get; }
/// <summary>
/// 当前节点执行完毕后需要执行的下一个分支的类别
/// </summary>
public ConnectionType NextOrientation { get; set; } = ConnectionType.None;
/// <summary>
/// 运行时的异常信息(仅在 FlowState 为 Error 时存在对应值)
/// </summary>
public Exception RuningException { get; set; } = null;
/// <summary>
/// 控制FlowData在同一时间只会被同一个线程更改。
/// </summary>
private readonly ReaderWriterLockSlim _flowDataLock = new ReaderWriterLockSlim();
private object _flowData;
/// <summary>
/// 当前传递数据(执行了节点对应的方法,才会存在值)。
/// </summary>
protected object FlowData
{
get
{
_flowDataLock.EnterReadLock();
try
{
return _flowData;
}
finally
{
_flowDataLock.ExitReadLock();
}
}
set
{
_flowDataLock.EnterWriteLock();
try
{
_flowData = value;
}
finally
{
_flowDataLock.ExitWriteLock();
}
}
}
}
/// <summary>
/// 节点基类(数据):条件控件,动作控件,条件区域,动作区域
/// </summary>
//public class NodeModelBaseBuilder
//{
// public NodeModelBaseBuilder(NodeModelBase builder)
// {
// this.ControlType = builder.ControlType;
// this.MethodDetails = builder.MethodDetails;
// this.Guid = builder.Guid;
// this.DisplayName = builder.DisplayName;
// this.IsStart = builder.IsStart;
// this.PreviousNode = builder.PreviousNode;
// this.PreviousNodes = builder.PreviousNodes;
// this.SucceedBranch = builder.SucceedBranch;
// this.FailBranch = builder.FailBranch;
// this.ErrorBranch = builder.ErrorBranch;
// this.UpstreamBranch = builder.UpstreamBranch;
// this.FlowState = builder.FlowState;
// this.RuningException = builder.RuningException;
// this.FlowData = builder.FlowData;
// }
// /// <summary>
// /// 节点对应的控件类型
// /// </summary>
// public NodeControlType ControlType { get; }
// /// <summary>
// /// 方法描述对应DLL的方法
// /// </summary>
// public MethodDetails MethodDetails { get; }
// /// <summary>
// /// 节点guid
// /// </summary>
// public string Guid { get; }
// /// <summary>
// /// 显示名称
// /// </summary>
// public string DisplayName { get;}
// /// <summary>
// /// 是否为起点控件
// /// </summary>
// public bool IsStart { get; }
// /// <summary>
// /// 运行时的上一节点
// /// </summary>
// public NodeModelBase? PreviousNode { get; }
// /// <summary>
// /// 上一节点集合
// /// </summary>
// public List<NodeModelBase> PreviousNodes { get; } = [];
// /// <summary>
// /// 下一节点集合(真分支)
// /// </summary>
// public List<NodeModelBase> SucceedBranch { get; } = [];
// /// <summary>
// /// 下一节点集合(假分支)
// /// </summary>
// public List<NodeModelBase> FailBranch { get; } = [];
// /// <summary>
// /// 异常分支
// /// </summary>
// public List<NodeModelBase> ErrorBranch { get; } = [];
// /// <summary>
// /// 上游分支
// /// </summary>
// public List<NodeModelBase> UpstreamBranch { get; } = [];
// /// <summary>
// /// 当前执行状态(进入真分支还是假分支,异常分支在异常中确定)
// /// </summary>
// public FlowStateType FlowState { get; set; } = FlowStateType.None;
// /// <summary>
// /// 运行时的异常信息(仅在 FlowState 为 Error 时存在对应值)
// /// </summary>
// public Exception RuningException { get; set; } = null;
// /// <summary>
// /// 当前传递数据(执行了节点对应的方法,才会存在值)
// /// </summary>
// public object? FlowData { get; set; } = null;
//}
}

View File

@@ -1,487 +0,0 @@
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Serein.Library.Api;
using Serein.Library.Attributes;
using Serein.Library.Entity;
using Serein.Library.Enums;
using Serein.Library.Ex;
using Serein.Library.Utils;
using Serein.NodeFlow.Tool.SereinExpression;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Net.Http.Headers;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;
using static Serein.Library.Utils.ChannelFlowInterrupt;
namespace Serein.NodeFlow.Base
{
/// <summary>
/// 节点基类(数据):条件控件,动作控件,条件区域,动作区域
/// </summary>
public abstract partial class NodeModelBase : IDynamicFlowNode
{
#region
/// <summary>
/// 不再中断
/// </summary>
public void CancelInterrupt()
{
this.DebugSetting.InterruptClass = InterruptClass.None;
DebugSetting.CancelInterruptCallback?.Invoke();
}
#endregion
#region /
public abstract Parameterdata[] GetParameterdatas();
public virtual NodeInfo ToInfo()
{
// if (MethodDetails == null) return null;
var trueNodes = SuccessorNodes[ConnectionType.IsSucceed].Select(item => item.Guid); // 真分支
var falseNodes = SuccessorNodes[ConnectionType.IsFail].Select(item => item.Guid);// 假分支
var errorNodes = SuccessorNodes[ConnectionType.IsError].Select(item => item.Guid);// 异常分支
var upstreamNodes = SuccessorNodes[ConnectionType.Upstream].Select(item => item.Guid);// 上游分支
// 生成参数列表
Parameterdata[] parameterData = GetParameterdatas();
return new NodeInfo
{
Guid = Guid,
MethodName = MethodDetails?.MethodName,
Label = DisplayName ?? "",
Type = this.GetType().ToString(),
TrueNodes = trueNodes.ToArray(),
FalseNodes = falseNodes.ToArray(),
UpstreamNodes = upstreamNodes.ToArray(),
ParameterData = parameterData.ToArray(),
ErrorNodes = errorNodes.ToArray(),
};
}
public virtual NodeModelBase LoadInfo(NodeInfo nodeInfo)
{
this.Guid = nodeInfo.Guid;
if (this.MethodDetails != null)
{
for (int i = 0; i < nodeInfo.ParameterData.Length; i++)
{
Parameterdata pd = nodeInfo.ParameterData[i];
this.MethodDetails.ParameterDetailss[i].IsExplicitData = pd.State;
this.MethodDetails.ParameterDetailss[i].DataValue = pd.Value;
}
}
return this;
}
#endregion
#region
/// <summary>
/// 是否应该退出执行
/// </summary>
/// <param name="context"></param>
/// <param name="flowCts"></param>
/// <returns></returns>
public static bool IsBradk(IDynamicContext context, CancellationTokenSource flowCts)
{
// 上下文不再执行
if(context.RunState == RunState.Completion)
{
return true;
}
// 不存在全局触发器时,流程运行状态被设置为完成,退出执行,用于打断无限循环分支。
if (flowCts is null && context.Env.FlowState == RunState.Completion)
{
return true;
}
// 如果存在全局触发器,且触发器的执行任务已经被取消时,退出执行。
if (flowCts != null)
{
if (flowCts.IsCancellationRequested)
return true;
}
return false;
}
/// <summary>
/// 开始执行
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task StartFlowAsync(IDynamicContext context)
{
Stack<NodeModelBase> stack = new Stack<NodeModelBase>();
stack.Push(this);
var flowCts = context.Env.IOC.Get<CancellationTokenSource>(NodeStaticConfig.FlipFlopCtsName);
bool hasFlipflow = flowCts != null;
while (stack.Count > 0) // 循环中直到栈为空才会退出循环
{
await Task.Delay(0);
// 从栈中弹出一个节点作为当前节点进行处理
var currentNode = stack.Pop();
#region
// 筛选出上游分支
var upstreamNodes = currentNode.SuccessorNodes[ConnectionType.Upstream].ToArray();
for (int index = 0; index < upstreamNodes.Length; index++)
{
NodeModelBase upstreamNode = upstreamNodes[index];
if (!(upstreamNode is null) && upstreamNode.DebugSetting.IsEnable)
{
if (upstreamNode.DebugSetting.InterruptClass != InterruptClass.None) // 执行触发前
{
var cancelType = await upstreamNode.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{upstreamNode.MethodDetails?.MethodName}]中断已{cancelType},开始执行后继分支");
}
upstreamNode.PreviousNode = currentNode;
await upstreamNode.StartFlowAsync(context); // 执行流程节点的上游分支
if (upstreamNode.NextOrientation == ConnectionType.IsError)
{
// 如果上游分支执行失败,不再继续执行
// 使上游节点(仅上游节点本身,不包含上游节点的后继节点)
// 具备通过抛出异常中断流程的能力
break;
}
}
}
if (IsBradk(context, flowCts)) break; // 退出执行
// 上游分支执行完成,才执行当前节点
object newFlowData = await currentNode.ExecutingAsync(context);
if (IsBradk(context, flowCts)) break; // 退出执行
await RefreshFlowDataAndExpInterrupt(context, currentNode, newFlowData); // 执行当前节点后刷新数据
#endregion
#region
// 选择后继分支
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
}
}
/// <summary>
/// 执行节点对应的方法
/// </summary>
/// <param name="context">流程上下文</param>
/// <returns>节点传回数据对象</returns>
public virtual async Task<object> ExecutingAsync(IDynamicContext context)
{
#region
if (DebugSetting.InterruptClass != InterruptClass.None) // 执行触发检查是否需要中断
{
var cancelType = await this.DebugSetting.GetInterruptTask(); // 等待中断结束
await Console.Out.WriteLineAsync($"[{this.MethodDetails?.MethodName}]中断已{cancelType},开始执行后继分支");
}
#endregion
MethodDetails md = MethodDetails;
//var del = md.MethodDelegate.Clone();
if (md is null)
{
throw new Exception($"节点{this.Guid}不存在方法信息请检查是否需要重写节点的ExecutingAsync");
}
if (!context.Env.TryGetDelegateDetails(md.MethodName, out var dd))
{
throw new Exception($"节点{this.Guid}不存在对应委托");
}
if(md.ActingInstance is null)
{
md.ActingInstance = context.Env.IOC.Get(md.ActingInstanceType);
}
// md.ActingInstance ??= context.Env.IOC.Get(md.ActingInstanceType);
object instance = md.ActingInstance;
object result = null;
try
{
object[] args = GetParameters(context, this, md);
result = await dd.InvokeAsync(md.ActingInstance, args);
NextOrientation = ConnectionType.IsSucceed;
return result;
}
catch (Exception ex)
{
await Console.Out.WriteLineAsync($"节点[{this.MethodDetails?.MethodName}]异常:" + ex);
NextOrientation = ConnectionType.IsError;
RuningException = ex;
return null;
}
}
/// <summary>
/// 获取对应的参数数组
/// </summary>
public static object[] GetParameters(IDynamicContext context, NodeModelBase nodeModel, MethodDetails md)
{
// 用正确的大小初始化参数数组
if (md.ParameterDetailss.Length == 0)
{
return null;// md.ActingInstance
}
object[] parameters = new object[md.ParameterDetailss.Length];
var flowData = nodeModel.PreviousNode?.FlowData; // 当前传递的数据
var previousDataType = flowData?.GetType();
for (int i = 0; i < parameters.Length; i++)
{
object inputParameter; // 存放解析的临时参数
var ed = md.ParameterDetailss[i]; // 方法入参描述
if (ed.IsExplicitData) // 判断是否使用显示的输入参数
{
if (ed.DataValue.StartsWith("@get", StringComparison.OrdinalIgnoreCase) && !(flowData is null))
{
// 执行表达式从上一节点获取对象
inputParameter = SerinExpressionEvaluator.Evaluate(ed.DataValue, flowData, out _);
}
else
{
// 使用输入的固定值
inputParameter = ed.DataValue;
}
}
else
{
inputParameter = flowData; // 使用上一节点的对象
}
// 入参存在取值转换器
if (ed.ExplicitType.IsEnum && !(ed.Convertor is null))
{
//var resultEnum = Enum.ToObject(ed.ExplicitType, ed.DataValue);
var resultEnum = Enum.Parse(ed.ExplicitType, ed.DataValue);
var value = ed.Convertor(resultEnum);
if (value is null)
{
throw new InvalidOperationException("转换器调用失败");
}
else
{
parameters[i] = value;
continue;
}
//if (Enum.TryParse(ed.ExplicitType, ed.DataValue, out var resultEnum))
//{
//}
}
// 入参存在类型转换器,获取枚举转换器中记录的枚举
if (ed.ExplicitType.IsEnum && ed.DataType != ed.ExplicitType)
{
var resultEnum = Enum.Parse(ed.ExplicitType, ed.DataValue);
// 获取绑定的类型
var type = EnumHelper.GetBoundValue(ed.ExplicitType, resultEnum, attr => attr.Value);
if (type is Type enumBindType && !(enumBindType is null))
{
var value = context.Env.IOC.Instantiate(enumBindType);
if (value is null)
{
}
else
{
parameters[i] = value;
continue;
}
}
}
if (ed.DataType.IsValueType)
{
var valueStr = inputParameter?.ToString();
parameters[i] = valueStr.ToValueData(ed.DataType);
}
else
{
var valueStr = inputParameter?.ToString();
if(ed.DataType == typeof(string))
{
parameters[i] = valueStr;
}
else if(ed.DataType == typeof(IDynamicContext))
{
parameters[i] = context;
}
else if(ed.DataType == typeof(MethodDetails))
{
parameters[i] = md;
}
else if(ed.DataType == typeof(NodeModelBase))
{
parameters[i] = nodeModel;
}
else
{
parameters[i] = inputParameter;
}
//parameters[i] = ed.DataType switch
//{
// Type t when t == typeof(string) => valueStr,
// Type t when t == typeof(IDynamicContext) => context, // 上下文
// Type t when t == typeof(DateTime) => string.IsNullOrEmpty(valueStr) ? null : DateTime.Parse(valueStr),
// Type t when t == typeof(MethodDetails) => md, // 节点方法描述
// Type t when t == typeof(NodeModelBase) => nodeModel, // 节点实体类
// Type t when t.IsArray => (inputParameter as Array)?.Cast<object>().ToList(),
// Type t when t.IsGenericType && t.GetGenericTypeDefinition() == typeof(List<>) => inputParameter,
// _ => inputParameter,
//};
}
}
return parameters;
}
/// <summary>
/// 更新节点数据,并检查监视表达式是否生效
/// </summary>
/// <param name="context">上下文</param>
/// <param name="nodeModel">节点Moel</param>
/// <param name="newData">新的数据</param>
/// <returns></returns>
public static async Task RefreshFlowDataAndExpInterrupt(IDynamicContext context, NodeModelBase nodeModel, object newData = null)
{
string guid = nodeModel.Guid;
if (newData is null)
{
}
else
{
await MonitorObjExpInterrupt(context, nodeModel, newData, 0); // 首先监视对象
await MonitorObjExpInterrupt(context, nodeModel, newData, 1); // 然后监视节点
nodeModel.FlowData = newData; // 替换数据
context.AddOrUpdate(guid, nodeModel); // 上下文中更新数据
}
}
private static async Task MonitorObjExpInterrupt(IDynamicContext context, NodeModelBase nodeModel, object data, int monitorType)
{
MonitorObjectEventArgs.ObjSourceType sourceType;
string key;
if (monitorType == 0)
{
key = data?.GetType()?.FullName;
sourceType = MonitorObjectEventArgs.ObjSourceType.IOCObj;
}
else
{
key = nodeModel.Guid;
sourceType = MonitorObjectEventArgs.ObjSourceType.IOCObj;
}
if (string.IsNullOrEmpty(key))
{
return;
}
if (context.Env.CheckObjMonitorState(key, out List<string> exps)) // 如果新的数据处于查看状态通知UI进行更新交给运行环境判断
{
context.Env.MonitorObjectNotification(nodeModel.Guid, data, sourceType); // 对象处于监视状态通知UI更新数据显示
if (exps.Count > 0)
{
// 表达式环境下判断是否需要执行中断
bool isExpInterrupt = false;
string exp = "";
// 判断执行监视表达式,直到为 true 时退出
for (int i = 0; i < exps.Count && !isExpInterrupt; i++)
{
exp = exps[i];
if (string.IsNullOrEmpty(exp)) continue;
// isExpInterrupt = SereinConditionParser.To(data, exp);
}
if (isExpInterrupt) // 触发中断
{
InterruptClass interruptClass = InterruptClass.Branch; // 分支中断
if (context.Env.SetNodeInterrupt(nodeModel.Guid, interruptClass))
{
context.Env.TriggerInterrupt(nodeModel.Guid, exp, InterruptTriggerEventArgs.InterruptTriggerType.Exp);
var cancelType = await nodeModel.DebugSetting.GetInterruptTask();
await Console.Out.WriteLineAsync($"[{data}]中断已{cancelType},开始执行后继分支");
}
}
}
}
}
/// <summary>
/// 释放对象
/// </summary>
public void ReleaseFlowData()
{
if (typeof(IDisposable).IsAssignableFrom(FlowData?.GetType()) && FlowData is IDisposable disposable)
{
disposable?.Dispose();
}
this.FlowData = null;
}
/// <summary>
/// 获取节点数据
/// </summary>
/// <returns></returns>
public object GetFlowData()
{
return this.FlowData;
}
#endregion
}
}

View File

@@ -1,116 +0,0 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace Serein.Library.Entity
{
/// <summary>
/// 方法入参描述
/// </summary>
public class ParameterDetailsInfo
{
/// <summary>
/// 参数索引
/// </summary>
public int Index { get; set; }
/// <summary>
/// 方法需要的类型
/// </summary>
public string DataTypeFullName { get; set; }
/// <summary>
/// 方法入参参数名称
/// </summary>
public string Name { get; set; }
}
/// <summary>
/// 节点入参参数详情
/// </summary>
public class ParameterDetails
{
/// <summary>
/// 转为描述
/// </summary>
/// <returns></returns>
public ParameterDetailsInfo ToInfo()
{
return new ParameterDetailsInfo
{
Index = Index,
DataTypeFullName = DataType.FullName,
Name = Name
};
}
/// <summary>
/// 拷贝新的对象。
/// </summary>
/// <returns></returns>
public ParameterDetails Clone() => new ParameterDetails()
{
Index = Index,
IsExplicitData = IsExplicitData,
ExplicitType = ExplicitType,
ExplicitTypeName = ExplicitTypeName,
Convertor = Convertor,
DataType = DataType,
Name = Name,
DataValue = string.IsNullOrEmpty(DataValue) ? string.Empty : DataValue,
Items = Items.Select(it => it).ToArray(),
};
/// <summary>
/// 参数索引
/// </summary>
public int Index { get; set; }
/// <summary>
/// 是否为显式参数(固定值/表达式)
/// </summary>
public bool IsExplicitData { get; set; }
/// <summary>
/// 转换器 IEnumConvertor&lt;,&gt;
/// </summary>
public Func<object, object> Convertor { get; set; }
/// <summary>
/// 显式类型
/// </summary>
public Type ExplicitType { get; set; }
/// <summary>
/// 目前存在三种状态Select/Bool/Value
/// <para>Select : 枚举值</para>
/// <para>Bool : 布尔类型</para>
/// <para>Value 除以上类型之外的任意参数</para>
/// </summary>
public string ExplicitTypeName { get; set; }
/// <summary>
/// 方法需要的类型
/// </summary>
public Type DataType { get; set; }
/// <summary>
/// 方法入参参数名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 入参值在UI上输入的文本内容
/// </summary>
public string DataValue { get; set; }
/// <summary>
/// 如果是引用类型,拷贝时不会发生改变。
/// </summary>
public object[] Items { get; set; }
}
}

View File

@@ -1,226 +0,0 @@
using Serein.Library.Api;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
namespace Serein.Library.Entity
{
/// <summary>
/// 项目保存文件
/// </summary>
public class SereinProjectData
{
/// <summary>
/// 基础
/// </summary>
public Basic Basic { get; set; }
/// <summary>
/// 依赖的DLL
/// </summary>
public Library[] Librarys { get; set; }
/// <summary>
/// 起始节点GUID
/// </summary>
public string StartNode { get; set; }
/// <summary>
/// 节点集合
/// </summary>
public NodeInfo[] Nodes { get; set; }
}
/// <summary>
/// 基础
/// </summary>
public class Basic
{
/// <summary>
/// 画布
/// </summary>
public FlowCanvas Canvas { get; set; }
/// <summary>
/// 版本
/// </summary>
public string Versions { get; set; }
}
/// <summary>
/// 画布
/// </summary>
public class FlowCanvas
{
/// <summary>
/// 宽度
/// </summary>
public double Width { get; set; }
/// <summary>
/// 高度
/// </summary>
public double Lenght { get; set; }
/// <summary>
/// 预览位置X
/// </summary>
public double ViewX { get; set; }
/// <summary>
/// 预览位置Y
/// </summary>
public double ViewY { get; set; }
/// <summary>
/// 缩放比例X
/// </summary>
public double ScaleX { get; set; }
/// <summary>
/// 缩放比例Y
/// </summary>
public double ScaleY { get; set; }
}
/// <summary>
/// DLL
/// </summary>
public class Library
{
/// <summary>
/// DLL名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 路径
/// </summary>
public string Path { get; set; }
}
/// <summary>
/// 节点
/// </summary>
public class NodeInfo
{
/// <summary>
/// GUID
/// </summary>
public string Guid { get; set; }
/// <summary>
/// 名称
/// </summary>
public string MethodName { get; set; }
/// <summary>
/// 显示标签
/// </summary>
public string Label { get; set; }
/// <summary>
/// 类型
/// </summary>
public string Type { get; set; }
/// <summary>
/// 真分支节点GUID
/// </summary>
public string[] TrueNodes { get; set; }
/// <summary>
/// 假分支节点
/// </summary>
public string[] FalseNodes { get; set; }
/// <summary>
/// 上游分支
/// </summary>
public string[] UpstreamNodes { get; set; }
/// <summary>
/// 异常分支
/// </summary>
public string[] ErrorNodes { get; set; }
/// <summary>
/// 参数
/// </summary>
public Parameterdata[] ParameterData { get; set; }
/// <summary>
/// 如果是区域控件,则会存在子项。
/// </summary>
public string[] ChildNodeGuids { get; set; }
/// <summary>
/// 于画布中的位置
/// </summary>
public Position Position { get; set; }
/// <summary>
/// 是否选中(暂时无效)
/// </summary>
public bool IsSelect { get; set; }
}
/// <summary>
/// 显示参数
/// </summary>
public class Parameterdata
{
/// <summary>
/// 参数类型true时使用自定义的入参false时由运行环境自动传参
/// </summary>
public bool State { get; set; }
/// <summary>
/// 自定义入参
/// </summary>
public string Value { get; set; }
/// <summary>
/// 表达式相关节点的表达式内容
/// </summary>
public string Expression { get; set; }
}
/// <summary>
/// 节点于画布中的位置
/// </summary>
public class Position
{
/// <summary>
/// 构造一个坐标
/// </summary>
public Position(double x, double y)
{
this.X = x; this.Y = y;
}
public double X { get; set; } = 0;
public double Y { get; set; } = 0;
}
}