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(__对象);
}
private M对象 创建工程通用访问对象()
{
var __对象 = new M对象("对象1", "业务1");
__对象.添加属性("号码方案", () => _号码方案, E角色.工程, new M元数据 {
类型 = "string", 结构 = E数据结构.单值, 默认值 = "标准", 范围 = "浙江/标准"
});
__对象.添加属性("网速", () => _网速.ToString(), E角色.工程, new M元数据 {
类型 = "int", 结构 = E数据结构.单值
});
__对象.添加属性("资源消耗", () => _资源消耗.ToString(), E角色.工程, new M元数据 {
类型 = "int", 结构 = E数据结构.单值, 范围 = "0-10000"
});
__对象.添加方法("设置网速", __参数列表 => { _网速 = int.Parse(__参数列表["网速"]); return(string.Empty); }, E角色.工程, new List <M形参>
{
new M形参("网速", new M元数据 {
类型 = "int", 结构 = E数据结构.单值, 描述 = "测试3次以上取平均值", 默认值 = "2000"
}),
});
__对象.添加方法("设置号码方案", __参数列表 => { _号码方案 = __参数列表["号码方案"]; return(string.Empty); }, E角色.工程, new List <M形参>
{
new M形参("号码方案", new M元数据 {
类型 = "string", 结构 = E数据结构.单值, 默认值 = "标准", 范围 = "浙江/标准"
}),
}, null);
return(__对象);
}
public M对象 创建对象(string __名称 = "测试", string __分类 = "")
{
var __对象 = new M对象(__名称, __分类);
__对象.添加属性("点结构属性1", () => "HELLO 你好!!!!!!!!");
__对象.添加属性("点结构属性2", () => "1");
__对象.添加属性("列结构属性", () => HJSON.序列化(new List <int> {
1, 2, 3
}), E角色.开发, new M元数据 {
类型 = "int", 结构 = E数据结构.单值数组, 默认值 = "[1,2,3]", 范围 = "1-10",
});
__对象.添加属性("行结构属性", () => HJSON.序列化(new Mdemo {
点属性 = 111, 行属性 = new Mdemo1 {
点属性1 = 1211, 点属性2 = "1221"
}
}));
__对象.添加属性("表结构属性", () => HJSON.序列化(new List <Mdemo>
{
new Mdemo {
点属性 = 111, 行属性 = new Mdemo1 {
点属性1 = 1211, 点属性2 = "1221"
}
},
new Mdemo {
点属性 = 112, 行属性 = new Mdemo1 {
点属性1 = 1212, 点属性2 = "1222"
}
},
}));
__对象.添加方法("使用单值", 实参列表 => 执行方法("使用单值", 实参列表), E角色.开发, new List <M形参>
{
new M形参("参数1", "int"),
new M形参("参数2", "string"),
}, new M元数据 {
类型 = "string", 描述 = "描述xxx", 结构 = E数据结构.单值, 范围 = "范围xxx"
});
__对象.添加方法("使用对象", 实参列表 => 执行方法("使用对象", 实参列表), E角色.开发, new List <M形参>
{
new M形参("参数1", 获取行元数据()),
}, 获取行元数据());
__对象.添加方法("使用单值数组", 实参列表 => 执行方法("使用单值数组", 实参列表), E角色.开发, new List <M形参>
{
new M形参("参数1", "int", E数据结构.单值数组),
new M形参("参数2", "string"),
}, new M元数据 {
类型 = "int", 描述 = "描述xxx", 结构 = E数据结构.单值数组, 范围 = "范围xxx"
});
__对象.添加方法("使用对象数组", 实参列表 => 执行方法("使用对象数组", 实参列表), E角色.开发, new List <M形参>
{
new M形参("参数1", 获取表元数据()),
}, 获取表元数据());
//__对象.添加方法("使用单值2", "参数1:int.参数2:string", "string", 实参列表 => 执行方法("使用单值", 实参列表), E角色.开发);
//__对象.添加方法("使用对象数组2",
// "参数1:,对象数组(参数1:int;参数2:string),描述.参数2:MXXX,对象(参数1:int,单值数组,xxx;参数2:string,,事大法师的).参数3:int,单值数组",
// "",
// 实参列表 => 执行方法("使用对象数组", 实参列表), E角色.开发);
__对象.添加方法("返回字符串表格", 实参列表 => 执行方法("返回字符串表格", 实参列表));
__对象.添加方法("返回字符串表格2", 实参列表 => 执行方法("返回字符串表格2", 实参列表));
return(__对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加方法("重启", q =>
{
if (重启 != null)
{
重启();
return("");
}
throw new ApplicationException("该功能不支持");
}, E角色.客户);
_对象.添加方法("关闭", q =>
{
if (关闭 != null)
{
关闭();
return("");
}
throw new ApplicationException("该功能不支持");
}, E角色.客户);
_对象.添加方法("查询版本记录", q =>
{
if (查询版本记录 != null)
{
return(HJSON.序列化(查询版本记录()));
}
throw new ApplicationException("该功能不支持");
}, E角色.客户);
_IT服务端.添加对象(_对象名称, () => _对象);
}
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(__对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("名称", () => 片.称, E角色.客户);
_对象.添加属性("描述", () => 片.描述, E角色.客户);
_对象.添加属性("版本号", () => 片.版本号, E角色.客户);
_对象.添加属性("版本时间", () => 片.版本时间, E角色.客户);
_对象.添加方法("查询", __实参列表 => HJSON.序列化(片), E角色.客户, null, null);
_对象.添加方法("查询参数", __实参列表 => HJSON.序列化(参数列表), E角色.客户, null, null);
_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服务端.添加对象(__对象名称, () => __对象);
}
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(__对象);
}
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(__对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("已连接设备", () => HJSON.序列化(_登录缓存.Values.ToList()), E角色.客户, null);
_对象.添加事件("已建立连接", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//IP, 端口号, 设备类型, 设备标识, 账号, 成功, 描述
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("IP", "string"),
new M子成员("端口号", "int"),
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
}
}
}
});
_对象.添加事件("已断开连接", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//IP, 端口号, 设备类型, 设备标识, 账号, 成功, 描述
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("IP", "string"),
new M子成员("端口号", "int"),
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
}
}
}
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
private void 配置通用访问(string __对象名称)
{
var __对象 = new M对象(__对象名称, null);
__对象.添加属性("启用", () => _MGPS过滤.启用.ToString(), E角色.工程);
__对象.添加属性("省", () => _MGPS过滤.省, E角色.工程);
__对象.添加属性("市", () => _MGPS过滤.市, E角色.工程);
__对象.添加方法("设置", q =>
{
_MGPS过滤.启用 = bool.Parse(q["启用"]);
_MGPS过滤.省 = q["省"];
_MGPS过滤.市 = q["市"];
H程序配置.设置("GPS过滤", HJSON.序列化(_MGPS过滤, false).Replace('"', '\''));
设置区域(_MGPS过滤.省, _MGPS过滤.市);
return(null);
}, E角色.工程, new List <M形参> {
new M形参("启用", "bool"), new M形参("省", "string"), new M形参("市", "string")
});
_IT服务端.添加对象(__对象名称, () => __对象);
}
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服务端>().添加对象(__对象名称, () => __对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("支持", () => 支持.ToString(), E角色.客户, null);
_对象.添加属性("运行中", () => 运行中.ToString(), E角色.客户, null);
_对象.添加属性("端口号", () => 端口号.ToString(), E角色.客户, null);
_对象.添加属性("目录路径", () => H路径.序目录, E角色.客户, null);
_对象.添加属性("编码", () => "GB2312", E角色.客户, null);
_对象.添加方法("开启", __实参列表 =>
{
开启();
return("");
}, E角色.客户, null, null);
_对象.添加方法("关闭", __实参列表 =>
{
关闭();
return("");
}, E角色.客户, null, null);
_IT服务端.添加对象(_对象名称, () => _对象);
}
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服务端>().添加对象(__对象名称, () => __对象);
}
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服务端.添加对象("基本状态", () => __对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("已登录设备", () => HJSON.序列化(_登录缓存.Values.ToList()), E角色.客户, null);
_对象.添加方法("登录", (__实参列表, __地址) =>
{
var __条件 = HJSON.反序列化 <M登录请求>(__实参列表["请求参数"]);
登录(__条件, __地址);
return("");
}, E角色.客户, new List <M形参> {
new M形参 {
称 = "请求参数", 元数据 = new M元数据
{
//设备类型, 设备标识, 账号, 密码
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
new M子成员("密码", "string"),
}
}
}
}, null);
_对象.添加方法("查询登录", (__实参列表, __地址) =>
{
IPAddress __IP = null;
IPAddress.TryParse(__实参列表["IP"], out __IP);
int?__端口号 = null;
if (!string.IsNullOrEmpty(__实参列表["端口号"]))
{
__端口号 = int.Parse(__实参列表["端口号"]);
}
var __结果 = 查询(__IP, __端口号, __实参列表["账号"]);
return(HJSON.序列化(__结果));
}, E角色.客户, new List <M形参> {
new M形参("IP", "string"), new M形参("端口号", new M元数据("int?")
{
描述 = "可为空"
})
}, null);
_对象.添加方法("注销", (__实参列表, __地址) =>
{
注销(__地址);
return("");
}, E角色.客户, null, null);
_对象.添加事件("登录完毕", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//IP, 端口号, 设备类型, 设备标识, 账号, 成功, 描述
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("IP", "string"),
new M子成员("端口号", "int"),
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
new M子成员("成功", "string"),
new M子成员("描述", "string"),
}
}
}
});
_对象.添加事件("注销完毕", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("IP", "string"),
new M子成员("端口号", "int"),
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
}
}
}
});
_对象.添加方法("修改密码", __实参列表 =>
{
var __旧密码 = __实参列表["旧密码"];
var __新密码 = __实参列表["新密码"];
修改密码(__旧密码, __新密码);
return(null);
}, E角色.客户, new List <M形参> {
new M形参("旧密码", "string"), new M形参("新密码", "string")
});
_对象.添加方法("增加账号", (__实参列表, __地址) =>
{
var __当前账号 = 查询账号(__地址);
if (__当前账号 == null || __当前账号.账号 != "admin")
{
throw new ApplicationException("无权限");
}
var __账号 = __实参列表["账号"];
var __密码 = __实参列表["密码"];
var __备注 = __实参列表["备注"];
增加账号(__账号, __密码, __备注);
return(null);
}, E角色.客户, new List <M形参> {
new M形参("账号", "string"), new M形参("密码", "string"), new M形参("备注", "string")
});
_对象.添加方法("删除账号", (__实参列表, __地址) =>
{
var __当前账号 = 查询账号(__地址);
if (__当前账号 == null || __当前账号.账号 != "admin")
{
throw new ApplicationException("无权限");
}
var __账号 = __实参列表["账号"];
除账号(__账号);
return(null);
}, E角色.客户, new List <M形参> {
new M形参("账号", "string")
});
_对象.添加方法("修改账号", (__实参列表, __地址) =>
{
var __当前账号 = 查询账号(__地址);
if (__当前账号 == null || __当前账号.账号 != "admin")
{
throw new ApplicationException("无权限");
}
var __账号 = __实参列表["账号"];
var __备注 = __实参列表["备注"];
修改账号(__账号, __备注);
return(null);
}, E角色.客户, new List <M形参> {
new M形参("账号", "string"), new M形参("备注", "string")
});
_对象.添加方法("查询账号", (__实参列表, __地址) =>
{
var __当前账号 = 查询账号(__地址);
if (__当前账号 == null || __当前账号.账号 != "admin")
{
throw new ApplicationException("无权限");
}
var __账号 = __实参列表["账号"];
var __备注 = __实参列表["备注"];
return(HJSON.序列化(查询账号(__账号, __备注)));
}, E角色.客户, new List <M形参> {
new M形参("账号", "string"), new M形参("备注", "string")
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
private void 配置通用访问(string __对象名称)
{
var __对象 = new M对象(__对象名称, null);
__对象.添加方法("查询轨迹", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M轨迹查询条件>(__实参列表["条件"]);
var __字符串 = HJSON.序列化(查询轨迹(__条件));
//return __字符串;
return(H序列化.AES压缩(__字符串));
}, 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"),
}
})
});
__对象.添加方法("查询最后位置", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M最后位置查询条件>(__实参列表["条件"]);
var __字符串 = HJSON.序列化(查询最后位置(__条件));
return(H序列化.AES压缩(__字符串));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("号码列表", "string", E数据结构.单值数组),
new M子成员("页数", "int?"),
new M子成员("每页数量", "int?"),
}
})
});
__对象.添加方法("查询活跃号码", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M活跃号码查询条件>(__实参列表["条件"]);
return(HJSON.序列化(查询活跃号码(__条件)));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("开始时间", "string"),
new M子成员("结束时间", "string"),
new M子成员("号码列表", "string", E数据结构.单值数组),
}
})
}, new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M子成员("总数", "string"), new M子成员("号码列表", "string", E数据结构.单值数组),
}
});
__对象.添加方法("统计活跃号码", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M活跃号码查询条件>(__实参列表["条件"]);
return(HJSON.序列化(统计活跃号码(__条件)));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("开始时间", "string"),
new M子成员("结束时间", "string"),
new M子成员("号码列表", "string", E数据结构.单值数组),
}
})
}, new M元数据("int"));
__对象.添加方法("统计频率", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M频率统计条件>(__实参列表["条件"]);
return(HJSON.序列化(统计频率(__条件)));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.单值, 子成员列表 = new List <M子成员>
{
new M子成员("开始时间", "string"),
new M子成员("结束时间", "string"),
new M子成员("号码列表", "string", E数据结构.单值数组),
}
})
}, new M元数据("float")
{
描述 = "(秒/次)"
});
_IT服务端.添加对象(__对象名称, () => __对象);
}
private void 配置通用访问(string __对象名称)
{
var __对象 = new M对象(__对象名称, null);
__对象.添加属性("号码总数", () => 订阅号码总数.ToString(), E角色.客户);
__对象.添加属性("客户端总数", () => _客户端订阅缓存.Count.ToString(), E角色.客户);
__对象.添加方法("增加", (__实参列表, __地址) =>
{
var __号码列表 = HJSON.反序列化 <List <string> >(__实参列表["号码列表"]);
_任务.执行(() => 增加(__号码列表, __地址));
return(null);
}, E角色.客户, new List <M形参> {
new M形参("号码列表", "string", E数据结构.单值数组)
});
__对象.添加方法("删除", (__实参列表, __地址) =>
{
var __号码列表 = HJSON.反序列化 <List <string> >(__实参列表["号码列表"]);
_任务.执行(() => 除(__号码列表, __地址));
return(null);
}, E角色.客户, new List <M形参> {
new M形参("号码列表", "string", E数据结构.单值数组)
});
__对象.添加方法("查询客户端概要", q => HJSON.序列化(查询客户端概要(), new IPAddressConverter()), E角色.客户);
__对象.添加方法("查询客户端明细", q =>
{
var __IP = IPAddress.Parse(q["IP"]);
int __端口号 = int.Parse(q["端口号"]);
return(HJSON.序列化(查询客户端(__IP, __端口号)));
}, E角色.客户, new List <M形参> {
new M形参("IP", new M元数据("string")
{
描述 = "可选"
}),
new M形参("端口号", new M元数据("int")
{
描述 = "可选"
}),
});
__对象.添加方法("查询所有号码", q => HJSON.序列化(所有号码), E角色.客户);
__对象.添加方法("查询号码", q =>
{
var __号码 = q["号码"];
return(HJSON.序列化(查询号码(__号码), new IPEndPointConverter()));
}, E角色.客户, new List <M形参> {
new M形参("号码", "string"),
});
__对象.添加事件("GPS上报", E角色.客户, new List <M形参> {
new M形参("号码", "string"),
new M形参("GPS", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("经度", "double"),
new M子成员("纬度", "double"),
new M子成员("时间", "string"),
new M子成员("速度", "int?"),
new M子成员("高度", "int?"),
new M子成员("方向", "int?"),
new M子成员("精度", "int?"),
}
}),
});
__对象.添加事件("状态上报", E角色.客户, new List <M形参> {
new M形参("号码", "string"),
new M形参("状态", "string"),
});
_IT服务端.添加对象(__对象名称, () => __对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("支持发送点名", () => 支持发送点名.ToString(), E角色.客户, null);
_对象.添加属性("支持点名响应", () => 支持点名响应.ToString(), E角色.客户, null);
_对象.添加属性("点名请求地址", () => _请求地址.ToString(), E角色.客户, null);
_对象.添加属性("事件上报地址", () => _响应地址.ToString(), E角色.客户, null);
_对象.添加方法("点名", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M点名条件>(__实参列表["点名条件"]);
点名(__条件);
return("");
}, E角色.客户, new List <M形参> {
new M形参 {
称 = "点名条件", 元数据 = new M元数据
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("参数列表", new M元数据 {
结构 = E数据结构.对象数组, 子成员列表 = new List <M子成员>
{
new M子成员("名称", "string"),
new M子成员("值", "int"),
}
}),
new M子成员("状态概要", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("健康状态", "string"),
new M子成员("未清除告警数量", "int"),
new M子成员("启动时间", "string"),
new M子成员("状态开始时间", "string"),
}
}),
}
}
}
}, null);
_对象.添加事件("设备事件上报", E角色.客户, new List <M形参> {
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("地址", "string"),
new M子成员("类型", "string"),
new M子成员("参数", new M元数据
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("参数列表", new M元数据 {
结构 = E数据结构.对象数组, 子成员列表 = new List <M子成员>
{
new M子成员("名称", "string"),
new M子成员("值", "int"),
}
}),
new M子成员("状态概要", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("健康状态", "string"),
new M子成员("未清除告警数量", "int"),
new M子成员("启动时间", "string"),
new M子成员("状态开始时间", "string"),
}
}),
}
}),
}
}
}
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
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(__对象);
}
static void 务端()
{
//创建服务器
var __服务端 = FT通用访问工厂.创建服务端();
__服务端.端口 = 8888;
__服务端.开启();
//实际对象
var __基本状态 = 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); //返回空字符串或者json格式的对象
}, E角色.所有, null, null); //最后两个参数是对参数和返回值的元数据定义
__对象.添加事件("发生了重要变化", E角色.所有, null);
//将对象加入到服务器
__服务端.添加对象("基本状态", () => __对象);
//触发服务器端事件
__服务端.触发事件("基本状态", "发生了重要变化", null, null);//最后两个参数是实参和客户端地址列表(可选)
//创建客户端
var __客户端 = FT通用访问工厂.创建客户端();
__客户端.连接(new IPEndPoint(IPAddress.Any, 8888));
var __版本 = __客户端.查询属性值("基本状态", "版本");
var __待处理问题 = HJSON.反序列化 <List <M问题> >(__客户端.查询属性值("基本状态", "待处理问题"));
__客户端.执行方法("基本状态", "重启", null); //最后一个参数是实参
__客户端.订阅事件("基本状态", "发生了重要变化", __实参 => {
//处理实参
});
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加方法("查询日志文件", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M日志文件查询条件>(__实参列表["过滤参数"]);
return(HJSON.序列化(查询日志文件列表(__条件)));
}, E角色.客户, new List <M形参>
{
new M形参
{
称 = "过滤参数",
元数据 = new M元数据
{
结构 = E数据结构.对象,
子成员列表 = new List <M子成员>
{
new M子成员("起始时间", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("结束时间", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
}
}
}
});
_对象.添加方法("删除日志文件", __实参列表 =>
{
var __条件 = HJSON.反序列化 <List <string> >(__实参列表["地址列表"]);
return(HJSON.序列化(除日志文件列表(__条件)));
}, E角色.客户, new List <M形参>
{
new M形参("地址列表", "string", E数据结构.单值数组)
});
_对象.添加方法("导出日志文件", __实参列表 =>
{
var __条件 = HJSON.反序列化 <List <string> >(__实参列表["地址列表"]);
return(HJSON.序列化(导出日志文件列表(__条件)));
}, E角色.客户, new List <M形参>
{
new M形参("地址列表", "string", E数据结构.单值数组)
});
_对象.添加方法("压缩日志文件", __实参列表 =>
{
var __条件 = HJSON.反序列化 <List <string> >(__实参列表["地址列表"]);
string __下载地址;
压缩日志文件列表(__条件, out __下载地址);
return(__下载地址);
}, E角色.客户, new List <M形参>
{
new M形参("地址列表", "string", E数据结构.单值数组)
});
_对象.添加方法("过滤工程日志", 设置工程日志过滤, E角色.客户, new List <M形参>
{
new M形参
{
称 = "过滤参数",
元数据 = new M元数据
{
结构 = E数据结构.对象,
子成员列表 = new List <M子成员>
{
new M子成员("重要性", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("方向", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("对端设备类型", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("对端设备标识", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("业务类型", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
new M子成员("业务标识", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("业务标签", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
new M子成员("关键字", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
}
}
}
});
_对象.添加方法("过滤开发日志", 设置开发日志过滤, E角色.客户, new List <M形参>
{
new M形参
{
称 = "过滤参数",
元数据 = new M元数据
{
结构 = E数据结构.对象,
子成员列表 = new List <M子成员>
{
new M子成员("重要性", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("线程", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
new M子成员("标题", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
new M子成员("内容", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
}
}
}
});
_对象.添加事件("上报工程日志", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数",
元数据 = new M元数据
{
//时间, 重要性, 方向(输入/输出), 对端设备类型, 对端设备名称, 业务类型, 业务标识, 业务标签[], 描述
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("时间", "string"),
new M子成员("重要性", "string"),
new M子成员("方向", "string"),
new M子成员("对端设备类型", "string"),
new M子成员("对端设备标识", "string"),
new M子成员("业务类型", "string"),
new M子成员("业务标识", "string"),
new M子成员("业务标签", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可选"
}),
new M子成员("描述", "string"),
}
}
}
});
_对象.添加事件("上报开发日志", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//时间, 重要性, 模块, 函数, 线程, 描述, 文件及行号
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("时间", "string"),
new M子成员("重要性", "string"),
new M子成员("线程", "string"),
new M子成员("标题", "string"),
new M子成员("内容", "string"),
}
}
}
});
//_对象.添加事件("日志压缩完毕", E角色.客户, new List<M形参>
//{
// new M形参{ 名称 = "事件参数", 元数据 = new M元数据
// {
// //时间, 重要性, 模块, 函数, 线程, 描述, 文件及行号
// 结构 = E数据结构.行, 子成员列表 = new List<M子成员>
// {
// new M子成员("成功", "bool"),
// new M子成员("描述", "string"),
// new M子成员("相对路径","string"),
// new M子成员("下载地址", "string"),
// }
// }
// }
//});
_IT服务端.添加对象(_对象名称, () => _对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("概要状态", () => HJSON.序列化(查询业务概要(null, null)), E角色.客户, null);
_对象.添加属性("启动时间", () => 启动时间.ToString(), E角色.客户, null);
_对象.添加属性("健康状态", () => 健康状态.ToString(), E角色.客户, null);
_对象.添加属性("状态开始时间", () => 状态开始时间.ToString(), E角色.客户, null);
_对象.添加属性("未清除告警数量", () => _待处理问题.Count.ToString(), E角色.客户, null);
_对象.添加方法("查询概要状态", __实参列表 =>
{
return(HJSON.序列化(查询概要状态()));
}, E角色.客户);
_对象.添加方法("查询业务概要", __实参列表 =>
{
var __类别 = __实参列表["类别"];
var __属性 = __实参列表["属性"];
return(HJSON.序列化(查询业务概要(__类别, __属性)));
}, E角色.客户, new List <M形参> {
new M形参("类别", new M元数据 {
类型 = "string", 描述 = "可为空"
}), new M形参("属性", new M元数据 {
类型 = "string", 描述 = "可为空"
})
}, null);
_对象.添加方法("查询未清除告警", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M查询条件>(__实参列表["条件"]);
return(HJSON.序列化(查询未清除告警(__条件)));
}, E角色.客户, new List <M形参> {
new M形参 {
称 = "条件", 元数据 = new M元数据
{
//每页数量, 页数, 来源设备类型(可选), 来源设备标识(可选), 类别(可选), 重要性(可选), 关键字(可选)
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("每页数量", "int"),
new M子成员("页数", "int"),
new M子成员("来源设备类型", new M元数据 {
类型 = "string", 描述 = "可选"
}),
new M子成员("来源设备标识", new M元数据 {
类型 = "string", 描述 = "可选"
}),
new M子成员("类别", new M元数据 {
类型 = "string", 描述 = "可选"
}),
new M子成员("重要性", new M元数据 {
类型 = "string", 描述 = "可选"
}),
new M子成员("关键字", new M元数据 {
类型 = "string", 描述 = "可选"
}),
}
}
}
}, null);
_对象.添加事件("上报告警", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//标识, 来源设备类型, 来源设备标识, 产生时间, 类别, 重要性, 描述, 原因, 解决方案
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("标识", "string"),
new M子成员("来源设备类型", "string"),
new M子成员("来源设备标识", "string"),
new M子成员("产生时间", "string"),
new M子成员("类别", "string"),
new M子成员("重要性", "string"),
new M子成员("描述", "string"),
new M子成员("原因", "string"),
new M子成员("解决方案", "string"),
}
}
}
});
_对象.添加事件("上报清除", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//标识, 来源设备类型, 来源设备标识
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("标识", "string"),
new M子成员("来源设备类型", "string"),
new M子成员("来源设备标识", "string"),
}
}
}
});
_对象.添加事件("健康状态变化", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//标识, 来源设备类型, 来源设备标识
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("旧状态", "int"),
new M子成员("新状态", "int"),
}
}
}
});
_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(__对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("支持", () => 支持.ToString(), E角色.客户, null);
_对象.添加属性("默认端口号", () => 默认端口号.ToString(), E角色.客户, null);
_对象.添加方法("请求上传", __实参列表 =>
{
var __版本 = HJSON.反序列化 <M请求上传>(__实参列表["版本"]);
请求上传(__版本);
return(null);
}, E角色.客户, new List <M形参>
{
new M形参("版本", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("版本号", "string"),
new M子成员("标签", "string", E数据结构.单值数组),
new M子成员("文件名", "string"),
new M子成员("补丁", "bool"),
new M子成员("md5校验码", "string"),
new M子成员("大小", new M元数据 {
类型 = "int", 描述 = "单位:KB"
}),
}
})
}, null);
_对象.添加方法("结束上传", __实参列表 =>
{
结束上传();
return(null);
}, E角色.客户);
_对象.添加方法("开始升级", __实参列表 =>
{
var __版本 = __实参列表["版本号"];
开始升级(__版本);
return(null);
}, E角色.客户, new List <M形参>
{
new M形参("版本号", "string")
}, null);
_对象.添加方法("删除版本", __实参列表 =>
{
var __版本 = __实参列表["版本号"];
除版本(__版本);
return(null);
}, E角色.客户, new List <M形参>
{
new M形参("版本号", "string")
}, null);
_对象.添加事件("准备好接收数据", E角色.客户, new List <M形参> {
new M形参("事件参数", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
//端口号，每包最大(单位KB)，每包间隔（毫秒）
new M子成员("端口号", "int"),
new M子成员("每包最大", new M元数据 {
类型 = "int", 描述 = "单位:KB"
}),
new M子成员("每包间隔", new M元数据 {
类型 = "int", 描述 = "单位:毫秒"
}),
}
})
});
_对象.添加事件("升级完成", E角色.客户, new List <M形参> {
new M形参("事件参数", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
//成功(true/false), 描述, 需要重启(true/false)
new M子成员("成功", "bool"),
new M子成员("描述", "string"),
new M子成员("需要重启", "bool"),
}
})
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
