SocketClient

最新推荐文章于 2022-07-07 17:13:45 发布
最新推荐文章于 2022-07-07 17:13:45 发布
阅读量2k 收藏
点赞数
文章标签： byte exception thread string socket null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lhsxsh/article/details/2503262
版权

using System;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Xml;


namespace COMM
{
    public class ThreadWithPara
    {
        private event Global.EvtSocketClientReceiveMsg onMyDelegate;   //指向事件处理代码的指针
        private string myrevString;

        public ThreadWithPara(string str, Global.EvtSocketClientReceiveMsg MyDelegate)
        {
            myrevString = str;
            onMyDelegate = MyDelegate;
        }


        public void ThreadProc()
        {
            if (onMyDelegate != null)
            {
                onMyDelegate(myrevString);  //----------------------------------------------------------------事件
            }
        }


    }


    //--------------------------------------------------

    public class SocketClient
    {

        log4net.ILog Log = log4net.LogManager.GetLogger("SocketLog");   ///SocketClient通信收发包的操作类   保存到文本文件
        private bool appClose = false;

        public bool AppClose
        {
            get { return appClose; }
            set { appClose = value; }
        }

        private System.Timers.Timer myTime;

        public event Global.EvtSocketClientReceiveMsg onMyDelegate;   //指向事件处理代码的指针

        private Thread thread;//接收数据的线程

        private const int DataBufferSize = 1024 * 50;            // Size of receive buffer.
        private int DataBufferSizeLast = 0;                     //最后一留下来的数据总长度

        private const int DataHeadLen = 5;                //包头长度          
        private const int APIVersion = 1;                 //版本号

        private byte[] DataBuffer = new byte[DataBufferSize];  // Receive buffer. 
        private byte[] DataBufferLast;//= new byte[DataBufferSize];  // Receive buffer.

        private Socket Clientsock;

        private int iport = 8888;
        private string sIP = "172.0.0.1";


        public bool ConnectFlag = true;
        public int ConnectCount = 0;
        //------------------------------

        public SocketClient()
        {
            myTime = new System.Timers.Timer();
            myTime.Interval = 5000;
            myTime.Elapsed += new System.Timers.ElapsedEventHandler(this.Check_State);
            myTime.Enabled = true;
        }


        public SocketClient(string IP, int port, int interval)
        {
            myTime = new System.Timers.Timer();
            myTime.Interval = interval;
            myTime.Elapsed += new System.Timers.ElapsedEventHandler(this.Check_State);
            myTime.Enabled = true;

            iport = port;
            sIP = IP;
        }


