IBridge/Future
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

将以往的代码复制到代码库

Browse Source
This commit is contained in:
于智纯
2025-08-30 17:19:57 +08:00
parent da46e0242d
commit 20ea70bf64
198 changed files with 10075 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
Future.Contract/Instruction/BehaviorInstructBase.cs Normal file
View File

@@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 所有行为指令的公共基类，可以附加于“目标”指令，为目标指令附加对应的参数并初始化；行为指令可以单独开线程执行
/// </summary>
public abstract class BehaviorInstructBase //: FutureInstruct
{
/// <summary>
/// 目标指令的上下文名称
/// </summary>
public string Target { get; set; }
}
}

44
Future.Contract/Instruction/CommandInstruct.cs Normal file
View File

@@ -0,0 +1,44 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 可以通过管道向执行空间发送临时的命令;是一种结构指令，允许有子指令序列；只能是指令空间的直接子节点，不会自动执行，只能由运行引擎或态势感知视图手动点击执行
/// </summary>
public class CommandInstruct : StructInstructBase
{
protected override string GetInstructValExp()
{
throw new NotImplementedException();
}
protected override string CheckChild(FutureInstruct childInst)
{
throw new NotImplementedException();
}
protected override string CheckParent(FutureInstruct parentInst)
{
throw new NotImplementedException();
}
protected override InstructResult DoExecute(IEnumerable<IOutputChannel> outChannels)
{
throw new NotImplementedException();
}
protected override void DoVerify(IOutputChannel infoChannel)
{
throw new NotImplementedException();
}
public override IEnumerable<ExpressionHandle> GetExpressionHandles(EParameterKind kind)
{
throw new NotImplementedException();
}
}
}

19
Future.Contract/Instruction/ConditionalInstruct.cs Normal file
View File

@@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 所有条件判定指令的公共基类
/// </summary>
public abstract class ConditionalInstruct : LogicalInstructBase
{
/// <summary>
/// 是否为取反逻辑
/// </summary>
public bool IsReverseLogic { get; set; }
}
}

27
Future.Contract/Instruction/ExpressionHandle.cs Normal file
View File

@@ -0,0 +1,27 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 表达式的描述类；用于将参数封装成表达式，以减少渲染消耗
/// </summary>
public class ExpressionHandle
{
/// <summary>
/// 表达式
/// </summary>
public string Handle { get; set; }
/// <summary>
/// 标题
/// </summary>
public string Title { get; set; }
/// <summary>
/// 描述
/// </summary>
public string Remark { get; set; }
}
}

56
Future.Contract/Instruction/InstructResult.cs Normal file
View File

@@ -0,0 +1,56 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 用于封装统一过程调用结果回执
/// </summary>
public class InstructResult
{
/// <summary>
/// 用于创建过程调用回执
/// </summary>
/// <param name="instLabel">指令编号</param>
/// <param name="receipt">调用回执，默认为[ResultE.Normal]</param>
/// <param name="result">调用结果，默认为[null]</param>
/// <param name="message">告警消息，默认为[""]</param>
/// <param name="exeption">崩溃异常，默认为[null]</param>
public InstructResult(string instLabel,EInstructReceipt receipt= EInstructReceipt.Normal, object result=null, string message="", Exception exeption=null)
{
this.InstLabel = instLabel;
this.Receipt = receipt;
this.Return = result;
this.Message = message;
this.Exception = exeption;
}
/// <summary>
/// 指令序列标号，用于在日志与指令序列相对照
/// </summary>
public string InstLabel { get; set; }
/// <summary>
/// 过程调用回执，指示调用方的后续工作行为
/// </summary>
public EInstructReceipt Receipt { get; set; }
/// <summary>
/// 信息输出位置，用于指示报告生成器或是态势感知器的行为
/// </summary>
public EInstructOutput Postion { get; set; }
/// <summary>
/// 过程调用结果，如果返回数据则存储于此属性
/// </summary>
public object Return { get; set; }
/// <summary>
/// 如果发生告警，则告警信息存储于此属性
/// </summary>
public String Message { get; set; }
/// <summary>
/// 如果发生崩溃，则异常信息存储于此属性
/// </summary>
public Exception Exception { get; set; }
}
}

