public B业务()
{
var __IT服务端 = H容器.取出 <IT服务端>();
__IT服务端.添加对象("对象1", 创建工程通用访问对象);
__IT服务端.添加对象("对象2", 创建开发通用访问对象);
}
public void 多接口拦截()
{
IA __IA = H容器.接口拦截 <IA>(new BA4(), new Type[] { typeof(IC) }, (__methodBase, __target, __args) =>
{
if (__methodBase == typeof(IC).GetMethod("M4"))
{
}
return(new Tuple <object, object[]>(100, null));
//return new Tuple<object, object[]>(((IC)__target).M4(), null); //死循环
});
__IA.E1 += Console.WriteLine;
Console.WriteLine(__IA.P1);
__IA.P1 = 1;
Console.WriteLine(__IA.P1);
__IA.M1();
__IA.M2(1, "A");
string __arg1;
string __arg2 = "2";
Console.WriteLine(__IA.M3(new DTO {
P1 = 2, P2 = "S"
}, out __arg1, ref __arg2));
__IA.OnE1(new DTO {
P1 = 3, P2 = "SS"
});
var __result = ((IC)__IA).M4();
Console.WriteLine(__result);
}
static void Main(string[] args)
{
H调试.初始化();
if (!Environment.UserInteractive)
{
var ServicesToRun = new ServiceBase[] { new Service1() };
ServiceBase.Run(ServicesToRun);
return;
}
if (System.Diagnostics.Debugger.IsAttached)
{
var __B控制器 = new B控制器();
__B控制器.配置();
__B控制器.开启();
Application.Run(new F对话框_确定("程序处于调试模式, 按确定键关闭", "GIS服务器 - 调试模式 " + H调试.查询版本()));
__B控制器.关闭();
return;
}
HUI线程.初始化();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
H容器.注入 <ID数据库, D数据库>();
H容器.注入 <IB数据库, B数据库>();
Application.Run(new F空窗口(new F主窗口(), "GIS服务器 - 运行环境 " + H调试.查询版本()));
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
var __1倍速 = new { 速度 = 1, 描述 = "1点/秒" };
var __3倍速 = new { 速度 = 3, 描述 = "3点/秒" };
var __5倍速 = new { 速度 = 5, 描述 = "5点/秒" };
var __倍速列表 = new List <object> {
__1倍速, __3倍速, __5倍速
};
this.in速度.DisplayMember = "描述";
this.in速度.ValueMember = "速度";
this.in速度.DataSource = __倍速列表;
this.in速度.SelectedValue = 3;
this.out进度.Enabled = false;
this.out进度.Minimum = 0;
this.out进度.Maximum = 100;
this.out进度.TickFrequency = 10;
this.out地图.Controls.Add(_FGPS);
H容器.虚方法拦截 <P回放_按频率>().处理视图(this, _初始化参数);
this.do暂停.Click += (sender1, e1) => this.On暂停();
this.do停止.Click += (sender1, e1) => this.On停止();
this.do播放.Click += (sender1, e1) => this.On播放((int)this.in速度.SelectedValue);
this.in速度.SelectedValueChanged += (sender1, e1) => this.On改变播放参数((int)this.in速度.SelectedValue);
this.out进度.ValueChanged += Out进度_ValueChanged;
}
public void 开启()
{
HB日志.记录("系统", "开启");
B通用命令.开启();
H容器.取出 <IB插件>().开启();
_IT服务端.开启();
}
public void 属性()
{
H容器.注入 <IBDemo, BDemo>();
H容器.注入 <IB属性, B属性>();
var __对象 = H容器.取出 <IB属性>();
Assert.AreEqual(8, __对象.IA.P1);
}
public void 方法参数()
{
H容器.注入 <IBDemo, BDemo>();
H容器.注入 <IB方法参数, B方法参数>();
var __对象 = H容器.取出 <IB方法参数>();
Assert.AreEqual(8, __对象.IA.P1);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.Controls.Add(地图);
显示等待("加载地图");
加载地图(H容器.取出 <IB地图路径配置>().查询());
隐藏等待();
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.tabControl1.Controls.RemoveAt(0);
H容器.虚方法拦截 <P配置>().处理视图(this);
this.do取消.Click += do取消_Click;
this.do确定.Click += do确定_Click;
}
void 设置状态()
{
H容器.取出 <IB状态_S>().设置属性("类别1", "属性1", () => new M业务概要 {
当前值 = "1", 正常 = true
});
H容器.取出 <IB状态_S>().设置属性("类别1", "属性2", () => new M业务概要 {
当前值 = "1", 正常 = false
});
}
public FGPS()
{
H接口注册.设置();
InitializeComponent();
this.地图 = new F地图 {
Dock = DockStyle.Fill
};
this._PGPS = H容器.虚方法拦截 <PGPS>();
}
public void 命名()
{
H容器.注入 <IBDemo, BDemo>();
H容器.注入 <IBDemo, BDemo>(true, true, "1");
var __A = H容器.取出 <IBDemo>();
var __B = H容器.取出 <IBDemo>("1");
__A.P1 = 1;
Assert.AreEqual(1, __A.P1);
Assert.AreEqual(8, __B.P1);
}
void do连接_Click(object sender, EventArgs e)
{
var __ip = this.inIP2.Text;
var __port = this.in端口号.Text;
var __最后访问 = _访问记录.Find(q => q.IP.ToString() == __ip && q.端口号.ToString() == __port);
if (__最后访问 == null)
{
if (!H检测网络.IsHostAlive(__ip, int.Parse(__port), 2000))
{
new F对话框_确定("连接失败").ShowDialog();
return;
}
else
{
__最后访问 = new M访问记录 {
IP = __ip, 端口号 = int.Parse(__port)
};
}
}
else
{
_访问记录.Remove(__最后访问);
}
_访问记录.Insert(0, __最后访问);
H程序配置.设置("访问记录", H序列化.ToJSON字符串(_访问记录));
H日志输出.设置(q =>
{
if (q.等级 <= TraceEventType.Information)
{
if (q.异常 != null)
{
H日志.记录异常(q.异常, q.概要, q.详细, q.等级, q.方法, q.文件, q.行号);
}
else
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}
});
_IT客户端 = FT通用访问工厂.创建客户端();
H容器.注入 <IT客户端>(_IT客户端, false);
_IT客户端.自动重连 = true;
_IT客户端.已断开 += q => 设置连接状态();
_IT客户端.已连接 += 设置连接状态;
_IT客户端.连接(new IPEndPoint(IPAddress.Parse(__ip), int.Parse(__port)));
this.ParentForm.ShowInTaskbar = false;
this.ParentForm.Visible = false;
_F主窗口 = new F空窗口(new F主窗口(), "");
设置连接状态();
_F主窗口.FormClosing += OnClosing;
_F主窗口.ShowDialog();
}
public void 更新(M基本状态 状态)
{
var __发生重要变化 = 验证是否发生重要变化(_基本状态.待处理问题, 状态.待处理问题);
_基本状态.待处理问题 = 状态.待处理问题;
_基本状态.连接设备 = 状态.连接设备;
_基本状态.业务状态 = 状态.业务状态;
if (__发生重要变化)
{
On发生了重要变化(_基本状态);
H容器.取出 <IT服务端>().触发事件("基本状态", "发生了重要变化");
}
}
void 配置通用访问(string __对象名称)
{
if (!H容器.可取出 <IT服务端>())
{
return;
}
var __IT服务端 = H容器.取出 <IT服务端>();
var __对象 = new M对象(__对象名称, null);
__对象.添加方法("设置连接参数", __实参列表 =>
{
var __账号 = __实参列表["账号"];
var __密码 = __实参列表["密码"];
var __数据源 = __实参列表["数据源"];
保存连接参数(__账号, __密码, __数据源);
return("");
}, E角色.工程, new List <M形参> {
new M形参("账号", "string"), new M形参("密码", "string"), new M形参("数据源", "string")
});
__对象.添加属性("账号", () => 账号, E角色.工程);
__对象.添加属性("密码", () => 密码, E角色.工程);
__对象.添加属性("数据源", () => 地址, E角色.工程);
__对象.添加属性("保留天数", () => H程序配置.获取字符串("保留天数"), E角色.工程);
__对象.添加方法("设置保留天数", __实参列表 =>
{
var __天数 = __实参列表["天数"];
H程序配置.设置("保留天数", __天数);
return("");
}, E角色.工程, new List <M形参> {
new M形参("天数", "int")
});
__对象.添加方法("检测连接", __实参列表 =>
{
var __账号 = __实参列表["账号"];
var __密码 = __实参列表["密码"];
var __数据源 = __实参列表["数据源"];
if (_D数据库.连接SQLSERVER(__账号, __密码, __数据源))
{
if (_D数据库.存在GIS数据库(__账号, __密码, __数据源, 称))
{
return("连接 MS SQL SERVER 成功, GIS数据库已存在");
}
return("连接 MS SQL SERVER 成功, GIS数据库未创建");
}
return("连接 MS SQL SERVER 失败");
}, E角色.工程, new List <M形参> {
new M形参("账号", "string"), new M形参("密码", "string"), new M形参("数据源", "string")
});
__IT服务端.添加对象(__对象名称, () => __对象);
}
public void 配置()
{
var __调试编解码 = H程序配置.获取Bool值("调试编解码");
H日志输出.设置(q =>
{
if (q.等级 < TraceEventType.Information || __调试编解码)
{
if (q.异常 != null)
{
H日志.记录异常(q.异常, q.概要, q.详细, q.等级, q.方法, q.文件, q.行号);
}
else
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}
}, TraceEventType.Verbose);
_IT服务端 = FT通用访问工厂.创建服务端();
_IT服务端.端口 = H程序配置.获取Int32值("端口号");
H容器.注入(_IT服务端, false);
B通用命令.配置(_IT服务端);
H容器.注入 <IB数据库, B数据库>();
H容器.注入 <IB插件, B插件>();
H容器.注入 <IB订阅, B订阅>();
H容器.注入 <IBGPS数据, BGPS数据>();
if (H程序配置.获取Bool值("内存数据库"))
{
H容器.注入 <ID数据库, D数据库_内存>();
H容器.注入 <IDGPS数据, DGPS数据_内存>(__拦截: false);
H容器.注入 <IB日志, B日志_内存>(__拦截: false);
}
else
{
H容器.注入 <ID数据库, D数据库>();
H容器.注入 <IDGPS数据, DGPS数据>(__拦截: false);
H容器.注入 <IB日志, B日志_内存>(__拦截: false); //未保存到数据库
}
H容器.注入 <IBGPS过滤, BGPS过滤>(__拦截: false);
H容器.取出 <IB数据库>().初始化();
H容器.取出 <IB订阅>().初始化();
H容器.取出 <IB插件>().初始化();
H容器.取出 <IBGPS数据>().初始化();
H容器.取出 <IB日志>().初始化();
}
public static void 设置()
{
if (!_已初始化)
{
_已初始化 = true;
}
else
{
return;
}
H调试.初始化();
H容器.注入 <IB服务器配置, B服务器配置>();
H容器.注入 <IBGPS状态配置, BGPS状态配置>();
H容器.注入 <IB地图路径配置, B地图路径配置>();
H容器.注入 <IB回放_按时间, B回放_按时间>();
H容器.注入 <IB回放_按频率, B回放_按频率>();
}
public void 生命周期()
{
H容器.注入 <IBDemo, BDemo1>();
var __A = H容器.取出 <IBDemo>();
var __B = H容器.取出 <IBDemo>();
__A.P1 = 1;
//Assert.AreEqual(__A, __B);
Assert.AreEqual(__A.P1, __B.P1);
H容器.注入 <IBDemo, BDemo2>(false);
var __C = H容器.取出 <IBDemo>();
var __D = H容器.取出 <IBDemo>();
__C.P1 = 1;
Assert.AreNotEqual(__C.P1, __D.P1);
}
private void 配置通用访问(string __对象名称)
{
var __对象 = new M对象(__对象名称, null);
__对象.添加属性("配置", () => HJSON.序列化(查询状态()), E角色.工程);
__对象.添加方法("设置", q =>
{
var __配置 = HJSON.反序列化 <List <M插件配置> >(q["配置"]);
设置(__配置);
return(null);
}, E角色.工程, new List <M形参> {
new M形参("配置", new M元数据 {
结构 = E数据结构.对象数组, 子成员列表 = new List <M子成员>
{
new M子成员("目录", "string"), new M子成员("启用", "bool")
}
})
});
H容器.取出 <IT服务端>().添加对象(__对象名称, () => __对象);
}
public void 虚方法拦截()
{
BA3 __IA = H容器.虚方法拦截 <BA3>();
__IA.E1 += Console.WriteLine;
Console.WriteLine(__IA.P1);
__IA.P1 = 1;
Console.WriteLine(__IA.P1);
__IA.M1();
__IA.M2(1, "A");
string __arg1;
string __arg2 = "2";
Console.WriteLine(__IA.M3(new DTO {
P1 = 2, P2 = "S"
}, out __arg1, ref __arg2));
__IA.OnE1(new DTO {
P1 = 3, P2 = "SS"
});
}
public void 透明拦截2()
{
IA __IA = H容器.透明拦截 <IA>(new BA1());
__IA.E1 += Console.WriteLine;
Console.WriteLine(__IA.P1);
__IA.P1 = 1;
Console.WriteLine(__IA.P1);
__IA.M1();
__IA.M2(1, "A");
string __arg1;
string __arg2 = "2";
Console.WriteLine(__IA.M3(new DTO {
P1 = 2, P2 = "S"
}, out __arg1, ref __arg2));
__IA.OnE1(new DTO {
P1 = 3, P2 = "SS"
});
}
static void Main()
{
H调试.初始化();
IT服务端 __IT服务端 = FT通用访问工厂.创建服务端();
H容器.注入 <IT服务端>(__IT服务端);
H容器.注入 <IB基本状态, B基本状态>();
H容器.注入 <IB业务, B业务>();
H容器.注入 <IB调试信息, B调试信息>();
var __对象 = new B测试().创建对象();
__IT服务端.添加对象("测试", () => __对象);
__IT服务端.端口 = 8888;
__IT服务端.开启();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
F主窗口 = new F主窗口();
Application.Run(F主窗口);
}
public static void 配置(IT服务端 __IT服务端)
{
H容器.注入 <IB名片_S, B名片_S>(true, false, "", __IT服务端);
H容器.注入 <IB系统_S, B系统_S>(true, false, "", __IT服务端);
H容器.注入 <IB状态_S, B状态_S>(true, false, "", __IT服务端);
H容器.注入 <IBFTP_S, BFTP_S>(true, false, "", __IT服务端);
var __版本号 = H程序配置.获取字符串("版本号");
if (string.IsNullOrEmpty(__版本号))
{
__版本号 = H调试.查询版本();
}
H容器.取出 <IB名片_S>().初始化(
new M名片 {
称 = "GIS服务器", 描述 = "", 版本号 = __版本号, 版本时间 = H程序配置.获取字符串("版本时间")
},
new List <M参数>
{
new M参数("IP列表", HJSON.序列化(H网络配置.获取IP配置())),
new M参数("操作系统", Environment.OSVersion.ToString()),
new M参数("64位系统", Environment.Is64BitOperatingSystem.ToString()),
new M参数("登录账号", Environment.UserName),
});
H容器.取出 <IB状态_S>().初始化(null, DateTime.Now);
H容器.取出 <IBFTP_S>();
H容器.取出 <IB系统_S>().初始化(() =>
{
H日志.记录提示("重启");
H服务管理.重启("GIS服务器", new TimeSpan(0, 1, 0));
}, () =>
{
H日志.记录提示("关闭");
H服务管理.关闭("GIS服务器", new TimeSpan(0, 1, 0));
}, () => new List <M版本记录>
{
//new M版本记录{ 版本号 = "1.0.0.0", 修改记录 = "xxx", 标签 = new List<string>{ "a", "b"}},
//new M版本记录{ 版本号 = "1.0.1.0", 修改记录 = "yyy", 标签 = new List<string>{ "a1", "b1"}},
});
}
private void 配置通用访问(string __对象名称)
{
var __对象 = new M对象(__对象名称, null);
__对象.添加方法("查询", q =>
{
var __条件 = HJSON.反序列化 <M查询条件>(q["条件"]);
return(HJSON.序列化(查询(__条件)));
}, E角色.工程, new List <M形参> {
new M形参("条件", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("开始时间", "string"),
new M子成员("结束时间", "string"),
new M子成员("类别", "string"),
new M子成员("页数", "int"),
new M子成员("每页数量", "int"),
}
})
});
H容器.取出 <IT服务端>().添加对象(__对象名称, () => __对象);
}
void 发布告警()
{
H容器.取出 <IB状态_S>().新增告警(new M上报告警
{
标识 = "1",
产生时间 = DateTime.Now,
来源设备类型 = "来源设备类型",
来源设备标识 = "来源设备标识",
重要性 = E重要性.次要,
类别 = "类别",
描述 = "描述",
原因 = "原因",
解决方案 = "解决方案"
});
H容器.取出 <IB状态_S>().清除告警(new M上报清除
{
标识 = "1",
来源设备类型 = "来源设备类型",
来源设备标识 = "来源设备标识",
});
}
public B基本状态()
{
//实际对象
_基本状态 = new M基本状态();
_基本状态.版本 = "1.0.0.0";
_基本状态.待处理问题.Add(new M问题 {
等级 = E重要性.普通, 内容 = "xxxx"
});
_基本状态.待处理问题.Add(new M问题 {
等级 = E重要性.重要, 内容 = "yyyy"
});
_基本状态.开启时间 = DateTime.Now;
_基本状态.连接设备.Add(new M设备连接 {
IP = IPAddress.Parse("192.168.0.1"), 标识 = "X1", 类型 = "X", 连接中 = true
});
_基本状态.连接设备.Add(new M设备连接 {
IP = IPAddress.Parse("192.168.0.2"), 标识 = "Y1", 类型 = "Y", 连接中 = true
});
_基本状态.位置 = "威尼斯";
_基本状态.业务状态 = new Dictionary <string, string> {
{ "参数1", "参数1值" }, { "参数2", "参数2值" }
};
//可通信对象
var __对象 = new M对象("基本状态", "");
__对象.添加属性("版本", () => _基本状态.版本, E角色.所有, null);
__对象.添加属性("位置", () => _基本状态.位置, E角色.所有, null);
__对象.添加属性("开启时间", () => _基本状态.开启时间.ToString(), E角色.所有, null);
__对象.添加属性("待处理问题", () => HJSON.序列化(_基本状态.待处理问题), E角色.所有, null);
__对象.添加属性("连接设备", () => HJSON.序列化(_基本状态.连接设备), E角色.所有, null);
__对象.添加属性("业务状态", () => HJSON.序列化(_基本状态.业务状态), E角色.所有, null);
__对象.添加方法("重启", 参数列表 => { 重启(); return(string.Empty); }, E角色.所有, null, null);
__对象.添加事件("发生了重要变化", E角色.所有, null);
var __IT服务端 = H容器.取出 <IT服务端>();
__IT服务端.添加对象("基本状态", () => __对象);
}
public void 多接口注入()
{
H容器.注入 <IA, BA4>(true, false);
IA __IA = H容器.取出 <IA>();
__IA.E1 += Console.WriteLine;
Console.WriteLine(__IA.P1);
__IA.P1 = 1;
Console.WriteLine(__IA.P1);
__IA.M1();
__IA.M2(1, "A");
string __arg1;
string __arg2 = "2";
Console.WriteLine(__IA.M3(new DTO {
P1 = 2, P2 = "S"
}, out __arg1, ref __arg2));
__IA.OnE1(new DTO {
P1 = 3, P2 = "SS"
});
var __result = ((IC)__IA).M4();
Console.WriteLine(__result);
}
public void 关闭()
{
HB日志.记录("系统", "关闭");
H容器.取出 <IB插件>().关闭();
_IT服务端.关闭();
}
static void Main()
{
H调试.初始化();
H日志输出.设置(__日志 => H调试.记录(__日志.概要, __日志.等级, __日志.详细, __日志.方法, __日志.文件, __日志.行号), TraceEventType.Warning);
var __服务端列表 = new List <IT服务端>();
var __随机数 = new Random();
for (int __端口 = 8001; __端口 <= 8001; __端口++)
{
#region 初始化环境
IT服务端 __IT服务端 = FT通用访问工厂.创建服务端();
__IT服务端.端口 = __端口;
__服务端列表.Add(__IT服务端);
#endregion
#region 配置通用命令
var __标识 = __端口.ToString();
H容器.注入 <IB名片_S, B名片_S>(true, true, __标识, __IT服务端);
H容器.注入 <IB系统_S, B系统_S>(true, true, __标识, __IT服务端);
H容器.注入 <IB状态_S, B状态_S>(true, true, __标识, __IT服务端);
H容器.注入 <IBFTP_S, BFTP_S>(true, true, __标识, __IT服务端);
H容器.取出 <IB名片_S>(__标识).初始化(
new M名片 {
称 = "设备1", 描述 = "描述1", 版本号 = "1.0.0.0", 版本时间 = DateTime.Now.ToString()
},
new List <M参数> {
new M参数("IP列表", "192.168.1.1,202.195.114.1"), new M参数("系统", "Windows 7")
});
H容器.取出 <IB状态_S>(__标识).初始化(null, DateTime.Now);
H容器.取出 <IBFTP_S>(__标识);
H容器.取出 <IB系统_S>(__标识).初始化(() =>
{
Console.WriteLine("重启");
}, () =>
{
Console.WriteLine("关闭");
}, () =>
{
Console.WriteLine("查询版本记录");
return(new List <M版本记录>
{
new M版本记录 {
版本号 = "1.0.0.0", 修改记录 = "xxx", 标签 = new List <string> {
"a", "b"
}
},
new M版本记录 {
版本号 = "1.0.1.0", 修改记录 = "yyy", 标签 = new List <string> {
"a1", "b1"
}
},
});
});
#endregion
#region 交互
//H容器.取出<IBFTP_S>(__标识).开启();
H容器.取出 <IB状态_S>(__标识).设置属性("类别1", "属性1", () => new M业务概要 {
类别 = "类别1", 属性 = "属性1", 当前值 = "1", 正常 = true
});
H容器.取出 <IB状态_S>(__标识).设置属性("类别1", "属性2", () => new M业务概要 {
类别 = "类别1", 属性 = "属性2", 当前值 = "1", 正常 = false
});
Task.Factory.StartNew(() =>
{
for (int i = 0; i < 100; i++)
{
if (i % 8 < 4)
{
H容器.取出 <IB状态_S>(__标识).新增告警(new M上报告警
{
标识 = i.ToString(),
产生时间 = DateTime.Now,
来源设备类型 = "来源设备类型",
来源设备标识 = "来源设备标识",
重要性 = (通用命令.状态.E重要性)(i % 4),
类别 = "类别",
描述 = "描述",
原因 = "原因",
解决方案 = "解决方案"
});
}
else
{
H容器.取出 <IB状态_S>(__标识).清除告警(new M上报清除
{
标识 = (i / 8 * 8 + (8 - i % 8)).ToString(),
来源设备类型 = "来源设备类型",
来源设备标识 = "来源设备标识",
});
}
Thread.Sleep(1000 * __随机数.Next(3, 3));
}
});
#endregion
//break;
}
__服务端列表.ForEach(q => q.开启());
Console.WriteLine("启动完毕, 按回车键关闭");
Console.ReadLine();
Console.WriteLine("关闭中");
__服务端列表.ForEach(q => q.关闭());
Console.WriteLine("按回车键退出");
Console.ReadLine();
}
private static void 参考(string __标识, IT服务端 __IT服务端)
{
H容器.注入 <IB链路_S, B链路_S>(true, true, __标识, __IT服务端);
H容器.注入 <IB日志_S, B日志_S>(true, true, __标识, __IT服务端);
H容器.注入 <IB点名_S, B点名_S>(true, true, __标识, __IT服务端);
H容器.取出 <IB点名_S>(__标识).初始化();
H容器.取出 <IB链路_S>(__标识);
H容器.取出 <IB状态_S>(__标识).健康状态变化 += q => H容器.取出 <IB点名_S>().发布事件(E事件.健康状态变化);
H容器.取出 <IB点名_S>(__标识).发布事件(E事件.启动完成);
H日志.输出通知 += (__标题, __内容, __等级, __线程) =>
{
var __重要性 = 通用命令.日志.E重要性.一般;
switch (__等级)
{
case TraceEventType.Critical:
case TraceEventType.Error:
__重要性 = 通用命令.日志.E重要性.紧急;
break;
case TraceEventType.Warning:
__重要性 = 通用命令.日志.E重要性.紧急;
break;
case TraceEventType.Information:
__重要性 = 通用命令.日志.E重要性.次要;
break;
}
H容器.取出 <IB日志_S>(__标识).新增开发日志(new 通用命令.日志.M上报开发日志
{
标题 = __标题,
时间 = DateTime.Now,
内容 = __内容,
线程 = __线程,
重要性 = __重要性
});
};
Task.Factory.StartNew(() =>
{
for (int i = 0; i < 100; i++)
{
H容器.取出 <IB日志_S>(__标识).新增工程日志(new 通用命令.日志.M上报工程日志
{
边界类型 = "对端设备类型" + i,
边界标识 = "对端设备名称" + i,
方向 = "输入",
描述 = "描述" + i,
时间 = DateTime.Now,
业务标签 = new List <string> {
"标签" + i, "标签" + (i + 1), "标签" + (i + 1)
},
业务标识 = "业务标识" + i,
业务类型 = "业务类型" + i,
重要性 = (通用命令.日志.E重要性)(i % 4)
});
if (i % 2 == 0)
{
H容器.取出 <IB链路_S>(__标识)
.建立(new M链路
{
IP = IPAddress.Parse("192.168.1.1"),
端口号 = 11,
建立连接时间 = DateTime.Now,
设备标识 = "设备标识1",
设备类型 = "设备类型1"
});
H容器.取出 <IB链路_S>(__标识)
.建立(new M链路
{
IP = IPAddress.Parse("192.168.1.2"),
端口号 = 12,
建立连接时间 = DateTime.Now,
设备标识 = "设备标识2",
设备类型 = "设备类型2",
账号 = "k"
});
}
else
{
H容器.取出 <IB链路_S>(__标识).断开(new IPEndPoint(IPAddress.Parse("192.168.1.1"), 11));
}
Thread.Sleep(3000);
}
});
}
