Esempio n. 1
0
        /// <summary>
        /// 开始连接远程服务器
        /// </summary>
        /// <param name="SocketPacketRB">要连接的远程服务器包</param>
        private void StartClient(SocketPacketRB socketPacket)
        {
            try
            {
                //设置指定的网络地址和端口号
                IPAddress  ipAddress = IPAddress.Parse(socketPacket.IpAddress);
                IPEndPoint remoteEP  = new IPEndPoint(ipAddress, socketPacket.ClientPort);
                // 创建一个TCP/IP套接字对象.
                socketPacket.CurrentSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                // 对远程主机开始异步连接.
                socketPacket.CurrentSocket.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), socketPacket);
            }
            catch (Exception e)
            {
                try
                {
                    if (socketPacket.State == 1 && socketPacket.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, e.StackTrace, "[Base_SocketClient:StartClient]", socketPacket.IpAddress + "未连接");
                        socketPacket.ErrorShow = true;
                    }
                    socketPacket.State = 2;
                }
                catch { }
            }
        }
Esempio n. 2
0
 /// <summary>
 /// 等待从客户端发送过来的数据
 /// </summary>
 /// <param name="soc"></param>
 /// <param name="clientNumber"></param>
 public void WaitForData(SocketPacketRB soc)
 {
     try
     {
         if (pfnWorkerCallBack == null)
         {
             // 获取等待发送数据回调方法
             pfnWorkerCallBack = new AsyncCallback(OnDataReceived);
         }
         soc.DataBuffer = new byte[soc.DataLength];
         //调用开始异步接收数据方法
         soc.CurrentSocket.BeginReceive(soc.DataBuffer, 0, soc.DataBuffer.Length, SocketFlags.None, pfnWorkerCallBack, soc);
     }
     catch (Exception se)
     {
         if (soc != null && soc.CurrentSocket != null)
         {
             if (ClientConnect != null)
             {
                 ClientConnect(((IPEndPoint)soc.CurrentSocket.RemoteEndPoint).Address.ToString(), false);
             }
         }
         if (ErrorMessage != null && soc.ErrorShow == false)
         {
             soc.ErrorShow = false;
             ErrorMessage(8033002, se.StackTrace, "[Base_SocketClient:StartClient]", se.Message);
         }
     }
 }
Esempio n. 3
0
        /// <summary>
        /// 添加远程连接
        /// </summary>
        /// <param name="strIpAddress">远程连接地址</param>
        /// <param name="port">远程连接端口</param>
        public void Add(string strIpAddress, int port)
        {
            #region [判断要连接的列表中是否存在]
            SocketPacketRB spCollect;
            for (int i = 0; i < m_socketClientList.Count; i++)
            {
                spCollect = (SocketPacketRB)m_socketClientList[i];
                if (spCollect.IpAddress.Equals(strIpAddress) && spCollect.ClientPort.Equals(port))
                {
                    return;
                }
            }
            spCollect = null;
            #endregion [判断要连接的列表中是否存在]

            #region [添加到要连接的服务器列表中]
            SocketPacketRB sp = new SocketPacketRB();
            sp.IpAddress  = strIpAddress;
            sp.ClientPort = port;
            sp.ErrorShow  = false;
            sp.State      = 0;
            m_socketClientList.Add(sp);
            #endregion [添加到要连接的服务器列表中]

            //开始连接远程服务器
            StartClient(sp);
        }
Esempio n. 4
0
 /// <summary>
 /// 重新连接远程主机
 /// </summary>
 private void Repeat()
 {
     while (true)
     {
         try
         {
             for (int i = 0; i < m_socketClientList.Count; i++)
             {
                 SocketPacketRB s = (SocketPacketRB)m_socketClientList[i];
                 if (s.CurrentSocket == null || (s.CurrentSocket.Connected == false && s.State != 1))
                 {
                     if (s.CurrentSocket != null)
                     {
                         s.CurrentSocket.Close();
                         s.CurrentSocket = null;
                     }
                     s.State = 1;
                     StartClient(s);
                 }
             }
         }
         catch
         { }
         finally
         {
             //3s后重新连接
             Thread.Sleep(3000);
         }
     }
 }