        public void Connect(string IP, int port)
        {
            try
            {
                iport = port;
                sIP = IP;
                IPAddress myIPAddress = IPAddress.Parse(sIP);
                IPEndPoint myIPEndPoint = new IPEndPoint(myIPAddress, iport);//把ip和端口转化为IPEndPoint实例
                Clientsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//创建一个Socket                  
                Clientsock.Connect(myIPEndPoint);//连接到服务器 
                thread = new Thread(new ThreadStart(receiveThread));
                thread.Start();
                ConnectFlag = true;
                ConnectCount = 0;
            }
            catch (SocketException ex)
            {
                Log.Info("Connect：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex)
            {
                Log.Info("Connect：" + ex.Message);
                try
                {
                    ConnectFlag = false;
                    if (Clientsock.Connected == true)
                    {
                        Clientsock.Shutdown(SocketShutdown.Both);
                        Clientsock.Close();
                    }
                }
                finally { throw ex; }
            }
        }


        public void Connect()
        {
            try
            {
                IPAddress myIPAddress = IPAddress.Parse(sIP);
                IPEndPoint myIPEndPoint = new IPEndPoint(myIPAddress, iport);//把ip和端口转化为IPEndPoint实例
                Clientsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//创建一个Socket                  
                Clientsock.Connect(myIPEndPoint);//连接到服务器 
                thread = new Thread(new ThreadStart(receiveThread));
                thread.Start();
                ConnectFlag = true;
                if (ConnectCount >= 1)
                {
                    string aa = "<pack><head><ver>2000</ver><oper>8888</oper><gid>76C4B8A42C824EB7B7897B70AF50E6B3</gid><stream>00000000</stream><from>8888</from><to>8888</to></head></pack>";
                    onMyDelegate(aa);
                }
                ConnectCount = 0;
            }
            catch (SocketException ex)
            {
                Log.Info("Connect：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex)
            {
                Log.Info("Connect：" + ex.Message);
                try
                {
                    ConnectFlag = false;
                    if (Clientsock.Connected == true)
                    {
                        Clientsock.Shutdown(SocketShutdown.Both);
                        Clientsock.Close();
                    }
                }
                finally { throw ex; }
            }
        }


        private void receiveThread()
        {
            try
            {
                while (true)
                {
                    byte[] DataBuffer = new byte[DataBufferSize - DataBufferSizeLast];
                    int receivedBytesCount = Clientsock.Receive(DataBuffer, DataBufferSize - DataBufferSizeLast, SocketFlags.None);

                    if (receivedBytesCount == 0)     //如果收到的是0的字节 ，说明网络有问题 (断开)
                    {
                        Log.Info("receivedBytesCount=0 收到网络服务被关闭：");
                        this.Shutdown();
                        return;
                    }

                    int iTempDataBufferSizeLast = 0;
                    byte[] TempBytes = new byte[receivedBytesCount + DataBufferSizeLast];   //receivedBytesCount + DataBufferSizeLast

                    if (DataBufferLast != null)
                    {
                        Buffer.BlockCopy(DataBufferLast, 0, TempBytes, 0, DataBufferSizeLast);
                        iTempDataBufferSizeLast = DataBufferSizeLast;
                        DataBufferLast = null;   //---- 使用完后 为空值
                        DataBufferSizeLast = 0;
                    }
                    Buffer.BlockCopy(DataBuffer, 0, TempBytes, iTempDataBufferSizeLast, receivedBytesCount);
                    EncodingBytes(TempBytes, receivedBytesCount + iTempDataBufferSizeLast);
                }
            }
            catch (SocketException ex)
            {
                Log.Info("receiveThread：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
                this.Shutdown();
            }
            catch (Exception ex)
            {
                Log.Info("receiveThread：" + ex.Message);
                this.Shutdown();
            }

        }

 

        private void EncodingBytes(byte[] Totalbytes, int TotalBytesCount)
        {
           // Thread.Sleep(10000);
            try
            {

                if (Totalbytes.Length <= 5)
                {
                    DataBufferLast = new byte[TotalBytesCount];
                    Buffer.BlockCopy(Totalbytes, 0, DataBufferLast, 0, TotalBytesCount);
                    return;
                }

                byte[] TempHeadBytes = new byte[4];
                Buffer.BlockCopy(Totalbytes, 1, TempHeadBytes, 0, 4);
                int TempPackLen = BitConverter.ToInt32(TempHeadBytes, 0);     //每个包的长度


                if ((TempPackLen + DataHeadLen) > TotalBytesCount)
                {
                    DataBufferSizeLast = TotalBytesCount;
                    DataBufferLast = new byte[TotalBytesCount];
                    Buffer.BlockCopy(Totalbytes, 0, DataBufferLast, 0, TotalBytesCount);
                    return;
                }


                byte[] TempPackBytes = new byte[TempPackLen];
                for (int i = 0; i < TempPackLen; i++)
                {
                    TempPackBytes[i] = Totalbytes[i + DataHeadLen];
                }
                //string receivedStr = System.Text.Encoding.Default.GetString(TempPackBytes);


                if (onMyDelegate != null)
                {
                    --
                    //ThreadWithPara para = new ThreadWithPara(System.Text.Encoding.Default.GetString(TempPackBytes), onMyDelegate);
                    //Thread t = new Thread(new ThreadStart(para.ThreadProc));
                    //t.Start();
                    //t.IsBackground = true;
                    --

                    onMyDelegate(System.Text.Encoding.Default.GetString(TempPackBytes));  //----------------------------------------------------------------事件
                }
                else
                {
                    Log.Info("onMyDelegate事件为空！");
                }


                if (TotalBytesCount > DataHeadLen + TempPackLen)
                {
                    byte[] Bytes = new byte[TotalBytesCount - DataHeadLen - TempPackLen];
                    Buffer.BlockCopy(Totalbytes, DataHeadLen + TempPackLen, Bytes, 0, TotalBytesCount - DataHeadLen - TempPackLen);
                    this.EncodingBytes(Bytes, TotalBytesCount - DataHeadLen - TempPackLen);
                }
            }

            catch (SocketException ex)
            {
                Log.Info("EncodingBytes：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex)
            {
                Log.Info("EncodingBytes：" + ex.Message);
            }
        }

 

        public void CloseSocket()
        {
            try
            {
                if (thread != null)
                {
                    thread.Abort();
                    thread = null;
                }

                if (Clientsock.Connected == true)
                {
                    Clientsock.Shutdown(SocketShutdown.Both);
                    Clientsock.Close();
                }
            }
            catch (SocketException ex)
            {
                Log.Info("CloseSocket：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex)
            {
                Log.Info("CloseSocket：" + ex.Message);
                throw ex;
            }
        }

 

        //public bool SendPack(string Msg)
        //{
        //    try
        //    {
        //        if (Clientsock.Connected == true)
        //        {
        //            byte[] javaPackageBytes = GetSendPack(Msg);
        //            int i = Clientsock.Send(javaPackageBytes, javaPackageBytes.Length, 0);
        //            ConnectFlag = true;
        //            return true;
        //        }
        //        return false;
        //    }
        //    catch
        //    {
        //        this.Shutdown();
        //        return false;
        //    }
        //}


        public void SendPack(string Msg, ref bool SendFlag)
        {
            try
            {

                SendFlag = false; ConnectFlag = false;
                byte[] javaPackageBytes = GetSendPack(Msg);
                int i = Clientsock.Send(javaPackageBytes, javaPackageBytes.Length, 0);

                if ((Clientsock.Connected == true) && (i == javaPackageBytes.Length))
                {
                    ConnectFlag = true;
                    SendFlag = true;
                }

            }
            catch (SocketException ex)
            {
                SendFlag = false; ConnectFlag = false;
                Log.Info("SendPack：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
                this.Shutdown();
            }
            catch (Exception ex)
            {
                SendFlag = false; ConnectFlag = false;
                Log.Info("SendPack：" + ex.Message);
                this.Shutdown();
                throw ex;
            }
        }

 


        private void Shutdown()
        {
            try
            {
                ConnectFlag = false;
                if (Clientsock.Connected == true)
                {
                    Clientsock.Shutdown(SocketShutdown.Both);
                    Clientsock.Close();
                }

                if (thread != null)
                {
                    thread.Abort();
                    thread = null;
                }

            }
            catch (SocketException ex)
            {
                Log.Info("Shutdown：" + ex.Message + ex.ErrorCode.ToString());
            }
            catch (ThreadAbortException ex)
            {
                Log.Info("Shutdown：" + ex.Message);
                thread = null;
            }
            catch (ThreadStateException ex)
            {
                Log.Info("Shutdown：" + ex.Message);
            }
            catch (Exception ex)
            {
                Log.Info("Shutdown：" + ex.Message);
            }
            finally
            {
                ConnectFlag = false;
                if (Clientsock.Connected == true)
                {
                    Clientsock.Shutdown(SocketShutdown.Both);
                    Clientsock.Close();
                }
            }


        }

        private byte[] GetSendPack(string SendMsg)
        {
            byte[] BytesVer = Encoding.Default.GetBytes(APIVersion.ToString());      //版本长度    

            byte[] Bytes = Encoding.Default.GetBytes(SendMsg);     //发送内容总长度 

            byte[] javaPackageBytes = new Byte[Bytes.Length + DataHeadLen];    // 包总长度

            byte[] b4 = Java_Int32ToBytes((UInt32)(Bytes.Length));

            BytesVer.CopyTo(javaPackageBytes, 0);

            b4.CopyTo(javaPackageBytes, 1);

            Bytes.CopyTo(javaPackageBytes, DataHeadLen);
            return javaPackageBytes;

        }

 

        // 4字节整型 --> 字节数组(Java队列用的序,低位在前，高位在后)
        private byte[] Java_Int32ToBytes(UInt32 i)
        {
            byte[] bytes = new byte[4];
            bytes[0] = (byte)(i % 256);
            bytes[1] = (byte)(i / 256);
            bytes[2] = (byte)(i / (65536));
            bytes[3] = (byte)(i / (16777216));
            return bytes;
        }

 

 

        private void Check_State(object sender, System.Timers.ElapsedEventArgs e)   //程序自动重联处理
        {
            try
            {
                if ((ConnectFlag == false) && (Clientsock.Connected == false))
                {
                    ConnectCount += 1;
                    this.Connect();
                }
            }
            catch (SocketException ex)
            {
                Log.Info("Check_State：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex) //
            {
                Log.Info("Check_State：" + ex.Message);
            }
        }
    }

}


/* public class SocketClient
    {

        log4net.ILog Log = log4net.LogManager.GetLogger("SocketLog");   ///SocketClient通信收发包的操作类   保存到文本文件
        private bool appClose = false;

        public bool AppClose
        {
            get { return appClose; }
            set { appClose = value; }
        }

        private System.Timers.Timer myTime;

        public event Global.EvtSocketClientReceiveMsg onMyDelegate;   //指向事件处理代码的指针

        private Thread thread;//接收数据的线程

        private const int DataBufferSize = 1024 * 50;            // Size of receive buffer.
        private int DataBufferSizeLast = 0;                     //最后一留下来的数据总长度

        private const int DataHeadLen = 5;                //包头长度          
        private const int APIVersion = 1;                 //版本号

        private byte[] DataBuffer = new byte[DataBufferSize];  // Receive buffer. 
        private byte[] DataBufferLast;//= new byte[DataBufferSize];  // Receive buffer.

        private Socket Clientsock;

        private int iport = 8888;
        private string sIP = "172.0.0.1";


        public bool ConnectFlag = true;
        public int ConnectCount = 0;
        //------------------------------

        public SocketClient()
        {
            myTime = new System.Timers.Timer();
            myTime.Interval = 5000;
            myTime.Elapsed += new System.Timers.ElapsedEventHandler(this.Check_State);
            myTime.Enabled = true;
        }


        public SocketClient(string IP, int port, int interval)
        {
            myTime = new System.Timers.Timer();
            myTime.Interval = interval;
            myTime.Elapsed += new System.Timers.ElapsedEventHandler(this.Check_State);
            myTime.Enabled = true;

            iport = port;
            sIP = IP;
        }


        public void Connect(string IP, int port)
        {
            try
            {
                iport = port;
                sIP = IP;
                IPAddress myIPAddress = IPAddress.Parse(sIP);
                IPEndPoint myIPEndPoint = new IPEndPoint(myIPAddress, iport);//把ip和端口转化为IPEndPoint实例
                Clientsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//创建一个Socket                  
                Clientsock.Connect(myIPEndPoint);//连接到服务器 
                thread = new Thread(new ThreadStart(receiveThread));
                thread.Start();
                ConnectFlag = true;
                ConnectCount = 0;
            }
            catch (SocketException ex)
            {
                Log.Info("Connect：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex)
            {
                Log.Info("Connect：" + ex.Message);
                try
                {
                    ConnectFlag = false;
                    if (Clientsock.Connected == true)
                    {
                        Clientsock.Shutdown(SocketShutdown.Both);
                        Clientsock.Close();
                    }
                }
                finally { throw ex; }
            }
        }


        public void Connect()
        {
            try
            {
                IPAddress myIPAddress = IPAddress.Parse(sIP);
                IPEndPoint myIPEndPoint = new IPEndPoint(myIPAddress, iport);//把ip和端口转化为IPEndPoint实例
                Clientsock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//创建一个Socket                  
                Clientsock.Connect(myIPEndPoint);//连接到服务器 
                thread = new Thread(new ThreadStart(receiveThread));
                thread.Start();
                ConnectFlag = true;
                if (ConnectCount >= 1)
                {
                    string aa = "<pack><head><ver>2000</ver><oper>8888</oper><gid>76C4B8A42C824EB7B7897B70AF50E6B3</gid><stream>00000000</stream><from>8888</from><to>8888</to></head></pack>";
                    onMyDelegate(aa);
                }
                ConnectCount = 0;
            }
            catch (SocketException ex)
            {
                Log.Info("Connect：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex)
            {
                Log.Info("Connect：" + ex.Message);
                try
                {
                    ConnectFlag = false;
                    if (Clientsock.Connected == true)
                    {
                        Clientsock.Shutdown(SocketShutdown.Both);
                        Clientsock.Close();
                    }
                }
                finally { throw ex; }
            }
        }


        private void receiveThread()
        {
            try
            {
                while (true)
                {
                    byte[] DataBuffer = new byte[DataBufferSize - DataBufferSizeLast];
                    int receivedBytesCount = Clientsock.Receive(DataBuffer, DataBufferSize - DataBufferSizeLast, SocketFlags.None);

                    if (receivedBytesCount == 0)     //如果收到的是0的字节 ，说明网络有问题 (断开)
                    {
                        Log.Info("receivedBytesCount=0 收到网络服务被关闭：");
                        this.Shutdown();
                        return;
                    }

                    int iTempDataBufferSizeLast = 0;
                    byte[] TempBytes = new byte[receivedBytesCount + DataBufferSizeLast];   //receivedBytesCount + DataBufferSizeLast

                    if (DataBufferLast != null)
                    {
                        Buffer.BlockCopy(DataBufferLast, 0, TempBytes, 0, DataBufferSizeLast);
                        iTempDataBufferSizeLast = DataBufferSizeLast;
                        DataBufferLast = null;   //---- 使用完后 为空值
                        DataBufferSizeLast = 0;
                    }
                    Buffer.BlockCopy(DataBuffer, 0, TempBytes, iTempDataBufferSizeLast, receivedBytesCount);
                    EncodingBytes(TempBytes, receivedBytesCount + iTempDataBufferSizeLast);
                }
            }
            catch (SocketException ex)
            {
                Log.Info("receiveThread：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
                this.Shutdown();
            }
            catch (Exception ex)
            {
                Log.Info("receiveThread：" + ex.Message);
                this.Shutdown();
            }

        }

 

        private void EncodingBytes(byte[] Totalbytes, int TotalBytesCount)
        {
            try
            {

                if (Totalbytes.Length <= 5)
                {
                    DataBufferLast = new byte[TotalBytesCount];
                    Buffer.BlockCopy(Totalbytes, 0, DataBufferLast, 0, TotalBytesCount);
                    return;
                }

                byte[] TempHeadBytes = new byte[4];
                Buffer.BlockCopy(Totalbytes, 1, TempHeadBytes, 0, 4);
                int TempPackLen = BitConverter.ToInt32(TempHeadBytes, 0);     //每个包的长度


                if ((TempPackLen + DataHeadLen) > TotalBytesCount)
                {
                    DataBufferSizeLast = TotalBytesCount;
                    DataBufferLast = new byte[TotalBytesCount];
                    Buffer.BlockCopy(Totalbytes, 0, DataBufferLast, 0, TotalBytesCount);
                    return;
                }


                byte[] TempPackBytes = new byte[TempPackLen];
                for (int i = 0; i < TempPackLen; i++)
                {
                    TempPackBytes[i] = Totalbytes[i + DataHeadLen];
                }
                string receivedStr = System.Text.Encoding.Default.GetString(TempPackBytes);

                if (onMyDelegate != null)
                {
                    onMyDelegate(receivedStr);  //----------------------------------------------------------------事件
                }

                if (TotalBytesCount > DataHeadLen + TempPackLen)
                {
                    byte[] Bytes = new byte[TotalBytesCount - DataHeadLen - TempPackLen];
                    Buffer.BlockCopy(Totalbytes, DataHeadLen + TempPackLen, Bytes, 0, TotalBytesCount - DataHeadLen - TempPackLen);
                    this.EncodingBytes(Bytes, TotalBytesCount - DataHeadLen - TempPackLen);
                }
            }

            catch (SocketException ex)
            {
                Log.Info("EncodingBytes：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex)
            {
                Log.Info("EncodingBytes：" + ex.Message);
            }
        }

 

        public void CloseSocket()
        {
            try
            {
                if (thread != null)
                {
                    thread.Abort();
                    thread = null;
                }

                if (Clientsock.Connected == true)
                {
                    Clientsock.Shutdown(SocketShutdown.Both);
                    Clientsock.Close();
                }
            }
            catch (SocketException ex)
            {
                Log.Info("CloseSocket：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex)
            {
                Log.Info("CloseSocket：" + ex.Message);
                throw ex;
            }
        }

 

        //public bool SendPack(string Msg)
        //{
        //    try
        //    {
        //        if (Clientsock.Connected == true)
        //        {
        //            byte[] javaPackageBytes = GetSendPack(Msg);
        //            int i = Clientsock.Send(javaPackageBytes, javaPackageBytes.Length, 0);
        //            ConnectFlag = true;
        //            return true;
        //        }
        //        return false;
        //    }
        //    catch
        //    {
        //        this.Shutdown();
        //        return false;
        //    }
        //}


        public void SendPack(string Msg, ref bool SendFlag)
        {
            try
            {

                SendFlag = false; ConnectFlag = false;
                byte[] javaPackageBytes = GetSendPack(Msg);
                int i = Clientsock.Send(javaPackageBytes, javaPackageBytes.Length, 0);

                if ((Clientsock.Connected == true) && (i == javaPackageBytes.Length))
                {
                    ConnectFlag = true;
                    SendFlag = true;                   
                }

            }
            catch (SocketException ex)
            {
                SendFlag = false; ConnectFlag = false;
                Log.Info("SendPack：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
                this.Shutdown();
            }
            catch (Exception ex)
            {
                SendFlag = false; ConnectFlag = false;
                Log.Info("SendPack：" + ex.Message);
                this.Shutdown();
                throw ex;
            }
        }

 


        private void Shutdown()
        {
            try
            {
                ConnectFlag = false;
                if (Clientsock.Connected == true)
                {
                    Clientsock.Shutdown(SocketShutdown.Both);
                    Clientsock.Close();
                }

                if (thread != null)
                {
                    thread.Abort();
                    thread = null;
                }

            }
            catch (SocketException ex)
            {
                Log.Info("Shutdown：" + ex.Message + ex.ErrorCode.ToString());
            }
            catch (ThreadAbortException ex)
            {
                Log.Info("Shutdown：" + ex.Message);
                thread = null;
            }
            catch (ThreadStateException ex)
            {
                Log.Info("Shutdown：" + ex.Message);
            }
            catch (Exception ex)
            {
                Log.Info("Shutdown：" + ex.Message);
            }
            finally
            {
                ConnectFlag = false;
                if (Clientsock.Connected == true)
                {
                    Clientsock.Shutdown(SocketShutdown.Both);
                    Clientsock.Close();
                }
            }


        }

        private byte[] GetSendPack(string SendMsg)
        {
            byte[] BytesVer = Encoding.Default.GetBytes(APIVersion.ToString());      //版本长度    

            byte[] Bytes = Encoding.Default.GetBytes(SendMsg);     //发送内容总长度 

            byte[] javaPackageBytes = new Byte[Bytes.Length + DataHeadLen];    // 包总长度

            byte[] b4 = Java_Int32ToBytes((UInt32)(Bytes.Length));

            BytesVer.CopyTo(javaPackageBytes, 0);

            b4.CopyTo(javaPackageBytes, 1);

            Bytes.CopyTo(javaPackageBytes, DataHeadLen);
            return javaPackageBytes;

        }

 

        // 4字节整型 --> 字节数组(Java队列用的序,低位在前，高位在后)
        private byte[] Java_Int32ToBytes(UInt32 i)
        {
            byte[] bytes = new byte[4];
            bytes[0] = (byte)(i % 256);
            bytes[1] = (byte)(i / 256);
            bytes[2] = (byte)(i / (65536));
            bytes[3] = (byte)(i / (16777216));
            return bytes;
        }

 

 

        private void Check_State(object sender, System.Timers.ElapsedEventArgs e)   //程序自动重联处理
        {
            try
            {
                if ((ConnectFlag == false) && (Clientsock.Connected == false))
                {
                    ConnectCount += 1;
                    this.Connect();
                }
            }
            catch (SocketException ex)
            {
                Log.Info("Check_State：" + ex.Message + "ErrorCode：" + ex.ErrorCode.ToString());
            }
            catch (Exception ex) //
            {
                Log.Info("Check_State：" + ex.Message);
            }
        }

 

        //---------------------------------------------------------------------------------------------------------------
    }*/

lhsxsh
关注
Socket Client
04-24
用IOS AsyncSocket编码ios设备间进行网络通信，客户端代码
Java Socket client端
月小升的CSDN专栏
11-20 571
之前写过一个Server Socket端。今天特意写了个client端。 java Socket 多线程Server端 两个结合起来，可以组成一个即时通讯的雏形。 package com.javaer.examples.socket; import java.io.BufferedReader; import java.io.IOException; import java.io
Socket Client
编程资料大全
03-12 183
using System;using System.IO;using System.ComponentModel;using System.Collections;using System.Diagnostics;using System.Net;using System.Net.Sockets;using System.Threading; namespace MyKJ...{ /**////...
socket-client
weixin_30855099的博客
10-22 1172
#!\usr\bin\env\python # -*- coding:utf-8 -*9 import socket #导入模块 client=socket.socket() #声明socket类型，同时生成socket连接对象 client.connect=(('localhost',6969)) #连接端口 while True: msg=inpu...
Android开发，Socket Client端和Socket Server端数据发送和接收
最新发布
09-06
Socket分为客户端（Socket Client）和服务器端（Socket Server），它们共同构成了基于TCP/IP协议的通信模型。本篇文章将详细探讨Android环境下如何进行Socket Client端和Socket Server端的数据发送与接收。 1. **...
SocketClient:SocketClient C ++
03-17
SocketClient在C++中的实现是网络编程中一个基础且重要的概念。它允许程序作为客户端与服务器进行通信，通过TCP或UDP协议发送和接收数据。在本文中，我们将深入探讨SocketClient在C++中的使用，包括基本原理、创建...
Socket Client 测试工具
03-27
例如，`SocketClient`文件可能是工具的主程序，包含了连接、发送、接收和断开连接等功能的实现。通过分析源码，我们可以学习到Socket编程的实践技巧，如何编写健壮的网络应用，以及如何调试网络通信问题。 在实际...
SocketClient.cs_socket_
09-29
SocketClient.cs 文件是一个C#编写的Socket客户端程序实例，它展示了如何使用.NET Framework中的System.Net.Sockets命名空间来实现网络通信。Socket是TCP/IP协议栈的一部分，用于在不同计算机之间建立低级别的连接，...
socket server关闭时导致socket client也关闭 的原因及解决办法
12-16
当Socket Server（服务端）关闭时，通常会导致与之相连的Socket Client（客户端）也关闭，这是因为TCP连接是全双工的，即数据可以双向传输。当一方关闭连接，另一方在尝试发送或接收数据时会检测到连接已断开，从而...
socketClient
09-26
最基本的socket客户端工具，用来进行网络编程时对服务器软件测试.自己工作时使用，大家就别下载了。
SocketClient实现简单服务端与客户端通信
06-23
利用Socket编程，http通信,httpClient，等技术实现简单的客户端与服务器端的通信，达到聊天室效果
SOCKET-CLIENT
idifc的博客
07-07 879
SOCKET-CLIENT
Socket:client
goushaoping04的专栏
09-18 728
package comm;/** * @docRoot:socket客户端程序 * @author:jingshaoping * @date:2007-9-17 */import javax.swing.*;import java.net.*;import java.io.*;import java.awt.*;import java.awt.event.*;public class Client
socketclient库
07-27
SocketClient 是一个用于在 Python 中创建和管理 Socket 连接的库。它提供了一组简单易用的函数和类，使得在客户端与服务器之间进行通信变得更加方便。 你可以使用 SocketClient 来建立与远程服务器的连接，并发送...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值