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

重新优化了NodeModel类；从硬编码类型改为“注册/获取”的方式，为下一步解耦Workbench与节点UI做准备。

Browse Source 
新增了“全局数据节点”；保存项目文件时，不同节点可以使用自定义数据保存自身独特的数据，不再借用“方法参数”。
重新设计了运行时的环境输出；增量式生成器现在可以选择在属性变更的前后时间点插入自定义代码；重写了加载项目、保存项目的方法。
This commit is contained in:
fengjiayi
2024-12-12 20:31:50 +08:00
parent dbbaa10cc0
commit 49603bb58f
40 changed files with 999 additions and 681 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
NodeFlow/Env/FlowEnvironment.cs
View File

@@ -58,6 +58,15 @@ namespace Serein.NodeFlow.Env
};
this.UIContextOperation = uiContextOperation; // 为加载的类库提供在UI线程上执行某些操作的封装工具类
this.FlowLibraryManagement = new FlowLibraryManagement(this); // 实例化类库管理
#region 注册基本节点类型
NodeMVVMManagement.RegisterModel(NodeControlType.Action, typeof(SingleActionNode)); // 动作节点
NodeMVVMManagement.RegisterModel(NodeControlType.Flipflop, typeof(SingleFlipflopNode)); // 触发器节点
NodeMVVMManagement.RegisterModel(NodeControlType.ExpOp, typeof(SingleExpOpNode)); // 表达式节点
NodeMVVMManagement.RegisterModel(NodeControlType.ExpCondition, typeof(SingleConditionNode)); // 条件表达式节点
NodeMVVMManagement.RegisterModel(NodeControlType.ConditionRegion, typeof(CompositeConditionNode)); // 条件区域
NodeMVVMManagement.RegisterModel(NodeControlType.GlobalData, typeof(SingleGlobalDataNode)); // 全局数据节点
#endregion
}
#region 远程管理
@@ -119,6 +128,11 @@ namespace Serein.NodeFlow.Env
/// </summary>
public event ProjectLoadedHandler? OnProjectLoaded;
/// <summary>
/// 项目准备保存
/// </summary>
public event ProjectSavingHandler? OnProjectSaving;
/// <summary>
/// 节点连接属性改变事件
/// </summary>
@@ -347,10 +361,10 @@ namespace Serein.NodeFlow.Env
{
if (@class >= this.InfoClass)
{
OnEnvOut?.Invoke(type, message);
}
Console.WriteLine($"{DateTime.UtcNow} [{type}] : {message}{Environment.NewLine}");
OnEnvOut?.Invoke(type, message);
//Console.WriteLine($"{DateTime.UtcNow} [{type}] : {message}{Environment.NewLine}");
}
///// <summary>
@@ -506,7 +520,7 @@ namespace Serein.NodeFlow.Env
// 获取所有的程序集对应的方法信息（程序集相关的数据）
var libraryMdss = this.FlowLibraryManagement.GetAllLibraryMds().ToArray();
// 获取当前项目的信息（节点相关的数据）
var project = await GetProjectInfoAsync();
var project = await GetProjectInfoAsync(); // 远程连接获取远程环境项目信息
SereinEnv.WriteLine(InfoType.INFO, "已将当前环境信息发送到远程客户端");
return new FlowEnvInfo
{
@@ -526,7 +540,13 @@ namespace Serein.NodeFlow.Env
}
/// <summary>
/// 保存项目
/// </summary>
public void SaveProject()
{
OnProjectSaving?.Invoke(new ProjectSavingEventArgs());
}
/// <summary>
/// 加载项目文件
@@ -746,6 +766,7 @@ namespace Serein.NodeFlow.Env
Nodes = NodeModels.Values.Select(node => node.ToInfo()).Where(info => info is not null).ToArray(),
StartNode = NodeModels.Values.FirstOrDefault(it => it.IsStart)?.Guid,
};
return Task.FromResult(projectData);
}
@@ -926,17 +947,14 @@ namespace Serein.NodeFlow.Env
if (remoteNode is null)
return false;
//if (remoteNode.IsStart)
//{
// return;
//}
if (remoteNode is SingleFlipflopNode flipflopNode)
{
flowStarter?.TerminateGlobalFlipflopRuning(flipflopNode); // 假设被移除的是全局触发器，尝试从启动器移除
}
remoteNode.Remove(); // 调用节点的移除方法
// 遍历所有父节点，从那些父节点中的子节点集合移除该节点
// 遍历所有前置节点，从那些前置节点中的后继节点集合移除该节点
foreach (var pnc in remoteNode.PreviousNodes)
{
var pCType = pnc.Key; // 连接类型
@@ -955,7 +973,7 @@ namespace Serein.NodeFlow.Env
}
}
// 遍历所有子节点，从那些子节点中的父节点集合移除该节点
// 遍历所有后继节点，从那些后继节点中的前置节点集合移除该节点
foreach (var snc in remoteNode.SuccessorNodes)
{
var connectionType = snc.Key; // 连接类型
@@ -968,6 +986,8 @@ namespace Serein.NodeFlow.Env
}
}
// 从集合中移除节点
NodeModels.Remove(nodeGuid);
UIContextOperation?.Invoke(() => OnNodeRemove?.Invoke(new NodeRemoveEventArgs(nodeGuid)));
@@ -1434,7 +1454,7 @@ namespace Serein.NodeFlow.Env
isPass = nodeModel.MethodDetails.RemoveParamsArg(paramIndex);
}
await Task.Delay(50);
await Task.Delay(200);
foreach ((var fromGuid, var type, var index) in argInfo)
{
await UIContextOperation.InvokeAsync(() =>
@@ -1487,7 +1507,7 @@ namespace Serein.NodeFlow.Env
/// <returns></returns>
public object AddOrUpdateGlobalData(string keyName, object data)
{
SereinEnv.EnvGlobalData.AddOrUpdate(keyName, data, (k, o) => data);
SereinEnv.AddOrUpdateFlowGlobalData(keyName, data);
return data;
}
@@ -1498,8 +1518,7 @@ namespace Serein.NodeFlow.Env
/// <returns></returns>
public object? GetGlobalData(string keyName)
{
SereinEnv.EnvGlobalData.TryGetValue(keyName, out var data);
return data;
return SereinEnv.GetFlowGlobalData(keyName);
}

19
NodeFlow/Env/FlowEnvironmentDecorator.cs
View File

@@ -86,12 +86,23 @@ namespace Serein.NodeFlow.Env
add { currentFlowEnvironment.OnDllLoad += value; }
remove { currentFlowEnvironment.OnDllLoad -= value; }
}
public event ProjectLoadedHandler OnProjectLoaded
{
add { currentFlowEnvironment.OnProjectLoaded += value; }
remove { currentFlowEnvironment.OnProjectLoaded -= value; }
}
/// <summary>
/// 项目准备保存
/// </summary>
public event ProjectSavingHandler? OnProjectSaving
{
add { currentFlowEnvironment.OnProjectSaving += value; }
remove { currentFlowEnvironment.OnProjectSaving -= value; }
}
public event NodeConnectChangeHandler OnNodeConnectChange
{
add { currentFlowEnvironment.OnNodeConnectChange += value; }
@@ -289,6 +300,14 @@ namespace Serein.NodeFlow.Env
currentFlowEnvironment.LoadLibrary(dllPath);
}
/// <summary>
/// 保存项目
/// </summary>
public void SaveProject()
{
currentFlowEnvironment.SaveProject();
}
public void LoadProject(FlowEnvInfo flowEnvInfo, string filePath)
{
if (flowEnvInfo is null) return;

28
NodeFlow/Env/FlowFunc.cs
View File

@@ -1,6 +1,8 @@
using Serein.Library;
using Serein.Library.Api;
using Serein.Library.Utils;
using Serein.NodeFlow.Model;
using System.Collections.Concurrent;
namespace Serein.NodeFlow.Env
{
@@ -10,6 +12,8 @@ namespace Serein.NodeFlow.Env
/// </summary>
public static class FlowFunc
{
/// <summary>
/// 判断是否为基础节点
/// </summary>
@@ -17,13 +21,15 @@ namespace Serein.NodeFlow.Env
public static bool IsBaseNode(this NodeControlType nodeControlType)
{
if(nodeControlType == NodeControlType.ExpCondition
|| nodeControlType == NodeControlType.ExpOp)
|| nodeControlType == NodeControlType.ExpOp
|| nodeControlType == NodeControlType.GlobalData)
{
return true;
}
return false;
}
/// <summary>
/// 创建节点
/// </summary>
@@ -35,24 +41,16 @@ namespace Serein.NodeFlow.Env
public static NodeModelBase CreateNode(IFlowEnvironment env, NodeControlType nodeControlType,
MethodDetails? methodDetails = null)
{
// 确定创建的节点类型
Type? nodeType = nodeControlType switch
{
NodeControlType.Action => typeof(SingleActionNode),
NodeControlType.Flipflop => typeof(SingleFlipflopNode),
NodeControlType.ExpOp => typeof(SingleExpOpNode),
NodeControlType.ExpCondition => typeof(SingleConditionNode),
NodeControlType.ConditionRegion => typeof(CompositeConditionNode),
_ => null
};
// 尝试获取需要创建的节点类型
if (nodeType is null)
if (!NodeMVVMManagement.TryGetType(nodeControlType, out var nodeMVVM) || nodeMVVM.ModelType == null)
{
throw new Exception($"节点类型错误[{nodeControlType}]");
throw new Exception($"无法创建{nodeControlType}节点，节点类型尚未注册。");
}
// 生成实例
var nodeObj = Activator.CreateInstance(nodeType, env);
var nodeObj = Activator.CreateInstance(nodeMVVM.ModelType, env);
if (nodeObj is not NodeModelBase nodeModel)
{
throw new Exception($"无法创建目标节点类型的实例[{nodeControlType}]");
@@ -90,6 +88,8 @@ namespace Serein.NodeFlow.Env
$"{NodeStaticConfig.NodeSpaceName}.{nameof(SingleExpOpNode)}" => NodeControlType.ExpOp, // 操作表达式控件
$"{NodeStaticConfig.NodeSpaceName}.{nameof(CompositeConditionNode)}" => NodeControlType.ConditionRegion, // 条件区域控件
$"{NodeStaticConfig.NodeSpaceName}.{nameof(SingleGlobalDataNode)}" => NodeControlType.GlobalData, // 数据节点
_ => NodeControlType.None,
};

13
NodeFlow/Env/RemoteFlowEnvironment.cs
View File

@@ -45,6 +45,10 @@ namespace Serein.NodeFlow.Env
public event LoadDllHandler OnDllLoad;
public event ProjectLoadedHandler OnProjectLoaded;
/// <summary>
/// 项目准备保存
/// </summary>
public event ProjectSavingHandler? OnProjectSaving;
public event NodeConnectChangeHandler OnNodeConnectChange;
public event NodeCreateHandler OnNodeCreate;
public event NodeRemoveHandler OnNodeRemove;
@@ -128,6 +132,15 @@ namespace Serein.NodeFlow.Env
return prjectInfo;
}
/// <summary>
/// 保存项目
/// </summary>
public void SaveProject()
{
OnProjectSaving?.Invoke(new ProjectSavingEventArgs());
}
/// <summary>
/// 远程环境下加载项目
/// </summary>

2
NodeFlow/FlowStarter.cs
View File

@@ -241,7 +241,7 @@ namespace Serein.NodeFlow
_flipFlopCts?.Dispose();
} // 通知所有流程上下文停止运行
TerminateAllGlobalFlipflop(); // 确保所有触发器不再运行
SereinEnv.ClearGlobalData(); // 清空全局数据缓存
SereinEnv.ClearFlowGlobalData(); // 清空全局数据缓存
NativeDllHelper.FreeLibrarys(); // 卸载所有已加载的 Native Dll
env.FlowState = RunState.Completion;

71
NodeFlow/Model/CompositeConditionNode.cs
View File

@@ -30,23 +30,6 @@ namespace Serein.NodeFlow.Model
}
/// <summary>
/// 加载完成后调用的方法
/// </summary>
public override void OnCreating()
{
SereinEnv.WriteLine(InfoType.WARN, "CompositeConditionNode 暂未实现 OnLoading");
}
public void AddNode(SingleConditionNode node)
{
if(ConditionNodes is null)
{
ConditionNodes = new List<SingleConditionNode>();
}
ConditionNodes.Add(node);
MethodDetails ??= node.MethodDetails;
}
/// <summary>
/// 条件节点重写执行方法
@@ -79,49 +62,35 @@ namespace Serein.NodeFlow.Model
return context.TransmissionData(this); // 条件区域透传上一节点的数据
}
}
public override ParameterData[] GetParameterdatas()
/// <summary>
/// 设置区域子项
/// </summary>
/// <param name="nodeInfo"></param>
/// <returns></returns>
public override NodeInfo SaveCustomData(NodeInfo nodeInfo)
{
return [];
nodeInfo.ChildNodeGuids = ConditionNodes.Select(node => node.Guid).ToArray();
return nodeInfo;
}
public override NodeInfo ToInfo()
/// <summary>
/// 添加条件子项
/// </summary>
/// <param name="node"></param>
public void AddNode(SingleConditionNode node)
{
//if (MethodDetails == null) return null;
//var trueNodes = SucceedBranch.Select(item => item.Guid); // 真分支
//var falseNodes = FailBranch.Select(item => item.Guid);// 假分支
//var upstreamNodes = UpstreamBranch.Select(item => item.Guid);// 上游分支
//var errorNodes = ErrorBranch.Select(item => item.Guid);// 异常分支
var trueNodes = SuccessorNodes[ConnectionInvokeType.IsSucceed].Select(item => item.Guid); // 真分支
var falseNodes = SuccessorNodes[ConnectionInvokeType.IsFail].Select(item => item.Guid);// 假分支
var errorNodes = SuccessorNodes[ConnectionInvokeType.IsError].Select(item => item.Guid);// 异常分支
var upstreamNodes = SuccessorNodes[ConnectionInvokeType.Upstream].Select(item => item.Guid);// 上游分支
// 生成参数列表
ParameterData[] parameterData = GetParameterdatas();
return new NodeInfo
if (ConditionNodes is null)
{
Guid = Guid,
AssemblyName = MethodDetails.AssemblyName,
MethodName = MethodDetails.MethodName,
Label = MethodDetails?.MethodAnotherName,
Type = this.GetType().ToString(),
TrueNodes = trueNodes.ToArray(),
FalseNodes = falseNodes.ToArray(),
UpstreamNodes = upstreamNodes.ToArray(),
ParameterData = parameterData.ToArray(),
ErrorNodes = errorNodes.ToArray(),
ChildNodeGuids = ConditionNodes.Select(node => node.Guid).ToArray(),
Position = Position,
};
ConditionNodes = new List<SingleConditionNode>();
}
ConditionNodes.Add(node);
MethodDetails ??= node.MethodDetails;
}
}
}