Esempio n. 5
0
 /// <summary>
 /// 挂起等待接收数据线程
 /// </summary>
 /// <param name="socketPacket">远程连接对象包</param>
 private void WaitForData(SocketPacketRB socketPacket)
 {
     try
     {
         if (m_pfnCallBack == null)
         {
             m_pfnCallBack = new AsyncCallback(OnDataReceived);
         }
         // 开始异步获取数据
         socketPacket.DataBuffer = new byte[socketPacket.DataLength];
         socketPacket.CurrentSocket.BeginReceive(socketPacket.DataBuffer, 0, socketPacket.DataBuffer.Length, SocketFlags.None, m_pfnCallBack, socketPacket);
     }
     catch (Exception se)
     {
         try
         {
             if ((socketPacket.State == 0 || socketPacket.State == 2) && socketPacket.ErrorShow == false)
             {
                 tA.Stop();
                 ErrorMessage(8033002, se.StackTrace, "[Base_SocketClient:WaitForData]", socketPacket.IpAddress + "未连接");
                 socketPacket.ErrorShow = true;
             }
             if (socketPacket.CurrentSocket != null)
             {
                 socketPacket.CurrentSocket.Close();
                 socketPacket.CurrentSocket = null;
             }
         }
         catch { }
     }
 }
Esempio n. 6
0
        /// <summary>
        /// 结束挂起的异步发送
        /// </summary>
        /// <param name="ar">异步操作对象</param>
        private void SendCallback(IAsyncResult ar)
        {
            SocketPacketRB sp_SendCallbace = new SocketPacketRB();

            try
            {
                sp_SendCallbace = (SocketPacketRB)ar.AsyncState;

                sp_SendCallbace.CurrentSocket.EndSend(ar);
            }
            catch (Exception e)
            {
                try
                {
                    if (sp_SendCallbace.State == 2 && !sp_SendCallbace.IpAddress.Equals("") && sp_SendCallbace.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, e.StackTrace, "[Base_SocketClient:SendCallback]", sp_SendCallbace.IpAddress + "未连接");
                        sp_SendCallbace.ErrorShow = true;
                    }
                    if (sp_SendCallbace.CurrentSocket != null)
                    {
                        sp_SendCallbace.CurrentSocket.Close();
                        sp_SendCallbace.CurrentSocket = null;
                    }
                }
                catch { }
            }
        }
Esempio n. 7
0
        /// <summary>
        /// 结束挂起的等待接收数据线程
        /// </summary>
        /// <param name="asyn">异步调用对象</param>
        private void OnDataReceived(IAsyncResult asyn)
        {
            SocketPacketRB socketPacket_Received = null;

            try
            {
                socketPacket_Received = (SocketPacketRB)asyn.AsyncState;
                int iRx = socketPacket_Received.CurrentSocket.EndReceive(asyn);

                //获取异步读取得到的数据包
                char[] chars          = new char[iRx + 1];
                System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
                int           charLen = d.GetChars(socketPacket_Received.DataBuffer, 0, iRx, chars, 0);
                System.String szData  = new System.String(chars);

                //// 获取得到的字符
                //byte[] bytes = new byte[iRx];
                //for (int i = 0; i < iRx; i++)
                //{
                //    bytes[i] = socketPacket_Received.DataBuffer[i];
                //}
                if (DataReceivedByAddress != null)
                {
                    //调用数据获取事件
                    DataReceivedByAddress(szData, socketPacket_Received.IpAddress);
                }
            }
            catch (Exception se)
            {
                try
                {
                    if ((socketPacket_Received.State == 0 || socketPacket_Received.State == 2) && socketPacket_Received.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, se.StackTrace, "[Base_SocketClient:WaitForData]", socketPacket_Received.IpAddress + "未连接");
                        socketPacket_Received.ErrorShow = true;
                    }
                    if (socketPacket_Received.CurrentSocket != null)
                    {
                        socketPacket_Received.CurrentSocket.Close();
                        socketPacket_Received.CurrentSocket = null;
                    }
                }
                catch { }
            }
            finally
            {
                if (socketPacket_Received != null)
                {
                    tA.Start();
                    //继续等待数据
                    WaitForData(socketPacket_Received);
                }
            }
        }