17
Future.Contract/Instruction/LogicalInstructBase.cs Normal file
View File

@@ -0,0 +1,17 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 所有逻辑指令的公共基类
/// </summary>
[InstructionDefine(InstKind = EInstructionKind.Logical)]
public abstract class LogicalInstructBase : FutureInstruct
{
//
}
}

29
Future.Contract/Instruction/LoopInstructBase.cs Normal file
View File

@@ -0,0 +1,29 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 迭代空间的公共基类，可以使用Continue和Break实现迭代控制
/// </summary>
public abstract class LoopInstructBase : StructInstructBase
{
public ELoopState LoopState { get; internal set; }
/// <summary>
/// 执行迭代逻辑
/// </summary>
/// <param name="outChannels">信息输出管道，可以向其中输出信息</param>
/// <returns></returns>
protected sealed override InstructResult DoExecute(IEnumerable<IOutputChannel> outChannels)
{
//if()
return this.DoLoop(outChannels);
}
protected abstract InstructResult DoLoop(IEnumerable<IOutputChannel> outChannels);
}
}

56
Future.Contract/Instruction/PlaceholderInstruct.cs Normal file
View File

@@ -0,0 +1,56 @@
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Navigation;
namespace Future.Contract
{
/// <summary>
/// 占位符指令，用于在编辑指令序列时临时标记还未开发完成的指令
/// </summary>
[InstructionDefine(InstKind = EInstructionKind.Design,AllowAddParameter =true)]
public sealed class PlaceholderInstruct : FutureInstruct,IConfigurableObject
{
protected override string GetInstructValExp()
{
throw new NotImplementedException();
}
protected override string CheckChild(FutureInstruct childInst)
{
throw new NotImplementedException();
}
protected override string CheckParent(FutureInstruct newParent)
{
throw new NotImplementedException();
}
protected override InstructResult DoExecute(IEnumerable<IOutputChannel> outChannels)
{
throw new NotImplementedException();
}
protected override void DoFinally( IEnumerable<IOutputChannel> outChannels, InstructResult result)
{
throw new NotImplementedException();
}
protected override void DoVerify(IOutputChannel infoChannel)
{
throw new NotImplementedException();
}
public override IEnumerable<ExpressionHandle> GetExpressionHandles(EParameterKind kind )
{
throw new NotImplementedException();
}
}
}

19
Future.Contract/Instruction/SignalInstructBase.cs Normal file
View File

@@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 所有信令指令的公共基类，需要命名信道
/// </summary>
public abstract class SignalInstructBase //: FutureInstruct
{
/// <summary>
/// 命名信道：可以通过名称从上下文中获得指定的通信信道引用
/// </summary>
public string ChannelName { get; set; }
}
}

273
Future.Contract/Instruction/SpaceInstructBase.cs Normal file
View File

