예제 #1
0
 private void ConnectTask(string host, TcpClient client)
 {
     Task.Factory.StartNew(() =>
     {
         OnConnect?.Invoke(host);//委托:已连接
         while (client.Connected)
         {
             try
             {
                 TcpDataModel model = TcpStreamHelper.Read(client);
                 if (model != null)
                 {
                     if (model.Type == int.MaxValue)
                     {
                         //返回心跳
                         Write(new TcpDataModel()
                         {
                             Type = int.MaxValue
                         });
                     }
                     else
                     {
                         ReceiveMessage(host, model);//委托:接收消息
                     }
                 }
             }
             catch { }
             //Sleep.S(1);
         }
         client.Close();
         OnDisconnect?.Invoke(host);//委托:断开连接
     });
     //lstn.BeginAcceptTcpClient(new AsyncCallback(acceptCallback), lstn);
 }
예제 #2
0
파일: TcppClient.cs 프로젝트: zyj0021/Fork
 /// <summary>
 /// 发送数据
 /// </summary>
 /// <param name="model">数据模型</param>
 public void Write(TcpDataModel model)
 {
     if (this.Client != null && this.Client.Connected)
     {
         bool flag = TcpStreamHelper.Write(Client, model);
     }
 }
예제 #3
0
        public static int Byte2Model(List <byte> data, out TcpDataModel model)
        {
            model = null;

            if (data.Count > HeadLength &&
                data[0] == 111 && data[1] == 222 && data[2] == 66 && data[3] == 66)
            {
                int msgCode       = BitConverter.ToInt32(new byte[] { data[4], data[5], data[6], data[7] }, 0);
                int msgBodyLength = BitConverter.ToInt32(new byte[] { data[8], data[9], data[10], data[11] }, 0);
                if (data.Count >= HeadLength + msgBodyLength)
                {
                    byte[] body      = data.GetRange(HeadLength, msgBodyLength).ToArray();
                    string bodyToGBK = Encoding.GetEncoding("GBK").GetString(body);
                    //ReceiveByteContent(body);
                    Cons.Log(bodyToGBK);
                    //Send(ReceiveByte.GetRange(0, 6).ToArray());
                    data.RemoveRange(0, 6 + msgBodyLength);

                    //ReceiveMessage?.Invoke(msgCode, body);
                }
            }
            else
            {
                data.Clear();
                //Socket.Send(new byte[] { 0 });
            }
            return(0);
        }
예제 #4
0
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="model">数据模型</param>
        public bool Write(TcpDataModel model)
        {
            bool flag = false;

            if (this.Client != null && this.Client.Connected)
            {
                flag = TcpStreamHelper.Write(Client, model);
            }
            return(flag);
        }
예제 #5
0
파일: TcppServer.cs 프로젝트: zyj0021/Fork
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="host">主机地址</param>
        /// <param name="model">数据模型</param>
        public void Write(string host, TcpDataModel model)
        {
            var dictionary = Clients_Get(host);

            if (dictionary != null && dictionary.Client != null)
            {
                if (dictionary.Client.Connected)
                {
                    bool flag = TcpStreamHelper.Write(dictionary.Client, model);
                }
            }
        }
예제 #6
0
파일: TcppServer.cs 프로젝트: znw333/Fork
        private void ConnectTask(string host, TcpClient client)
        {
            TcpClientInfo clientInfo    = TcpClientManager.GetInfoByHost(host);
            DateTime      HeartbeatTime = DateTime.Now;

            //发送心跳
            Task.Factory.StartNew(() =>
            {
                while (client.Connected)
                {
                    TcpDataModel model = new TcpDataModel()
                    {
                        Type = int.MaxValue
                    };
                    TcpStreamHelper.Write(client, model);

                    Sleep.S(5);
                    //if (DateTime.Now.AddSeconds(-10) > HeartbeatTime)
                    //    client.Close();
                    Sleep.S(5);
                }
            });
            //接收消息
            Task.Factory.StartNew(() =>
            {
                OnConnectAction?.Invoke(clientInfo);//委托:已连接
                while (client.Connected)
                {
                    try
                    {
                        TcpDataModel model = TcpStreamHelper.Read(client);
                        if (model != null)
                        {
                            if (model.Type == int.MaxValue)
                            {
                                //过滤心跳
                                HeartbeatTime = DateTime.Now;
                            }
                            else
                            {
                                TcpClientManager.UpdateDownloadFlowCount(host, model.Data.Length);
                                OnReceiveAction(clientInfo, model);//委托:接收消息
                            }
                        }
                    }
                    catch { }
                    //Sleep.S(1);
                }
                client.Close();
                TcpClientManager.RemoveByHost(host);
                OnDisconnectAction?.Invoke(clientInfo);//委托:断开连接
            });
        }
예제 #7
0
파일: TcppServer.cs 프로젝트: znw333/Fork
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="host">主机地址</param>
        /// <param name="model">数据模型</param>
        public void Write(string host, TcpDataModel model)
        {
            var dictionary = TcpClientManager.GetInfoByHost(host);

            if (dictionary != null && dictionary.Client != null)
            {
                if (dictionary.Client.Connected)
                {
                    TcpClientManager.UpdateUploadFlowCount(host, model.Data.Length);
                    bool flag = TcpStreamHelper.Write(dictionary.Client, model);
                }
            }
        }