Esempio n. 8
0
 void tA_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
 {
     tA.Stop();
     for (int i = 0; i < m_socketClientList.Count; i++)
     {
         SocketPacketRB s      = (SocketPacketRB)m_socketClientList[i];
         byte[]         byData = System.Text.Encoding.ASCII.GetBytes("1");
         Send(byData, s.IpAddress, s.ClientPort);
     }
     tA.Start();
 }
Esempio n. 9
0
        /// <summary>
        /// 回调方法  客户端请求连接同意
        /// </summary>
        /// <param name="asyn"></param>
        public void OnClientConnect(IAsyncResult asyn)
        {
            Socket         workerSocket = null;
            SocketPacketRB sp           = null;

            try
            {
                //同意接收接入
                workerSocket = m_mainSocket.EndAccept(asyn);

                sp               = new SocketPacketRB();
                sp.ErrorShow     = false;
                sp.CurrentSocket = workerSocket;
                sp.IpAddress     = ((IPEndPoint)workerSocket.RemoteEndPoint).Address.ToString();
                // 把接入的Socket添加到动态数组中
                m_workerSocketList.Add(sp);

                if (ClientConnect != null)
                {
                    ClientConnect(((IPEndPoint)workerSocket.RemoteEndPoint).Address.ToString(), true);
                }
            }
            catch (Exception ee)
            {
                if (workerSocket != null)
                {
                    if (ClientConnect != null)
                    {
                        ClientConnect(((IPEndPoint)workerSocket.RemoteEndPoint).Address.ToString(), false);
                    }
                }
                if (ErrorMessage != null && sp.ErrorShow == false)
                {
                    sp.ErrorShow = true;
                    ErrorMessage(8033002, ee.StackTrace, "[Base_SocketClient:StartClient]", ee.Message);
                }
            }
            finally
            {
                if (sp != null)
                {
                    if (sp.CurrentSocket != null && sp.CurrentSocket.Connected)
                    {
                        //ErrorMessage(30007, "", "[Base_SocketClient:ConnectCallback]", SocketPacketRB.IpAddress + "已连接");
                        sp.ErrorShow = false;
                        //等待接收数据
                        WaitForData(sp);
                        //其他客户端连接,异步调用请求同意方法
                        m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
                    }
                }
            }
        }
Esempio n. 10
0
        /// <summary>
        /// 开始发送数据
        /// </summary>
        /// <param name="bytes">发送字节</param>
        /// <param name="strIpAddress">发送的地址</param>
        /// <param name="port">发送的端口</param>
        public void Send(byte[] bytes, string strIpAddress)
        {
            SocketPacketRB spCollect = new SocketPacketRB();

            try
            {
                for (int i = 0; i < m_workerSocketList.Count; i++)
                {
                    spCollect = (SocketPacketRB)m_workerSocketList[i];
                    if (spCollect.IpAddress.Equals(strIpAddress))
                    {
                        //开始异步发送数据
                        spCollect.CurrentSocket.BeginSend(bytes, 0, bytes.Length, 0, new AsyncCallback(SendCallback), spCollect);
                        break;
                    }
                }
            }
            catch (SocketException se)
            {
                try
                {
                    if (spCollect != null && spCollect.CurrentSocket != null)
                    {
                        if (ClientConnect != null)
                        {
                            ClientConnect(((IPEndPoint)spCollect.CurrentSocket.RemoteEndPoint).Address.ToString(), false);
                        }
                    }
                    if (!spCollect.IpAddress.Equals("") && spCollect.ErrorShow == false)
                    {
                        ErrorMessage(8033002, se.StackTrace, "[Base_SocketClient:Send]", spCollect.IpAddress + "未连接");
                        spCollect.ErrorShow = true;
                    }
                    if (spCollect.CurrentSocket != null)
                    {
                        spCollect.CurrentSocket.Close();
                        spCollect.CurrentSocket = null;
                    }
                }
                catch { }
            }
            catch (Exception ee)
            {
            }
        }
