Example #1
0
        public void 连接(IPEndPoint __设备端口)
        {
            H日志输出.记录("创建客户端");
            __IN网络节点   = FN网络传输工厂.创建TCP客户端(__设备端口, new IPEndPoint(IPAddress.Any, 5555), P报文.消息头长度, P报文.解码消息长度);
            __IN网络节点.称 = "客户端";
            //__客户端.自动重连 = true;
            _IN上下文         = new N上下文();
            __IN网络节点.收到消息 += (__远端地址, __消息) =>
            {
                var __报文 = H报文注册.解码(__消息);
                if (__报文 == null)
                {
                    return;
                }
                _IN上下文.收到报文(__远端地址, __报文);
            };
            __IN网络节点.已断开 += () => H日志输出.记录("客户端: 与服务器断开", string.Empty);
            __IN网络节点.已连接 += () =>
            {
                连接正常 = true;
                On已连接();
                On收到了通知(new M通知
                {
                    对象  = "系统",
                    概要  = "欢迎进入",
                    详细  = "",
                    重要性 = "普通"
                });

                Task.Factory.StartNew(() =>
                {
                    byte[] __心跳 = new P心跳().编码();
                    while (__IN网络节点.连接正常)
                    {
                        __IN网络节点.异步发送(__心跳);
                        Thread.Sleep(10000);
                    }
                });
                Task.Factory.StartNew(() =>
                {
                    _最后心跳时间 = DateTime.Now;
                    while (__IN网络节点.连接正常)
                    {
                        if (_最后心跳时间.AddMilliseconds(_心跳频率 * 5) < DateTime.Now)
                        {
                            On已断开(false);
                        }
                        Thread.Sleep(_心跳频率);
                    }
                });
            };
            H日志输出.记录("配置客户端上下文");
            _IN上下文.设置发送方法((__节点, __消息) => __IN网络节点.步发送(__消息));
            _IN上下文.订阅报文(typeof(P心跳), () => this);
            _IN上下文.订阅报文(typeof(P通知), () => this);

            __IN网络节点.开启();
        }
Example #2
0
        public void 连接(IPEndPoint __设备地址)
        {
            设备地址 = __设备地址;
            var __编解码器 = new B编解码器(H报文注册.报文字典, H报文注册.通道字典, FT通用访问工厂.文本编码)
            {
                编码拦截 = H报文注册.拦截发送报文,
                解码拦截 = H报文注册.拦截接收报文
            };

            _IN网络节点       = FN网络传输工厂.创建TCP客户端(__设备地址, new IPEndPoint(IPAddress.Any, 0), __编解码器.消息头长度, __编解码器.解码消息长度);
            _IN网络节点.称     = "客户端";
            _IN网络节点.自动重连  = this.自动重连;
            _IN上下文        = new N上下文(__编解码器, _IN网络节点.称);
            _N主动会话        = new N主动会话(_IN上下文, __设备地址);
            _IN网络节点.收到消息 += (__远端地址, __消息) => _IN上下文.收到报文(__远端地址, __消息);
            _IN网络节点.已断开  += () =>
            {
                if (连接正常)
                {
                    连接正常 = false;
                    On已断开(false);
                }
                _IN上下文.注销节点(__设备地址);
            };
            _IN网络节点.已连接 += () =>
            {
                连接正常 = true;

                Task.Factory.StartNew(On已连接);
            };
            _IN上下文.设置发送方法((__节点, __消息) => _IN网络节点.步发送(__消息));
            _IN上下文.订阅报文(H报文注册.查询功能码(typeof(M接收事件)), () => new N被动会话(new Action <N会话参数>(处理事件)));

            _IN网络节点.最大消息长度 = 10000000;
            _IN网络节点.开启();
        }
        public void 连接(IPEndPoint __设备地址)
        {
            设备地址 = __设备地址;
            var __编解码器 = new B编解码器(H报文注册.报文字典, H报文注册.通道字典, FT通用访问工厂.文本编码)
            {
                编码拦截 = H报文注册.拦截发送报文,
                解码拦截 = H报文注册.拦截接收报文
            };
            _IN网络节点 = FN网络传输工厂.创建TCP客户端(__设备地址, new IPEndPoint(IPAddress.Any, 0), __编解码器.消息头长度, __编解码器.解码消息长度);
            _IN网络节点.名称 = "客户端";
            _IN网络节点.自动重连 = this.自动重连;
            _IN上下文 = new N上下文(__编解码器, _IN网络节点.名称);
            _N主动会话 = new N主动会话(_IN上下文, __设备地址);
            _IN网络节点.收到消息 += (__远端地址, __消息) => _IN上下文.收到报文(__远端地址, __消息);
            _IN网络节点.已断开 += () =>
            {
                if (连接正常)
                {
                    连接正常 = false;
                    On已断开(false);
                }
                _IN上下文.注销节点(__设备地址);
            };
            _IN网络节点.已连接 += () =>
            {
                连接正常 = true;

                Task.Factory.StartNew(On已连接);
            };
            _IN上下文.设置发送方法((__节点, __消息) => _IN网络节点.同步发送(__消息));
            _IN上下文.订阅报文(H报文注册.查询功能码(typeof(M接收事件)), () => new N被动会话(new Action<N会话参数>(处理事件)));

            _IN网络节点.最大消息长度 = 10000000;
            _IN网络节点.开启();
        }
        public void 连接(IPEndPoint __设备端口)
        {
            H日志输出.记录("创建客户端");
            __IN网络节点 = FN网络传输工厂.创建TCP客户端(__设备端口, new IPEndPoint(IPAddress.Any, 5555), P报文.消息头长度, P报文.解码消息长度);
            __IN网络节点.名称 = "客户端";
            //__客户端.自动重连 = true;
            _IN上下文 = new N上下文();
            __IN网络节点.收到消息 += (__远端地址, __消息) =>
            {
                var __报文 = H报文注册.解码(__消息);
                if (__报文 == null)
                {
                    return;
                }
                _IN上下文.收到报文(__远端地址, __报文);
            };
            __IN网络节点.已断开 += () => H日志输出.记录("客户端: 与服务器断开", string.Empty);
            __IN网络节点.已连接 += () =>
            {
                连接正常 = true;
                On已连接();
                On收到了通知(new M通知
                {
                    对象 = "系统",
                    概要 = "欢迎进入",
                    详细 = "",
                    重要性 = "普通"
                });

                Task.Factory.StartNew(() =>
                {
                    byte[] __心跳 = new P心跳().编码();
                    while (__IN网络节点.连接正常)
                    {
                        __IN网络节点.异步发送(__心跳);
                        Thread.Sleep(10000);
                    }
                });
                Task.Factory.StartNew(() =>
                {
                    _最后心跳时间 = DateTime.Now;
                    while (__IN网络节点.连接正常)
                    {
                        if (_最后心跳时间.AddMilliseconds(_心跳频率 * 5) < DateTime.Now)
                        {
                            On已断开(false);
                        }
                        Thread.Sleep(_心跳频率);
                    }
                });
            };
            H日志输出.记录("配置客户端上下文");
            _IN上下文.设置发送方法((__节点, __消息) => __IN网络节点.同步发送(__消息));
            _IN上下文.订阅报文(typeof(P心跳), () => this);
            _IN上下文.订阅报文(typeof(P通知), () => this);

            __IN网络节点.开启();
        }