예제 #8
0
파일: TcppServer.cs 프로젝트: zyj0021/Fork
        private void ConnectTask(string host, TcpClient client)
        {
            DateTime HeartbeatTime = DateTime.Now;

            //发送心跳
            Task.Factory.StartNew(() =>
            {
                while (client.Connected)
                {
                    TcpDataModel model = new TcpDataModel()
                    {
                        Type = int.MaxValue
                    };
                    TcpStreamHelper.Write(client, model);

                    Sleep.S(5);
                    //if (DateTime.Now.AddSeconds(-10) > HeartbeatTime)
                    //    client.Close();
                    Sleep.S(5);
                }
            });
            //接收消息
            Task.Factory.StartNew(() =>
            {
                OnConnect?.Invoke(host);//委托:已连接
                while (client.Connected)
                {
                    try
                    {
                        TcpDataModel model = TcpStreamHelper.Read(client);
                        if (model != null)
                        {
                            if (model.Type == int.MaxValue)
                            {
                                //过滤心跳
                                HeartbeatTime = DateTime.Now;
                            }
                            else
                            {
                                ReceiveMessage(host, model);//委托:接收消息
                            }
                        }
                    }
                    catch { }
                    //Sleep.S(1);
                }
                client.Close();
                Clients_Del(host);
                OnDisconnect?.Invoke(host);//委托:断开连接
            });
        }
예제 #9
0
        /// <summary>
        /// 流 读取
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static TcpDataModel Read(TcpClient client)
        {
            TcpDataModel data = null;

            try
            {
                if (client != null && client.GetStream() != null)
                {
                    //内容长度
                    byte[] data_length = new byte[4];
                    int    read        = client.GetStream().Read(data_length, 0, 4);
                    int    length      = BitConverter.ToInt32(data_length, 0) - 4;

                    if (read > 0 && length > 0)
                    {
                        //内容头部标志
                        byte[] data_head = new byte[4];
                        client.GetStream().Read(data_head, 0, 4);
                        bool head = data_head[0] == 111 && data_head[1] == 222 && data_head[2] == 66 && data_head[3] == 66;

                        if (head)
                        {
                            //读取内容
                            byte[] buffer  = new byte[length];
                            int    bf_read = 0;
                            while (bf_read < length)
                            {
                                //循环读取内容,防止断包
                                bf_read += client.GetStream().Read(buffer, bf_read, length - bf_read);
                                if (bf_read < length)
                                {
                                    int x = bf_read;
                                }
                            }
                            //解析内容
                            data = TcpDataModel.ToModel(buffer);
                        }
                    }
                    else
                    {
                        if (read == 0)
                        {
                            client?.Close();
                        }
                    }
                }
            }
            catch { }
            return(data);
        }
예제 #10
0
        /// <summary>
        /// 转换为模型
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public static TcpDataModel ToModel(byte[] bytes)
        {
            TcpDataModel model = null;

            try
            {
                int type   = BitConverter.ToInt32(bytes, 0);
                int length = BitConverter.ToInt32(bytes, 4);

                byte[] data_byte = bytes.Skip(8).Take(length).ToArray();

                model = new TcpDataModel(type, data_byte);
            }
            catch { }
            return(model);
        }
예제 #11
0
        private void ConnectTask(TcpClient client)
        {
            Task.Factory.StartNew(() =>
            {
                OnConnectAction?.Invoke();//委托:已连接
                while (client.Connected)
                {
                    try
                    {
                        TcpDataModel model = TcpStreamHelper.Read(client);
                        if (model != null)
                        {
                            if (model.Type == int.MaxValue)
                            {
                                //返回心跳
                                Write(new TcpDataModel(int.MaxValue));
                            }
                            else
                            {
                                //优先调用默认接收消息方法Action
                                OnReceiveAction?.Invoke(model);

                                //调用同步处理委托方法
                                if (Ls.Ok(SyncFunction))
                                {
                                    for (var i = 0; i < SyncFunction.Count; i++)
                                    {
                                        bool flag = SyncFunction.TryDequeue(out Tuple <int, Action <TcpDataModel> > fun);
                                        if (flag)
                                        {
                                            Task.Factory.StartNew(() => { fun.Item2?.Invoke(model); });
                                        }
                                    }
                                }
                            }
                        }
                    }
                    catch { }
                    //Sleep.S(1);
                }
                client.Close();
                OnDisconnectAction?.Invoke();//委托:断开连接
            });
            //lstn.BeginAcceptTcpClient(new AsyncCallback(acceptCallback), lstn);
        }
예제 #12
0
        /// <summary>
        /// 发送数据(action禁止使用阻塞操作,必须新建task线程操作)
        /// </summary>
        /// <param name="model">数据模型</param>
        /// <param name="actionType">事件驱动处理类型</param>
        /// <param name="action">事件驱动处理方法</param>
        public bool Write(TcpDataModel model, int?actionType = 0, Action <TcpDataModel> action = null)
        {
            bool flag = false;

            if (Client != null && Client.Connected)
            {
                flag = TcpStreamHelper.Write(Client, model);
            }
            if (flag)
            {
                if (actionType != null && action != null)
                {
                    int type = actionType.GetValueOrDefault();
                    SyncFunction.Enqueue(new Tuple <int, Action <TcpDataModel> >(type, action));
                }
            }
            return(flag);
        }
예제 #13
0
        /// <summary>
        /// 流 写入
        /// </summary>
        /// <param name="stream"></param>
        /// <param name="model"></param>
        /// <returns></returns>
        public static bool Write(TcpClient client, TcpDataModel model)
        {
            try
            {
                if (client != null && client.GetStream() != null)
                {
                    byte[] md_byte     = model.ToByte();
                    byte[] length_byte = BitConverter.GetBytes((int)(md_byte.Length + 4));

                    List <byte> data = new List <byte>();
                    data.AddRange(length_byte);                              //长度
                    data.AddRange(new byte[] { 111, 222, 66, 66 });          //标志
                    data.AddRange(md_byte);                                  //内容

                    client.GetStream().Write(data.ToArray(), 0, data.Count); //写出内容
                    return(true);
                }
            }
            catch { }
            return(false);
        }