Esempio n. 11
0
        /// <summary>
        /// 构造客户端连接对象
        /// </summary>
        /// <param name="socketArrayList">客户端连接列表</param>
        public ClientRB(string strIPaddress, int port)
        {
            if (baseSocketClient == null)
            {
                ArrayList socketArrayList = new ArrayList();
                socketPack = new SocketPacketRB();
                socketPack.IpAddress = strIPaddress;
                socketPack.ClientPort = port;
                socketPack.ErrorShow = false;
                socketPack.State = 0;
                socketArrayList.Add(socketPack);

                //创建链接服务器
                rbSqlConn.ExecCreadLineServer(strIPaddress);
                baseSocketClient = new SocketClient(socketArrayList);
                baseSocketClient.DataReceivedByAddress += new SocketClient.DataReceivedEventHandler(baseSocketClient_DataReceivedByAddress);
                baseSocketClient.ErrorMessage += new SocketClient.ErrorMessageEventHandler(baseSocketClient_ErrorMessage);

                //开始连接远程服务器
                RepeatStart();
            }
        }   
Esempio n. 12
0
        /// <summary>
        /// 构造客户端连接对象
        /// </summary>
        /// <param name="socketArrayList">客户端连接列表</param>
        public ClientRB(string strIPaddress, int port)
        {
            if (baseSocketClient == null)
            {
                ArrayList socketArrayList = new ArrayList();
                socketPack            = new SocketPacketRB();
                socketPack.IpAddress  = strIPaddress;
                socketPack.ClientPort = port;
                socketPack.ErrorShow  = false;
                socketPack.State      = 0;
                socketArrayList.Add(socketPack);

                //创建链接服务器
                rbSqlConn.ExecCreadLineServer(strIPaddress);
                baseSocketClient = new SocketClient(socketArrayList);
                baseSocketClient.DataReceivedByAddress += new SocketClient.DataReceivedEventHandler(baseSocketClient_DataReceivedByAddress);
                baseSocketClient.ErrorMessage          += new SocketClient.ErrorMessageEventHandler(baseSocketClient_ErrorMessage);

                //开始连接远程服务器
                RepeatStart();
            }
        }
Esempio n. 13
0
        /// <summary>
        /// 结束挂起的连接请求
        /// </summary>
        /// <param name="ar">异步调用对象</param>
        private void ConnectCallback(IAsyncResult ar)
        {
            //获取异步操作对象
            SocketPacketRB socketPacket = (SocketPacketRB)ar.AsyncState;

            try
            {
                // 与远程主机连接完成
                socketPacket.CurrentSocket.EndConnect(ar);
            }
            catch (Exception e)
            {
                try
                {
                    if (socketPacket.State == 1 && socketPacket.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, e.StackTrace, "[Base_SocketClient:ConnectCallback]", socketPacket.IpAddress + "未连接");
                        socketPacket.ErrorShow = true;
                    }
                }
                catch { }
            }
            finally
            {
                if (socketPacket != null)
                {
                    socketPacket.State = 2;
                    if (socketPacket.CurrentSocket != null && socketPacket.CurrentSocket.Connected)
                    {
                        ErrorMessage(8033001, "", "[Base_SocketClient:ConnectCallback]", socketPacket.IpAddress + "已连接");
                        socketPacket.ErrorShow = false;
                        tA.Start();
                        //等待接收数据
                        WaitForData(socketPacket);
                    }
                }
            }
        }
Esempio n. 14
0
        /// <summary>
        /// 结束挂起的异步发送
        /// </summary>
        /// <param name="ar">异步操作对象</param>
        private void SendCallback(IAsyncResult ar)
        {
            SocketPacketRB sp_SendCallbace = new SocketPacketRB();

            try
            {
                sp_SendCallbace = (SocketPacketRB)ar.AsyncState;

                sp_SendCallbace.CurrentSocket.EndSend(ar);
            }
            catch (SocketException e)
            {
                try
                {
                    if (sp_SendCallbace != null && sp_SendCallbace.CurrentSocket != null)
                    {
                        if (ClientConnect != null)
                        {
                            ClientConnect(((IPEndPoint)sp_SendCallbace.CurrentSocket.RemoteEndPoint).Address.ToString(), false);
                        }
                    }
                    if (sp_SendCallbace.State == 2 && !sp_SendCallbace.IpAddress.Equals("") && sp_SendCallbace.ErrorShow == false)
                    {
                        ErrorMessage(8033002, e.StackTrace, "[Base_SocketClient:SendCallback]", sp_SendCallbace.IpAddress + "未连接");
                        sp_SendCallbace.ErrorShow = true;
                    }
                    if (sp_SendCallbace.CurrentSocket != null)
                    {
                        sp_SendCallbace.CurrentSocket.Close();
                        sp_SendCallbace.CurrentSocket = null;
                    }
                }
                catch { }
            }
            catch (Exception ee)
            {
            }
        }