26
NodeFlow/Model/SingleActionNode.cs
View File

@@ -14,32 +14,6 @@ namespace Serein.NodeFlow.Model
}
/// <summary>
/// 加载完成后调用的方法
/// </summary>
public override void OnCreating()
{
}
public override ParameterData[] GetParameterdatas()
{
if (base.MethodDetails.ParameterDetailss.Length > 0)
{
return MethodDetails.ParameterDetailss
.Select(it => new ParameterData
{
SourceNodeGuid = it.ArgDataSourceNodeGuid,
SourceType = it.ArgDataSourceType.ToString(),
State = it.IsExplicitData,
Value = it.DataValue,
})
.ToArray();
}
else
{
return [];
}
}
}

209
NodeFlow/Model/SingleConditionNode.cs
View File

@@ -2,7 +2,10 @@
using Serein.Library.Api;
using Serein.Library.Utils;
using Serein.Library.Utils.SereinExpression;
using System;
using System.ComponentModel;
using System.Dynamic;
using System.Linq.Expressions;
namespace Serein.NodeFlow.Model
{
@@ -12,38 +15,90 @@ namespace Serein.NodeFlow.Model
[NodeProperty(ValuePath = NodeValuePath.Node)]
public partial class SingleConditionNode : NodeModelBase
{
/// <summary>
/// 是否为自定义参数
/// </summary>
[PropertyInfo(IsNotification = true)]
private bool _isCustomData;
private bool _isExplicitData;
/// <summary>
/// 自定义参数值
/// </summary>
[PropertyInfo(IsNotification = true)]
private string? _customData;
private string? _explicitData;
/// <summary>
/// 条件表达式
/// </summary>
[PropertyInfo(IsNotification = true)]
private string _expression;
}
public partial class SingleConditionNode : NodeModelBase
{
/// <summary>
/// 表达式参数索引
/// </summary>
private const int INDEX_EXPRESSION = 0;
public SingleConditionNode(IFlowEnvironment environment):base(environment)
{
this.IsCustomData = false;
this.CustomData = null;
this.IsExplicitData = false;
this.ExplicitData = string.Empty;
this.Expression = "PASS";
}
public override void OnCreating()
{
// 这里的这个参数是为了方便使用入参控制点，参数无意义
var pd = new ParameterDetails[1];
pd[INDEX_EXPRESSION] = new ParameterDetails
{
Index = INDEX_EXPRESSION,
Name = nameof(Expression),
IsExplicitData = false,
DataValue = string.Empty,
DataType = typeof(string),
ExplicitType = typeof(string),
ArgDataSourceNodeGuid = string.Empty,
ArgDataSourceType = ConnectionArgSourceType.GetPreviousNodeData,
NodeModel = this,
Convertor = null,
ExplicitTypeName = "Value",
Items = null,
};
this.MethodDetails.ParameterDetailss = [..pd];
}
/// <summary>
/// 导出方法信息
/// </summary>
/// <param name="nodeInfo"></param>
/// <returns></returns>
public override NodeInfo SaveCustomData(NodeInfo nodeInfo)
{
dynamic data = new ExpandoObject();
data.Expression = Expression ?? "";
data.ExplicitData = ExplicitData ?? "";
data.IsExplicitData = IsExplicitData;
nodeInfo.CustomData = data;
return nodeInfo;
}
/// <summary>
/// 加载自定义数据
/// </summary>
/// <param name="nodeInfo"></param>
public override void LoadCustomData(NodeInfo nodeInfo)
{
this.Expression = nodeInfo.CustomData?.Expression ?? "";
this.ExplicitData = nodeInfo.CustomData?.ExplicitData ?? "";
this.IsExplicitData = nodeInfo.CustomData?.IsExplicitData ?? false;
}
/// <summary>
/// 重写节点的方法执行
/// </summary>
@@ -54,54 +109,45 @@ namespace Serein.NodeFlow.Model
// 接收上一节点参数or自定义参数内容
object? parameter;
object? result = null;
if (!IsCustomData) // 是否使用自定义参数
if (!IsExplicitData)
{
var pd = MethodDetails.ParameterDetailss[0];
if (pd.ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeData)
// 使用自动取参
var pd = MethodDetails.ParameterDetailss[INDEX_EXPRESSION];
if (pd.ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeData)
{
// 使用自定义节点的参数
result = context.GetFlowData(pd.ArgDataSourceNodeGuid);
result = context.GetFlowData(pd.ArgDataSourceNodeGuid); // 使用自定义节点的参数
}
else if (pd.ArgDataSourceType == ConnectionArgSourceType.GetOtherNodeDataOfInvoke)
{
// 立刻调用目标节点，然后使用其返回值
result = await Env.InvokeNodeAsync(context, pd.ArgDataSourceNodeGuid);
result = await Env.InvokeNodeAsync(context, pd.ArgDataSourceNodeGuid); // 立刻调用目标节点，然后使用其返回值
}
else
{
// 条件节点透传上一节点的数据
result = context.TransmissionData(this);
result = context.TransmissionData(this); // 条件节点透传上一节点的数据
}
// 使用上一节点的参数
parameter = result;
parameter = result; // 使用上一节点的参数
}
else
{
var getObjExp = CustomData?.ToString();
if (string.IsNullOrEmpty(getObjExp) || getObjExp.Length < 4 || !getObjExp[..4].Equals("@get", StringComparison.CurrentCultureIgnoreCase))
var exp = ExplicitData?.ToString();
if (!string.IsNullOrEmpty(exp) && exp.StartsWith('@'))
{
// 使用自定义的参数
parameter = CustomData;
parameter = result; // 表达式获取上一节点数据
if (parameter is not null)
{
parameter = SerinExpressionEvaluator.Evaluate(exp, parameter, out _);
}
}
else
{
// 表达式获取上一节点数据
parameter = result;
if (parameter is not null)
{
parameter = SerinExpressionEvaluator.Evaluate(getObjExp, parameter, out _);
}
parameter = ExplicitData; // 使用自定义的参数
}
}
try
{
var isPass = SereinConditionParser.To(parameter, Expression);
context.NextOrientation = isPass ? ConnectionInvokeType.IsSucceed : ConnectionInvokeType.IsFail;
}
@@ -117,105 +163,6 @@ namespace Serein.NodeFlow.Model
public override ParameterData[] GetParameterdatas()
{
var pd1 = MethodDetails.ParameterDetailss[0];
var pd2 = MethodDetails.ParameterDetailss[1];
var pd3 = MethodDetails.ParameterDetailss[2];
return [
new ParameterData // 保存表达式
{
Value = Expression ,
SourceNodeGuid = pd1.ArgDataSourceNodeGuid,
SourceType = pd1.ArgDataSourceType.ToString(),
},
new ParameterData // 保存自定义参数
{
Value = CustomData?.ToString() ,
SourceNodeGuid = pd2.ArgDataSourceNodeGuid,
SourceType = pd2.ArgDataSourceType.ToString(),
},
new ParameterData // 参数来源状态
{
Value = IsCustomData.ToString() ,
SourceNodeGuid = pd3.ArgDataSourceNodeGuid,
SourceType = pd3.ArgDataSourceType.ToString(),
}];
}
public override void OnCreating()
{
// 自定义节点初始化默认的参数实体
var tmpParameterDetails = new ParameterDetails[3];
for (int index = 0; index <= 2; index++)
{
tmpParameterDetails[index] = new ParameterDetails
{
Index = index,
IsExplicitData = false,
DataValue = string.Empty,
ArgDataSourceNodeGuid = string.Empty,
ArgDataSourceType = ConnectionArgSourceType.GetPreviousNodeData,
NodeModel = this,
Convertor = null,
ExplicitTypeName = "Value",
Items = Array.Empty<string>(),
};
}
var pd1 = tmpParameterDetails[0]; // 表达式
var pd2 = tmpParameterDetails[1]; // 自定义参数
var pd3 = tmpParameterDetails[2]; // 参数来源
// 表达式
pd1.Name = nameof(Expression);
pd1.DataType = typeof(string);
pd1.ExplicitType = typeof(string);
// 自定义参数
pd2.Name = nameof(CustomData);
pd2.DataType = typeof(string);
pd2.ExplicitType = typeof(string);
// 参数来源
pd3.Name = nameof(IsCustomData);
pd3.DataType = typeof(bool);
pd3.ExplicitType = typeof(bool);
//this.MethodDetails.ParameterDetailss = new ParameterDetails[2] { pd1, pd2 };
this.MethodDetails.ParameterDetailss = [..tmpParameterDetails];
}
public override NodeModelBase LoadInfo(NodeInfo nodeInfo)
{
this.Guid = nodeInfo.Guid;
this.Position = nodeInfo.Position;// 加载位置信息
var pdInfo1 = nodeInfo.ParameterData[0];
this.Expression = pdInfo1.Value; // 加载表达式
var pdInfo2 = nodeInfo.ParameterData[1];
this.CustomData = pdInfo2.Value; // 加载自定义参数信息
var pdInfo3 = nodeInfo.ParameterData[2];
bool.TryParse(pdInfo3.Value,out var @bool); // 参数来源状态
this.IsCustomData = @bool;
for (int i = 0; i < nodeInfo.ParameterData.Length; i++)
{
var pd = this.MethodDetails.ParameterDetailss[i]; // 本节点的参数信息
ParameterData? pdInfo = nodeInfo.ParameterData[i]; // 项目文件的保存信息
pd.ArgDataSourceNodeGuid = pdInfo.SourceNodeGuid;
pd.ArgDataSourceType = EnumHelper.ConvertEnum<ConnectionArgSourceType>(pdInfo.SourceType);
}
return this;
}
}

71
NodeFlow/Model/SingleExpOpNode.cs
View File

@@ -2,6 +2,7 @@
using Serein.Library.Api;
using Serein.Library.Utils;
using Serein.Library.Utils.SereinExpression;
using System.Dynamic;
using System.Reactive;
using System.Reflection.Metadata;
@@ -25,6 +26,11 @@ namespace Serein.NodeFlow.Model
public partial class SingleExpOpNode : NodeModelBase
{
/// <summary>
/// 表达式参数索引
/// </summary>
private const int INDEX_EXPRESSION = 0;
public SingleExpOpNode(IFlowEnvironment environment) : base(environment)
{
@@ -35,23 +41,46 @@ namespace Serein.NodeFlow.Model
/// </summary>
public override void OnCreating()
{
var pd = new ParameterDetails
// 这里的这个参数是为了方便使用入参控制点，参数无意义
var pd = new ParameterDetails[1];
pd[INDEX_EXPRESSION] = new ParameterDetails
{
Index = 0,
Index = INDEX_EXPRESSION,
Name = nameof(Expression),
DataType = typeof(string),
ExplicitType = typeof(string),
IsExplicitData = false,
DataValue = string.Empty,
DataType = typeof(string),
ExplicitType = typeof(string),
ArgDataSourceNodeGuid = string.Empty,
ArgDataSourceType = ConnectionArgSourceType.GetPreviousNodeData,
NodeModel = this,
Convertor = null,
ExplicitTypeName = "Value",
Items = Array.Empty<string>(),
Items = null,
};
this.MethodDetails.ParameterDetailss = [.. pd];
}
this.MethodDetails.ParameterDetailss = new ParameterDetails[] { pd };
/// <summary>
/// 导出方法信息
/// </summary>
/// <param name="nodeInfo"></param>
/// <returns></returns>
public override NodeInfo SaveCustomData(NodeInfo nodeInfo)
{
dynamic data = new ExpandoObject();
data.Expression = Expression ?? "";
nodeInfo.CustomData = data;
return nodeInfo;
}
/// <summary>
/// 加载自定义数据
/// </summary>
/// <param name="nodeInfo"></param>
public override void LoadCustomData(NodeInfo nodeInfo)
{
this.Expression = nodeInfo.CustomData?.Expression ?? "";
}
@@ -76,8 +105,6 @@ namespace Serein.NodeFlow.Model
parameter = context.TransmissionData(this);
}
try
{
var newData = SerinExpressionEvaluator.Evaluate(Expression, parameter, out bool isChange);
@@ -103,33 +130,5 @@ namespace Serein.NodeFlow.Model
}
public override ParameterData[] GetParameterdatas()
{
return [new ParameterData {
Value = Expression,
SourceNodeGuid = this.MethodDetails.ParameterDetailss[0].ArgDataSourceNodeGuid,
SourceType = this.MethodDetails.ParameterDetailss[0].ArgDataSourceType.ToString(),
}];
}
public override NodeModelBase LoadInfo(NodeInfo nodeInfo)
{
var node = this;
node.Guid = nodeInfo.Guid;
this.Position = nodeInfo.Position;// 加载位置信息
var pdInfo1 = nodeInfo.ParameterData[0];
node.Expression = pdInfo1.Value; // 加载表达式
for (int i = 0; i < nodeInfo.ParameterData.Length; i++)
{
ParameterData? pd = nodeInfo.ParameterData[i];
node.MethodDetails.ParameterDetailss[i].ArgDataSourceNodeGuid = pd.SourceNodeGuid;
node.MethodDetails.ParameterDetailss[i].ArgDataSourceType = EnumHelper.ConvertEnum<ConnectionArgSourceType>(pd.SourceType);
}
return this;
}
}
}