@@ -0,0 +1,273 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 指令空间：有独立的参数和信道上下文
/// </summary>
public abstract class SpaceInstructBase : StructInstructBase
{
#region 指令序列设计支持逻辑
/// <summary>
/// 指令空间的序列标签Label种子
/// </summary>
public int LabelSeed { get; set; }
protected override void DoVerify(IOutputChannel infoChannel)
{
this.ReferenceMapping.Clear();
this.BuildReferenceMapping(this.ReferenceMapping);
this.InsturctContext.Clear();
this.ParameterContext.Clear();
this.ChannelContext.Clear();
}
protected override string CheckParent(FutureInstruct parentInst)
{
if (parentInst != null)
return "指令空间不可以成为任何一个指令的子级指令！";
else return null;
}
#endregion
#region 指令执行逻辑
/// <summary>
/// 指令序列的执行状态
/// </summary>
public ESpaceState State { get; set; }
/// <summary>
/// 启动指令序列的执行逻辑,自类可以重写这个逻辑
/// </summary>
/// <param name="infoOutChannel">用于输出验证信息或其它过程提示信息的输出通道</param>
/// <param name="expansionChannels">消息输出管道、态势感知管道、报告生成管道等</param>
/// <param name="needThread">是否需要开启独立线程还执行？默认=false</param>
/// <returns>如果失败则返回原因，正常启动返回“null”</returns>
public virtual string Start(IOutputChannel infoOutChannel, IEnumerable<IOutputChannel> expansionChannels = null, bool needThread = false)
{
if (this.State != ESpaceState.Finished) return $"当前指令序列正在执行或暂停，不可重复启动！";
//先执行一次指令校验
this.Verify(infoOutChannel);
if (infoOutChannel.OutputMessageCount > 0) return $"当前指令序列运行校验失败，存在【{infoOutChannel.OutputMessageCount}】个问题，请检查指令序列的配置！";
//清空所有上下文
this.__ExpansionChannels.Clear();
this.ReferenceMapping.Clear();
this.InsturctContext.Clear();
this.ParameterContext.Clear();
this.ChannelContext.Clear();
this.__ExpansionChannels.AddRange(expansionChannels);
//个性化启动准备
string startMsg = this.OnPreStart();
if (startMsg != null) return startMsg;
this.State = ESpaceState.Normal;
if (needThread)
{
//TODO:指令执行逻辑=>启动线程并使用新线程执行Execute方法或DoExecute方法
}
else this.Execute();
return null;
}
/// <summary>
/// 子类必须实现的启动准备逻辑
/// </summary>
/// <returns>如果启动准备失败则需要返回失败原因</returns>
protected abstract string OnPreStart();
/// <summary>
/// 发送暂停通知，等待执行引擎在执行到检查周期时开始等待
/// </summary>
/// <returns>如果失败则返回原因</returns>
public virtual string Pause() { return null; }
/// <summary>
/// 发送继续通知，等待执行引擎在执行到检查周期时继续执行
/// </summary>
/// <returns>如果失败则返回原因</returns>
public virtual string Rouse() { return null; }
/// <summary>
/// 发出终止通知，等待执行引擎在执行到检查周期时自动停止
/// </summary>
/// <returns>如果失败则返回原因</returns>
public virtual string Break() { return null; }
/// <summary>
/// 强制终止，强制终止引擎的执行线程，可能会造成未知错误
/// </summary>
/// <returns>如果失败则返回原因</returns>
public virtual string Abort() { return null; }
/// <summary>
/// 执行结束时需要进行的操作
/// </summary>
public abstract void OnFinished();
/// <summary>
/// 当执行完成时发出的通知
/// </summary>
public event EventHandler Finished;
#endregion
#region 扩展通道逻辑
private readonly List<IOutputChannel> __ExpansionChannels = new List<IOutputChannel>();
/// <summary>
/// 扩展信道表，用于进行态势感知、报告生成等行为的扩展信道表
/// </summary>
/// <returns></returns>
public IEnumerable<IOutputChannel> OutChannels() { yield break; }
#endregion
#region 指令与参数上下文逻辑
/// <summary>
/// 存储一个指令空间中所有指令的“值”
/// </summary>
private readonly Dictionary<string, string> InsturctContext = new Dictionary<string, string>();
/// <summary>
/// 以指令为单位存储一个指令空间中所有指令的参数值
/// </summary>
private readonly Dictionary<string, Dictionary<string, string>> ParameterContext = new Dictionary<string, Dictionary<string, string>>();
/// <summary>
/// 设置一个参数的值，如果这个参数尚未存在于上下文中则创建上下文参数
/// </summary>
/// <param name="key">上下文参数名</param>
/// <param name="value">参数值</param>
public void SetParameter(string key, string value)
{
string[] args = key.Split(new char[] { FutureInstruct.PR_SplitChar, FutureInstruct.PR_StartChar }, StringSplitOptions.RemoveEmptyEntries);
switch (args.Length)
{
case (1):
{
if (this.InsturctContext.ContainsKey(args[0]))
InsturctContext[args[0]] = value;
else InsturctContext.Add(args[0], value);
}
break;
case (2):
{
if (!this.ParameterContext.ContainsKey(args[0]))
this.ParameterContext.Add(args[0], new Dictionary<string, string>());
Dictionary<string, string> param = this.ParameterContext[args[0]];
if (param.ContainsKey(args[1])) param[args[1]] = value;
else param.Add(args[1], value);
}
break;
default: return;
}
}
/// <summary>
/// 获取一个上下文参数的值，如果这个上下文参数不存在则返回默认值
/// </summary>
/// <param name="key">上下文参数名</param>
/// <param name="default">默认值</param>
/// <returns>参数的值</returns>
public string GetParameter(string key, string @default)
{
string[] args = key.Split(new char[] { FutureInstruct.PR_SplitChar, FutureInstruct.PR_StartChar }, StringSplitOptions.RemoveEmptyEntries);
switch (args.Length)
{
case (1):
{
if (this.InsturctContext.ContainsKey(args[0]))
return this.InsturctContext[args[0]];
else return @default;
}
case (2):
{
if (!this.ParameterContext.ContainsKey(args[0]))
this.ParameterContext.Add(args[0], new Dictionary<string, string>());
Dictionary<string, string> param = this.ParameterContext[args[0]];
if (param.ContainsKey(args[1])) return param[args[1]];
else return @default;
}
default: return @default;
}
}
/// <summary>
/// 检查上下文中是否存在制定名称的参数
/// </summary>
/// <param name="key">上下文参数名称</param>
/// <returns>是/否</returns>
public bool IsExistParameter(string key)
{
string[] args = key.Split(new char[] { FutureInstruct.PR_SplitChar, FutureInstruct.PR_StartChar }, StringSplitOptions.RemoveEmptyEntries);
switch (args.Length)
{
case (1):
{
if (this.InsturctContext.ContainsKey(args[0])) return true;
}
break;
case (2):
{
if (!this.ParameterContext.ContainsKey((string)args[0])) return false;
if (this.ParameterContext[args[0]].ContainsKey(args[1])) return true;
break;
}
default: return false;
}
return false;
}
#endregion
#region 信道上下文逻辑
/// <summary>
/// 以信道名称为Key，存储当前指令空间中所有已经完成初始化化的通信信道
/// </summary>
private readonly Dictionary<string, CommChannel> ChannelContext = new Dictionary<string, CommChannel>();
/// <summary>
/// 向上下文注册信道，如果信道名称已经存在则会报错
/// </summary>
/// <param name="key">通信信道名称</param>
/// <param name="channel">信道实例</param>
public void SetChannel(string key, CommChannel channel)
{
key = key.TrimStart(FutureInstruct.PR_StartChar);
if (!this.ChannelContext.ContainsKey(key))
this.ChannelContext.Add(key, channel);
else this.ChannelContext[key] = channel;
}
/// <summary>
/// 从上下文中获取通信信道实例
/// </summary>
/// <param name="key">通信信道名称</param>
/// <returns>获得的通信信道实例</returns>
public CommChannel GetChannel(string key)
{
key = key.TrimStart(FutureInstruct.PR_StartChar);
if (!ChannelContext.ContainsKey(key)) return this.ChannelContext[key];
return null;
}
/// <summary>
/// 检查上下文中是否存在制定名称的通信信道
/// </summary>
/// <param name="key">通信信道名称</param>
/// <returns>是/否</returns>
public bool IsExistChannel(string key)
{
key = key.TrimStart(FutureInstruct.PR_StartChar);
return this.ChannelContext.ContainsKey(key);
}
#endregion
#region 指令与参数引用校验逻辑
/// <summary>
/// 指令引用表：指示那些指令被其它指令引用，用于加速指令的运行，减小指令上下文与参数上下文的内存占用
/// </summary>
private readonly List<string> ReferenceMapping = new List<string>();
/// <summary>
/// 检查一个指令或是指令的参数是否被其它指令引用；只允许在执行态被使用
/// </summary>
/// <param name="identify">指令或是参数的标识符</param>
/// <returns>如果被引用则返回True,否则返回False</returns>
public bool IsExistReference(string identify)
{
if (string.IsNullOrEmpty(identify)) return false;
return this.ReferenceMapping.Contains(identify);
}
#endregion
}
}

18
Future.Contract/Instruction/StructInstructBase.cs Normal file
View File

@@ -0,0 +1,18 @@
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.AccessControl;
using System.Text;
using System.Threading.Tasks;
namespace Future.Contract
{
/// <summary>
/// 所有指令空间的基类，可以使用Return指令退出
/// </summary>
public abstract class StructInstructBase : FutureInstruct
{
}
}