Esempio n. 15
0
        /// <summary>
        /// 开始发送数据
        /// </summary>
        /// <param name="bytes">发送字节</param>
        /// <param name="strIpAddress">发送的地址</param>
        /// <param name="port">发送的端口</param>
        public void Send(byte[] bytes, string strIpAddress, int port)
        {
            SocketPacketRB spCollect = new SocketPacketRB();

            try
            {
                for (int i = 0; i < m_socketClientList.Count; i++)
                {
                    spCollect = (SocketPacketRB)m_socketClientList[i];
                    if (spCollect.IpAddress.Equals(strIpAddress) && spCollect.ClientPort.Equals(port))
                    {
                        //开始异步发送数据
                        spCollect.CurrentSocket.BeginSend(bytes, 0, bytes.Length, 0, new AsyncCallback(SendCallback), spCollect);
                        break;
                    }
                }
            }
            catch (Exception ee)
            {
                try
                {
                    if (spCollect.State == 2 && !spCollect.IpAddress.Equals("") && spCollect.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, ee.StackTrace, "[Base_SocketClient:Send]", spCollect.IpAddress + "未连接");
                        spCollect.ErrorShow = true;
                    }
                    if (spCollect.CurrentSocket != null)
                    {
                        spCollect.CurrentSocket.Close();
                        spCollect.CurrentSocket = null;
                    }
                }
                catch { }
            }
        }
Esempio n. 16
0
        /// <summary>
        /// 结束挂起的异步发送
        /// </summary>
        /// <param name="ar">异步操作对象</param>
        private void SendCallback(IAsyncResult ar)
        {
            SocketPacketRB sp_SendCallbace = new SocketPacketRB();
            try
            {
                sp_SendCallbace = (SocketPacketRB)ar.AsyncState;

                sp_SendCallbace.CurrentSocket.EndSend(ar);
            }
            catch (Exception e)
            {
                try
                {
                    if (sp_SendCallbace.State == 2 && !sp_SendCallbace.IpAddress.Equals("") && sp_SendCallbace.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, e.StackTrace, "[Base_SocketClient:SendCallback]", sp_SendCallbace.IpAddress + "未连接");
                        sp_SendCallbace.ErrorShow = true;
                    }
                    if (sp_SendCallbace.CurrentSocket != null)
                    {
                        sp_SendCallbace.CurrentSocket.Close();
                        sp_SendCallbace.CurrentSocket = null;
                    }

                }
                catch { }
            }
        }
Esempio n. 17
0
        /// <summary>
        /// 开始发送数据
        /// </summary>
        /// <param name="bytes">发送字节</param>
        /// <param name="strIpAddress">发送的地址</param>
        /// <param name="port">发送的端口</param>
        public void Send(byte[] bytes, string strIpAddress, int port)
        {
            SocketPacketRB spCollect = new SocketPacketRB();
            try
            {
                for (int i = 0; i < m_socketClientList.Count; i++)
                {
                    spCollect = (SocketPacketRB)m_socketClientList[i];
                    if (spCollect.IpAddress.Equals(strIpAddress) && spCollect.ClientPort.Equals(port))
                    {
                        //开始异步发送数据
                        spCollect.CurrentSocket.BeginSend(bytes, 0, bytes.Length, 0, new AsyncCallback(SendCallback), spCollect);
                        break;
                    }
                }
            }
            catch (Exception ee)
            {
                try
                {
                    if (spCollect.State == 2 && !spCollect.IpAddress.Equals("") && spCollect.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, ee.StackTrace, "[Base_SocketClient:Send]", spCollect.IpAddress + "未连接");
                        spCollect.ErrorShow = true;
                    }
                    if (spCollect.CurrentSocket != null)
                    {
                        spCollect.CurrentSocket.Close();
                        spCollect.CurrentSocket = null;
                    }

                }
                catch { }
            }
        }