59
NodeFlow/Model/SingleFlipflopNode.cs
View File

@@ -16,13 +16,6 @@ namespace Serein.NodeFlow.Model
}
/// <summary>
/// 加载完成后调用的方法
/// </summary>
public override void OnCreating()
{
}
/// <summary>
/// 执行触发器进行等待触发
@@ -60,59 +53,7 @@ namespace Serein.NodeFlow.Model
throw new FlipflopException(base.MethodDetails.MethodName + "触发器超时触发。Guid" + base.Guid);
}
return dynamicFlipflopContext.Value;
/*try
{
}
catch (FlipflopException ex)
{
if(ex.Type == FlipflopException.CancelClass.CancelFlow)
{
throw;
}
SereinEnv.WriteLine(InfoType.ERROR, $"触发器[{this.MethodDetails.MethodName}]异常：" + ex);
context.NextOrientation = ConnectionInvokeType.None;
context.ExceptionOfRuning = ex;
return null;
}
catch (Exception ex)
{
SereinEnv.WriteLine(InfoType.ERROR, $"触发器[{this.MethodDetails.MethodName}]异常：" + ex);
context.NextOrientation = ConnectionInvokeType.IsError;
context.ExceptionOfRuning = ex;
return null;
}
finally
{
// flipflopTask?.Dispose();
}*/
}
/// <summary>
/// 获取触发器参数
/// </summary>
/// <returns></returns>
public override ParameterData[] GetParameterdatas()
{
if (base.MethodDetails.ParameterDetailss.Length > 0)
{
return MethodDetails.ParameterDetailss
.Select(it => new ParameterData
{
SourceNodeGuid = it.ArgDataSourceNodeGuid,
SourceType = it.ArgDataSourceType.ToString(),
State = it.IsExplicitData,
Value = it.DataValue
})
.ToArray();
}
else
{
return [];
}
}
}
}

