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服务端.添加对象("基本状态", () => __对象);
        }
Beispiel #2
0
        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); //最后一个参数是实参
            __客户端.订阅事件("基本状态", "发生了重要变化", __实参 => {
            //处理实参
            });
        }
Beispiel #3
0
 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 __对象;
 }
Beispiel #4
0
 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 __对象;
 }