Esempio n. 18
0
        /// <summary>
        /// 挂起等待接收数据线程
        /// </summary>
        /// <param name="socketPacket">远程连接对象包</param>
        private void WaitForData(SocketPacketRB socketPacket)
        {
            try
            {
                if (m_pfnCallBack == null)
                {
                    m_pfnCallBack = new AsyncCallback(OnDataReceived);
                }
                // 开始异步获取数据
                socketPacket.DataBuffer = new byte[socketPacket.DataLength];
                socketPacket.CurrentSocket.BeginReceive(socketPacket.DataBuffer, 0, socketPacket.DataBuffer.Length, SocketFlags.None, m_pfnCallBack, socketPacket);
            }
            catch (Exception se)
            {
                try
                {
                    if ((socketPacket.State == 0 || socketPacket.State == 2) && socketPacket.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, se.StackTrace, "[Base_SocketClient:WaitForData]", socketPacket.IpAddress + "未连接");
                        socketPacket.ErrorShow = true;
                    }
                    if (socketPacket.CurrentSocket != null)
                    {
                        socketPacket.CurrentSocket.Close();
                        socketPacket.CurrentSocket = null;
                    }
                }
                catch { }
            }

        }
Esempio n. 19
0
        /// <summary>
        /// 开始连接远程服务器
        /// </summary>
        /// <param name="SocketPacketRB">要连接的远程服务器包</param>
        private void StartClient(SocketPacketRB socketPacket)
        {
            try
            {
                //设置指定的网络地址和端口号
                IPAddress ipAddress = IPAddress.Parse(socketPacket.IpAddress);
                IPEndPoint remoteEP = new IPEndPoint(ipAddress, socketPacket.ClientPort);
                // 创建一个TCP/IP套接字对象.
                socketPacket.CurrentSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                // 对远程主机开始异步连接.
                socketPacket.CurrentSocket.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), socketPacket);
            }
            catch (Exception e)
            {
                try
                {
                    if (socketPacket.State == 1 && socketPacket.ErrorShow == false)
                    {
                        tA.Stop();
                        ErrorMessage(8033002, e.StackTrace, "[Base_SocketClient:StartClient]", socketPacket.IpAddress + "未连接");
                        socketPacket.ErrorShow = true;
                    }
                    socketPacket.State = 2;
                }
                catch { }
            }
        }
Esempio n. 20
0
        /// <summary>
        /// 添加远程连接
        /// </summary>
        /// <param name="strIpAddress">远程连接地址</param>
        /// <param name="port">远程连接端口</param>
        public void Add(string strIpAddress, int port)
        {
            #region [判断要连接的列表中是否存在]
            SocketPacketRB spCollect;
            for (int i = 0; i < m_socketClientList.Count; i++)
            {
                spCollect = (SocketPacketRB)m_socketClientList[i];
                if (spCollect.IpAddress.Equals(strIpAddress) && spCollect.ClientPort.Equals(port))
                {
                    return;
                }
            }
            spCollect = null;
            #endregion [判断要连接的列表中是否存在]

            #region [添加到要连接的服务器列表中]
            SocketPacketRB sp = new SocketPacketRB();
            sp.IpAddress = strIpAddress;
            sp.ClientPort = port;
            sp.ErrorShow = false;
            sp.State = 0;
            m_socketClientList.Add(sp);
            #endregion [添加到要连接的服务器列表中]

            //开始连接远程服务器
            StartClient(sp);
        }