122
NodeFlow/Model/SingleGlobalDataNode.cs
View File

@@ -1,30 +1,140 @@
using Serein.Library;
using Newtonsoft.Json.Linq;
using Serein.Library;
using Serein.Library.Api;
using Serein.Library.Utils;
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow.Model
{
/// <summary>
/// Expression Operation - 表达式操作
/// </summary>
[NodeProperty(ValuePath = NodeValuePath.Node)]
public partial class SingleGlobalDataNode : NodeModelBase
{
/// <summary>
/// 表达式
/// </summary>
[PropertyInfo(IsNotification = true, CustomCodeAtStart = "ChangeName(value);")]
private string _keyName;
}
/// <summary>
/// 全局数据节点
/// </summary>
public class SingleGlobalDataNode : NodeModelBase
public partial class SingleGlobalDataNode : NodeModelBase
{
public SingleGlobalDataNode(IFlowEnvironment environment) : base(environment)
{
}
public override ParameterData[] GetParameterdatas()
/// <summary>
/// 数据节点
/// </summary>
private string? DataNodeGuid;
/// <summary>
/// 设置数据节点
/// </summary>
/// <param name="dataNode"></param>
public void SetDataNode(NodeModelBase dataNode)
{
throw new NotImplementedException();
DataNodeGuid = dataNode.Guid;
}
public override void OnCreating()
private void ChangeName(string newName)
{
throw new NotImplementedException();
if(SereinEnv.GetFlowGlobalData(_keyName) == null)
{
return;
}
SereinEnv.ChangeNameFlowGlobalData(_keyName, newName);
}
/// <summary>
/// 设置全局数据
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override async Task<object> ExecutingAsync(IDynamicContext context)
{
if (string.IsNullOrEmpty(KeyName))
{
context.NextOrientation = ConnectionInvokeType.IsError;
SereinEnv.WriteLine(InfoType.ERROR, $"全局数据的KeyName不能为空[{this.Guid}]");
return null;
}
if (DataNodeGuid == null)
{
context.NextOrientation = ConnectionInvokeType.IsError;
SereinEnv.WriteLine(InfoType.ERROR, $"全局数据节点没有数据[{this.Guid}]");
return null;
}
try
{
var result = await context.Env.InvokeNodeAsync(context, DataNodeGuid);
SereinEnv.AddOrUpdateFlowGlobalData(KeyName, result);
return result;
}
catch (Exception ex)
{
context.NextOrientation = ConnectionInvokeType.IsError;
context.ExceptionOfRuning = ex;
return null;
}
}
/// <summary>
/// 保存全局变量的数据
/// </summary>
/// <param name="nodeInfo"></param>
/// <returns></returns>
public override NodeInfo SaveCustomData(NodeInfo nodeInfo)
{
dynamic data = new ExpandoObject();
nodeInfo.CustomData = data;
data.KeyName = KeyName; // 变量名称
if (string.IsNullOrEmpty(DataNodeGuid))
{
return nodeInfo;
}
data.DataNodeGuid = DataNodeGuid; // 数据节点Guid
nodeInfo.ChildNodeGuids = [DataNodeGuid];
return nodeInfo;
}
/// <summary>
/// 加载全局变量的数据
/// </summary>
/// <param name="nodeInfo"></param>
public override void LoadCustomData(NodeInfo nodeInfo)
{
KeyName = nodeInfo.CustomData?.KeyName;
DataNodeGuid = nodeInfo.CustomData?.DataNodeGuid;
}
/// <summary>
/// 需要移除数据节点
/// </summary>
public override void Remove()
{
// 移除数据节点
_ = this.Env.RemoveNodeAsync(DataNodeGuid);
}
}
}

