M对象 创建对象(IT服务端 __IT服务端, BFTP __FTP, string __对象名称 = "FTP", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("运行中", () => __FTP.运行中.ToString(), E角色.客户, null);
__对象.添加属性("端口号", () => __FTP.端口号.ToString(), E角色.客户, null);
__对象.添加属性("目录", () => __FTP.目录, E角色.客户, null);
__对象.添加属性("编码", () => "GB2312", E角色.客户, null);
__对象.添加方法("开启", __实参列表 =>
{
var __目录 = __实参列表["目录"];
var __端口号 = int.Parse(__实参列表["端口号"]);
__FTP.开启(__目录, __端口号);
return("");
}, E角色.客户, new List <M形参>
{
new M形参("目录", "string"),
new M形参("端口号", "int"),
}, null);
__对象.添加方法("关闭", __实参列表 =>
{
__FTP.关闭();
return("");
}, E角色.客户, null, null);
__对象.添加事件("开关变化", E角色.客户, new List <M形参> {
new M形参("开", "bool")
});
__FTP.状态变化 += __参数 => __IT服务端.触发事件(__对象名称, "开关变化", new Dictionary <string, string> {
{ "开", __参数.ToString() }
});
return(__对象);
}
M对象 创建对象(IT服务端 __IT服务端, B资源监控 __监控, string __对象名称 = "资源监控", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("配置", () => HJSON.序列化(__监控.配置), E角色.客户, null);
__对象.添加属性("总内存", () => string.Format("{0} GB", __监控.总内存 / 1024), E角色.客户, null);
__对象.添加方法("设置配置", __实参列表 =>
{
var __配置 = HJSON.反序列化 <M资源监控配置>(__实参列表["配置"]);
__监控.配置 = __配置;
File.WriteAllText(H路径.获取绝对路径("资源监控配置.txt"), HJSON.序列化(__配置), Encoding.UTF8);
return("");
}, E角色.客户, null, null);
__对象.添加方法("查询状态", __实参列表 =>
{
return(HJSON.序列化(__监控.查询状态()));
}, E角色.客户, null, null);
__对象.添加事件("告警", E角色.客户, new List <M形参> {
new M形参("描述", "string")
});
__监控.阈值告警 += __描述 =>
{
H业务日志.记录("进程", __描述);
__IT服务端.触发事件(__对象名称, "告警", new Dictionary <string, string> {
{ "描述", __描述 }
});
};
return(__对象);
}
public BFTP_S(IT服务端 __IT服务端)
{
端口号 = 2121;
_IT服务端 = __IT服务端;
支持 = true;
配置通用访问();
}
M对象 创建对象(IT服务端 __IT服务端, string __对象名称 = "业务日志", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("缓存上限", () => H业务日志.缓存上限.ToString(), E角色.客户, null);
__对象.添加方法("查询缓存", __实参列表 =>
{
//return HJSON.AES压缩(HJSON.序列化(H业务日志.查询缓存()));
return(HJSON.序列化(H业务日志.查询缓存()));
}, E角色.客户, null, null);
return(__对象);
}
M对象 创建对象(IT服务端 __IT服务端, B链路监控 __Ping, string __对象名称 = "链路监控", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("配置", () => HJSON.序列化(__Ping.配置), E角色.客户, null);
__对象.添加方法("查询状态", __实参列表 =>
{
return(HJSON.序列化(__Ping.查询状态()));
}, E角色.客户, null, null);
__对象.添加方法("修改配置", __实参列表 =>
{
var __配置 = HJSON.反序列化 <M链路监控配置>(__实参列表["配置"]);
__Ping.修改配置(__配置);
File.WriteAllText(H路径.获取绝对路径("链路监控配置.txt"), HJSON.序列化(__Ping.配置), Encoding.UTF8);
return("");
}, E角色.客户, new List <M形参>
{
new M形参("配置", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M子成员("超时", new M元数据 {
类型 = "int", 描述 = "毫秒", 默认值 = "1000"
}),
new M子成员("频率", new M元数据 {
类型 = "int", 描述 = "毫秒/次", 默认值 = "1000"
}),
new M子成员("阈值", new M元数据 {
类型 = "int", 描述 = "1-10, 通过10次中成功的次数表示当前通断", 默认值 = "7"
}),
new M子成员("IP列表", new M元数据 {
类型 = "string", 描述 = "ip或域名", 结构 = E数据结构.单值数组
}),
}
}),
}, null);
__对象.添加事件("连接变化", E角色.客户, new List <M形参> {
new M形参("地址", "string"), new M形参("旧", "bool"), new M形参("新", "bool")
});
__Ping.连接变化 += (__地址, __旧, __新) =>
{
H业务日志.记录("链路", string.Format("{0} {1}", __地址, __新 == true ? "通" : "断"));
__IT服务端.触发事件(__对象名称, "连接变化", new Dictionary <string, string> {
{ "地址", __地址 }, { "旧", __旧.ToString() }, { "新", __新.ToString() }
});
};
return(__对象);
}
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日志>().初始化();
}
M对象 创建对象(IT服务端 __IT服务端, B进程管理 __进程管理, string __对象名称 = "进程管理", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加方法("查询所有", 实参列表 =>
{
return(HJSON.序列化(__进程管理.查询所有().Select(q => new { q.Id, q.称, q.内存, q.路径, q.CPU })));
}, E角色.客户);
__对象.添加方法("结束进程", 实参列表 =>
{
var __id = 实参列表["Id"];
__进程管理.结束进程(int.Parse(__id));
return("");
}, E角色.客户);
return(__对象);
}
public void 配置()
{
INET.H日志输出.设置(q => Console.WriteLine(string.Format("{0}\t{1}\t{2}\n{3}\t{4}({5})\n{6}", q.等级, q.概要, q.详细, q.文件, q.方法, q.行号, q.异常)));
_IT服务端 = FT通用访问工厂.创建服务端();
var __命令行 = new B命令行();
var __命令行对象 = 创建对象(_IT服务端, __命令行);
_IT服务端.添加对象("命令行", () => __命令行对象);
var __进程管理 = new B进程管理();
var __进程管理对象 = 创建对象(_IT服务端, __进程管理);
_IT服务端.添加对象("进程管理", () => __进程管理对象);
var __FTP = new BFTP();
var __FTP对象 = 创建对象(_IT服务端, __FTP);
_IT服务端.添加对象("FTP", () => __FTP对象);
var __链路监控配置 = HJSON.反序列化 <M链路监控配置>(File.ReadAllText(H路径.获取绝对路径("链路监控配置.txt"), Encoding.UTF8));
var __链路监控 = new B链路监控(__链路监控配置);
var __链路监控对象 = 创建对象(_IT服务端, __链路监控);
_IT服务端.添加对象("链路监控", () => __链路监控对象);
var __进程监控配置 = HJSON.反序列化 <M进程监控配置>(File.ReadAllText(H路径.获取绝对路径("进程监控配置.txt"), Encoding.UTF8));
var __进程监控 = new B进程监控(__进程监控配置);
var __进程监控对象 = 创建对象(_IT服务端, __进程监控);
_IT服务端.添加对象("进程监控", () => __进程监控对象);
var __资源监控配置 = HJSON.反序列化 <M资源监控配置>(File.ReadAllText(H路径.获取绝对路径("资源监控配置.txt"), Encoding.UTF8));
var __资源监控 = new B资源监控(__资源监控配置);
var __资源监控对象 = 创建对象(_IT服务端, __资源监控);
_IT服务端.添加对象("资源监控", () => __资源监控对象);
var __业务日志对象 = 创建对象(_IT服务端);
_IT服务端.添加对象("业务日志", () => __业务日志对象);
}
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"}},
});
}
public B系统_S(IT服务端 __IT服务端)
{
_IT服务端 = __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);
}
});
}
public B日志_S(IT服务端 __IT服务端)
{
_IT服务端 = __IT服务端;
配置通用访问();
_IT服务端.客户端已断开 += _IT服务端_客户端已断开;
}
M对象 创建对象(IT服务端 __IT服务端, B命令行 __命令行, string __对象名称 = "命令行", string __分类 = "")
{
Func <IPEndPoint, string, string> __合并 = (__地址, __标识) => string.Format("{0}:{1}:{2}", __地址.Address, __地址.Port, __标识);
Func <string, Tuple <IPEndPoint, string> > __解析 = __合成标识 =>
{
var __数组 = __合成标识.Split(':');
var __地址 = new IPEndPoint(IPAddress.Parse(__数组[0]), int.Parse(__数组[1]));
var __标识 = __数组[2];
return(new Tuple <IPEndPoint, string>(__地址, __标识));
};
var __对象 = new M对象(__对象名称, __分类);
__对象.添加属性("IsWindows", () => __命令行.IsWindows.ToString(), E角色.客户);
__对象.添加方法("创建进程", (__实参列表, __地址) =>
{
var __进程标识 = __合并(__地址, __实参列表["进程标识"]);
__命令行.创建进程(__进程标识);
return("");
}, E角色.客户, new List <M形参>
{
new M形参("进程标识", "string"),
});
__对象.添加方法("结束进程", (__实参列表, __地址) =>
{
var __进程标识 = __合并(__地址, __实参列表["进程标识"]);
__命令行.结束进程(__进程标识);
return("");
}, E角色.客户, new List <M形参>
{
new M形参("进程标识", "string"),
});
__对象.添加方法("执行", (__实参列表, __地址) =>
{
var __进程标识 = __合并(__地址, __实参列表["进程标识"]);
var __命令行列表 = HJSON.反序列化 <List <string> >(__实参列表["命令行列表"]);
__命令行.执行(__进程标识, __命令行列表);
return("");
}, E角色.客户, new List <M形参>
{
new M形参("进程标识", "string"),
new M形参("命令行列表", "string", E数据结构.单值数组),
});
__对象.添加事件("正常输出", E角色.客户, new List <M形参> {
new M形参("参数", new M元数据 {
类型 = "M输出", 结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M子成员("进程标识", "string"),
new M子成员("内容", "string")
}
}),
});
__对象.添加事件("异常输出", E角色.客户, new List <M形参> {
new M形参("参数", new M元数据 {
类型 = "M输出", 结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M子成员("进程标识", "string"),
new M子成员("内容", "string")
}
}),
});
__对象.添加事件("执行结束", E角色.客户, new List <M形参> {
new M形参("参数", new M元数据 {
类型 = "M输出", 结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M子成员("进程标识", "string"),
new M子成员("内容", "string")
}
}),
});
__命令行.正常输出 += __参数 =>
{
var __分解 = __解析(__参数.进程标识);
var __地址 = __分解.Item1;
__参数.进程标识 = __分解.Item2;
__参数.内容 = __参数.内容 == null ? null : __参数.内容.Replace("{", "").Replace("}", "").Replace("[", "").Replace("]", "");
__IT服务端.触发事件(__对象名称, "正常输出", new Dictionary <string, string> {
{ "参数", HJSON.序列化(__参数) }
}, new List <IPEndPoint> {
__地址
});
};
__命令行.异常输出 += __参数 =>
{
var __分解 = __解析(__参数.进程标识);
var __地址 = __分解.Item1;
__参数.进程标识 = __分解.Item2;
__参数.内容 = __参数.内容 == null ? null : __参数.内容.Replace("{", "").Replace("}", "").Replace("[", "").Replace("]", "");
__IT服务端.触发事件(__对象名称, "异常输出", new Dictionary <string, string> {
{ "参数", HJSON.序列化(__参数) }
}, new List <IPEndPoint> {
__地址
});
};
__命令行.执行结束 += __参数 =>
{
var __分解 = __解析(__参数.进程标识);
var __地址 = __分解.Item1;
__参数.进程标识 = __分解.Item2;
__参数.内容 = __参数.内容 == null ? null : __参数.内容.Replace("{", "").Replace("}", "").Replace("[", "").Replace("]", "");
__IT服务端.触发事件(__对象名称, "执行结束", new Dictionary <string, string> {
{ "参数", HJSON.序列化(__参数) }
}, new List <IPEndPoint> {
__地址
});
};
return(__对象);
}
M对象 创建对象(IT服务端 __IT服务端, B进程监控 __监控, string __对象名称 = "进程监控", string __分类 = "")
{
var __对象 = new M对象(__对象名称, __分类);
__对象.添加方法("查询状态", __实参列表 =>
{
return(HJSON.序列化(__监控.查询状态()));
}, E角色.客户, null);
__对象.添加方法("查询配置", __实参列表 =>
{
return(HJSON.序列化(__监控.查询配置()));
}, E角色.客户, null);
__对象.添加方法("设置配置", __实参列表 =>
{
var __配置 = HJSON.反序列化 <M进程监控配置>(__实参列表["配置"]);
__监控.设置配置(__配置);
File.WriteAllText(H路径.获取绝对路径("进程监控配置.txt"), HJSON.序列化(__配置), Encoding.UTF8);
return("");
}, E角色.客户, new List <M形参>
{
new M形参("配置", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M形参("频率", ""),
new M形参("列表", new M元数据 {
结构 = E数据结构.对象数组, 子成员列表 = new List <M子成员> {
new M子成员("进程名", "string"),
new M子成员("CPU阈值", new M元数据 {
类型 = "int?", 描述 = "可为空,1-100", 默认值 = "90"
}),
new M子成员("内存阈值", new M元数据 {
类型 = "int?", 描述 = "可为空,单位MB", 默认值 = "2000"
}),
new M子成员("阈值次数", new M元数据 {
类型 = "int?", 默认值 = "可为空,5"
}),
}
})
}
}),
}, null);
__对象.添加事件("告警", E角色.客户, new List <M形参> {
new M形参("描述", "string")
});
__监控.进程开启 += (qid, __进程名, __时间) =>
{
var __描述 = string.Format("进程{1}（{0}）开启, {2}", qid, __进程名, __时间.ToString());
H业务日志.记录("进程", __描述);
__IT服务端.触发事件(__对象名称, "告警", new Dictionary <string, string> {
{ "描述", __描述 }
});
};
__监控.进程关闭 += (qid, __进程名) =>
{
var __描述 = string.Format("进程{1}（{0}）关闭", qid, __进程名);
H业务日志.记录("进程", __描述);
__IT服务端.触发事件(__对象名称, "告警", new Dictionary <string, string> {
{ "描述", __描述 }
});
};
__监控.阈值告警 += __描述 =>
{
H业务日志.记录("进程", __描述);
__IT服务端.触发事件(__对象名称, "告警", new Dictionary <string, string> {
{ "描述", __描述 }
});
};
return(__对象);
}