Esempio n. 21
0
        /// <summary>
        /// 结束挂起的异步发送
        /// </summary>
        /// <param name="ar">异步操作对象</param>
        private void SendCallback(IAsyncResult ar)
        {
            SocketPacketRB sp_SendCallbace = new SocketPacketRB();
            try
            {
                sp_SendCallbace = (SocketPacketRB)ar.AsyncState;

                sp_SendCallbace.CurrentSocket.EndSend(ar);
            }
            catch (SocketException e)
            {
                try
                {
                    if (sp_SendCallbace != null && sp_SendCallbace.CurrentSocket != null)
                    {
                        if (ClientConnect != null)
                        {
                            ClientConnect(((IPEndPoint)sp_SendCallbace.CurrentSocket.RemoteEndPoint).Address.ToString(), false);
                        }
                    }
                    if (sp_SendCallbace.State == 2 && !sp_SendCallbace.IpAddress.Equals("") && sp_SendCallbace.ErrorShow == false)
                    {
                        ErrorMessage(8033002, e.StackTrace, "[Base_SocketClient:SendCallback]", sp_SendCallbace.IpAddress + "未连接");
                        sp_SendCallbace.ErrorShow = true;
                    }
                    if (sp_SendCallbace.CurrentSocket != null)
                    {
                        sp_SendCallbace.CurrentSocket.Close();
                        sp_SendCallbace.CurrentSocket = null;
                    }

                }
                catch { }
            }
            catch (Exception ee)
            {
                
            }
        }
Esempio n. 22
0
        /// <summary>
        /// 开始发送数据
        /// </summary>
        /// <param name="bytes">发送字节</param>
        /// <param name="strIpAddress">发送的地址</param>
        /// <param name="port">发送的端口</param>
        public void Send(byte[] bytes, string strIpAddress)
        {
            SocketPacketRB spCollect = new SocketPacketRB();
            try
            {
                for (int i = 0; i < m_workerSocketList.Count; i++)
                {
                    spCollect = (SocketPacketRB)m_workerSocketList[i];
                    if (spCollect.IpAddress.Equals(strIpAddress))
                    {
                        //开始异步发送数据
                        spCollect.CurrentSocket.BeginSend(bytes, 0, bytes.Length, 0, new AsyncCallback(SendCallback), spCollect);
                        break;
                    }
                }
            }
            catch (SocketException se)
            {
                try
                {
                    if (spCollect != null && spCollect.CurrentSocket != null)
                    {
                        if (ClientConnect != null)
                        {
                            ClientConnect(((IPEndPoint)spCollect.CurrentSocket.RemoteEndPoint).Address.ToString(), false);
                        }
                    }
                    if (!spCollect.IpAddress.Equals("") && spCollect.ErrorShow == false)
                    {
                        ErrorMessage(8033002, se.StackTrace, "[Base_SocketClient:Send]", spCollect.IpAddress + "未连接");
                        spCollect.ErrorShow = true;
                    }
                    if (spCollect.CurrentSocket != null)
                    {
                        spCollect.CurrentSocket.Close();
                        spCollect.CurrentSocket = null;
                    }

                }
                catch { }
            }
            catch (Exception ee)
            {
                
            }
        }
Esempio n. 23
0
 /// <summary>
 /// 等待从客户端发送过来的数据
 /// </summary>
 /// <param name="soc"></param>
 /// <param name="clientNumber"></param>
 public void WaitForData(SocketPacketRB soc)
 {
     try
     {
         if (pfnWorkerCallBack == null)
         {
             // 获取等待发送数据回调方法
             pfnWorkerCallBack = new AsyncCallback(OnDataReceived);
         }
         soc.DataBuffer = new byte[soc.DataLength];
         //调用开始异步接收数据方法
         soc.CurrentSocket.BeginReceive(soc.DataBuffer, 0, soc.DataBuffer.Length, SocketFlags.None, pfnWorkerCallBack, soc);
     }
     catch (Exception se)
     {
         if (soc != null && soc.CurrentSocket!=null)
         {
             if (ClientConnect != null)
             {
                 ClientConnect(((IPEndPoint)soc.CurrentSocket.RemoteEndPoint).Address.ToString(), false);
             }
         }
         if (ErrorMessage != null && soc.ErrorShow == false)
         {
             soc.ErrorShow = false;
             ErrorMessage(8033002, se.StackTrace, "[Base_SocketClient:StartClient]", se.Message);
         }
     }
 }