5
NodeFlow/MoveNodeData.cs
View File

@@ -1,5 +0,0 @@
namespace Serein.NodeFlow
{
}

110
NodeFlow/NodeMVVMManagement.cs Normal file
View File

@@ -0,0 +1,110 @@
using Serein.Library;
using Serein.Library.Utils;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Serein.NodeFlow
{
/// <summary>
/// 节点类型
/// </summary>
public class NodeMVVM
{
/// <summary>
/// 节点类型
/// </summary>
public required NodeControlType NodeType { get; set; }
/// <summary>
/// 节点Model类型
/// </summary>
public required Type ModelType { get; set; }
/// <summary>
/// 节点视图控件类型
/// </summary>
public Type? ControlType { get; set; }
/// <summary>
/// 节点视图VM类型
/// </summary>
public Type? ViewModelType { get; set; }
public override string ToString()
{
return $"$[{NodeType}]类型信息 : ModelType->{ModelType};ControlType->{ControlType};ViewModelType->{ViewModelType}";
}
}
/// <summary>
/// 节点 数据、视图、VM 管理
/// </summary>
public static class NodeMVVMManagement
{
/// <summary>
/// 节点对应的控件类型
/// </summary>
private static ConcurrentDictionary<NodeControlType, NodeMVVM> FlowNodeTypes { get; } = [];
/// <summary>
/// 注册 Model 类型
/// </summary>
/// <param name="type"></param>
/// <param name="modelType"></param>
public static bool RegisterModel(NodeControlType type, Type modelType)
{
if(FlowNodeTypes.TryGetValue(type,out var nodeMVVM))
{
SereinEnv.WriteLine(InfoType.WARN, $"无法为节点[{type}]注册Model类型[{modelType}]，已经注册的类型为{nodeMVVM}。");
return false;
}
nodeMVVM = new NodeMVVM
{
NodeType = type,
ModelType = modelType
};
return FlowNodeTypes.TryAdd(type, nodeMVVM);
}
/// <summary>
/// 注册 UI 类型
/// </summary>
/// <param name="type"></param>
/// <param name="controlType"></param>
/// <param name="viewModelType"></param>
public static bool RegisterUI(NodeControlType type, Type controlType,Type viewModelType)
{
if (!FlowNodeTypes.TryGetValue(type, out var nodeMVVM))
{
SereinEnv.WriteLine(InfoType.WARN, $"无法为节点[{type}]注册UI类型[{controlType}][{viewModelType}]，当前类型尚未注册。");
return false;
}
nodeMVVM.ControlType = controlType;
nodeMVVM.ViewModelType = viewModelType;
return true;
}
/// <summary>
/// 获取相应的类型
/// </summary>
/// <param name="type"></param>
/// <param name="nodeMVVM"></param>
/// <returns></returns>
public static bool TryGetType(NodeControlType type, out NodeMVVM nodeMVVM)
{
if( FlowNodeTypes.TryGetValue(type, out nodeMVVM))
{
return nodeMVVM != null;
}
else
{
return false;
}
}
}
}

6
NodeFlow/Tool/FlowLibrary.cs
View File

@@ -64,6 +64,10 @@ namespace Serein.NodeFlow
}
/// <summary>
/// 转为依赖信息
/// </summary>
/// <returns></returns>
public NodeLibraryInfo ToInfo()
{
return new NodeLibraryInfo
@@ -72,6 +76,8 @@ namespace Serein.NodeFlow
FileName = Path.GetFileName(assembly.Location),
FilePath = assembly.Location,
};
}