Esempio n. 24
0
        /// <summary>
        /// 回调方法  客户端请求连接同意
        /// </summary>
        /// <param name="asyn"></param>
        public void OnClientConnect(IAsyncResult asyn)
        {
            Socket workerSocket = null;
            SocketPacketRB sp = null;
            try
            {
                //同意接收接入
                workerSocket = m_mainSocket.EndAccept(asyn);

                sp = new SocketPacketRB();
                sp.ErrorShow = false;
                sp.CurrentSocket = workerSocket;
                sp.IpAddress = ((IPEndPoint)workerSocket.RemoteEndPoint).Address.ToString();
                // 把接入的Socket添加到动态数组中
                m_workerSocketList.Add(sp);

                if (ClientConnect != null)
                {
                    ClientConnect(((IPEndPoint)workerSocket.RemoteEndPoint).Address.ToString(), true);
                }
            }
            catch(Exception ee)
            {
                if (workerSocket != null)
                {
                    if (ClientConnect != null)
                    {
                        ClientConnect(((IPEndPoint)workerSocket.RemoteEndPoint).Address.ToString(), false);
                    }
                }
                if (ErrorMessage != null && sp.ErrorShow == false)
                {
                    sp.ErrorShow = true;
                    ErrorMessage(8033002, ee.StackTrace, "[Base_SocketClient:StartClient]", ee.Message);
                }
            }
            finally
            {
                if (sp != null)
                {
                    if (sp.CurrentSocket != null && sp.CurrentSocket.Connected)
                    {
                        //ErrorMessage(30007, "", "[Base_SocketClient:ConnectCallback]", SocketPacketRB.IpAddress + "已连接");
                        sp.ErrorShow = false;
                        //等待接收数据
                        WaitForData(sp);
                        //其他客户端连接,异步调用请求同意方法
                        m_mainSocket.BeginAccept(new AsyncCallback(OnClientConnect), null);
                    }
                }
            }
        }
Esempio n. 25
0
        /// <summary>
        /// 接收数据方法
        /// </summary>
        /// <param name="asyn"></param>
        public void OnDataReceived(IAsyncResult asyn)
        {
            SocketPacketRB socketData = null;

            try
            {
                socketData = (SocketPacketRB)asyn.AsyncState;
                //获取异步读取得到的数据包
                int    iRx            = socketData.CurrentSocket.EndReceive(asyn);
                char[] chars          = new char[iRx + 1];
                System.Text.Decoder d = System.Text.Encoding.UTF8.GetDecoder();
                int charLen           = d.GetChars(socketData.DataBuffer, 0, iRx, chars, 0);

                System.String szData = new System.String(chars);

                if (DataReceivedByAddress != null)
                {
                    DataReceivedByAddress(szData, ((IPEndPoint)socketData.CurrentSocket.RemoteEndPoint).Address.ToString());

                    ////Czlt-2012-2-24
                    //if (ErrorMessage != null)
                    //{
                    //    ErrorMessage(8033001, "", "[Base_SocketClient:StartClient]", "已连接");
                    //}
                }
            }
            catch (SocketException se)
            {
                if (se.ErrorCode == 10054 && socketData.ErrorShow == false)
                {
                    socketData.ErrorShow = true;

                    //移除
                    if (socketData.CurrentSocket != null)
                    {
                        socketData.CurrentSocket.Close();
                        socketData.CurrentSocket = null;
                    }
                    m_workerSocketList.Remove(socketData);
                    //m_workerSocketList[socketData.m_clientNumber - 1] = null;

                    if (socketData != null && socketData.CurrentSocket != null)
                    {
                        if (ClientConnect != null)
                        {
                            ClientConnect(((IPEndPoint)socketData.CurrentSocket.RemoteEndPoint).Address.ToString(), false);
                        }
                    }

                    try
                    {
                        if (ErrorMessage != null)
                        {
                            ErrorMessage(8033002, se.StackTrace, "[Base_SocketClient:StartClient]", se.Message);
                        }
                    }
                    catch { }
                }
            }
            finally
            {
                if (socketData != null && socketData.CurrentSocket != null)
                {
                    //继续等待数据
                    WaitForData(socketData);
                }
            }
        }