2021-6-16 TcpIp

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace BatteryDetectWorkA
{
    class SocketClient
    {
        byte[] buffer = new byte[2048];
        Socket socket;
        Thread thread;
        string ip, port;
        public bool connect(string ip, string port)
        {
            bool result = true;
            try
            {
                //实例化socket
                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                //连接服务器
                this.ip = ip; this.port = port;
                socket.Connect(new IPEndPoint(IPAddress.Parse(this.ip), int.Parse(this.port)));

                thread = new Thread(StartReceive);
                thread.IsBackground = true;
                thread.Start(socket);
            }
            catch (Exception ex)
            {
                //SetMessage("连接服务器异常:" + ex.Message);
                result = false;
            }
            return result;
        }

        private void StartReceive(object obj)
        {
            string str;
            while (true)
            {
                Socket receiveSocket = obj as Socket;
                try
                {
                    int result = receiveSocket.Receive(buffer);
                    if (result == 0)
                    {
                        break;
                    }
                    else
                    {
                        str = Encoding.Default.GetString(buffer);

                    }

                }
                catch (Exception ex)
                {
                    //SetMessage("服务器异常:" + ex.Message);

                }
            }

        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public bool close()
        {
            bool result = true;
            try
            {
                socket.Shutdown(SocketShutdown.Both);
                socket.Close();
                socket.Dispose();
                thread.Abort();
                socket = null;
                thread = null;
                GC.Collect();
            }
            catch (Exception ex)
            {
                result = false;
            }
            return result;
        }

        public void send(string str)
        {
            socket.Send(Encoding.Default.GetBytes(str));
        }

        public void sendbytes(byte[] buffer)
        {
            socket.Send(buffer);
        }

        public bool isConnection()
        {

            bool blockingState = socket.Blocking;
            try
            {
                if (!socket.Connected)
                {
                    try
                    {
                        close();
                        connect(this.ip, this.port);
                    }
                    catch (Exception ex)
                    {
                        return false;
                    }
                }
                byte[] tmp = new byte[1];
                socket.Blocking = false;
                socket.Send(tmp, 0, 0);
                socket.Blocking = blockingState;    // 恢复状态
                return true;
            }
            catch (SocketException e)
            {
                //try
                //{
                //   // socket.Close();
                //    socket.Connect(new IPEndPoint(IPAddress.Parse(this.ip), int.Parse(this.port)));
                //}
                //catch(Exception ex) { }
                // 产生 10035 == WSAEWOULDBLOCK 错误，说明被阻止了，但是还是连接的
                //if (e.NativeErrorCode.Equals(10035))
                return false;
                //else
                //    return true;
            }
            //finally
            //{
            //    socket.Blocking = blockingState;    // 恢复状态
            //}

        }

    }

    class SocketServer
    {
        private static Dictionary<string, Socket> socketList = new Dictionary<string, Socket>();
        public SocketServer(string ip, string port)
        {
            try
            {

                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

                IPEndPoint IEP = new IPEndPoint(IPAddress.Parse(ip), int.Parse(port));
                //绑定ip和端口
                socket.Bind(IEP);
                //开启监听
                socket.Listen(20);
                //Logger.WriteLog(ip + ':' + port + "开始监听");

                Thread thread = new Thread(new ParameterizedThreadStart(StartServer));
                thread.IsBackground = true;
                thread.Start(socket);

            }
            catch (Exception ex)
            {
                // Logger.WriteLog(ex.Message.ToString(), ex);

            }
        }

        public void StartServer(object obj)
        {
            string str;
            while (true)
            {
                //等待接收客户端连接 Accept方法返回一个用于和该客户端通信的Socket
                Socket recviceSocket = ((Socket)obj).Accept();
                //获取客户端ip和端口号
                str = recviceSocket.RemoteEndPoint.ToString();
                socketList.Add(str, recviceSocket);
                //Logger.LogOperate.Info(str + "已连接");

                //Accept()执行过后 当前线程会阻塞 只有在有客户端连接时才会继续执行
                //创建新线程,监控接收新客户端的请求数据
                Thread thread = new Thread(startRecive);
                thread.IsBackground = true;
                thread.Start(recviceSocket);
            }
        }

        public void startRecive(object obj)
        {

            while (true)
            {
                try
                {
                    byte[] buffer = new byte[2048];
                    int count = ((Socket)obj).Receive(buffer);
                    if (count == 0) break;
                    string str = Encoding.Default.GetString(buffer, 0, count);
                    string ip = ((Socket)obj).RemoteEndPoint.ToString();

                }
                catch (Exception ex)
                {
                    // Logger.WriteLog(ex.Message.ToString(), ex);

                }
            }
        }
        private void send2Client(string ip, string str)
        {
            byte[] bytes = new byte[2048];
            bytes = Encoding.Default.GetBytes(str);
            if (socketList.ContainsKey(ip))
            {
                Logger.QuiesceThread(new Action(() => {
                    try
                    {
                        socketList[ip].Send(bytes);
                    }
                    catch (Exception ex)
                    { }
                }));
            }

        }

    }

    public class TcpClient
    {

        Socket m_client;

        byte[] buffer = new byte[3072 * 2048];
        bool isOpen = false;
        bool hasClient = false;

        bool check_client()
        {
            try
            {
                if (m_client == null)
                    return false;

                bool isConnect = !(m_client.Poll(1000, SelectMode.SelectRead) && m_client.Available == 0) && m_client.Connected;
                return isConnect;
            }
            catch
            {
                return false;
            }
        }

        void AcceptCallBack(IAsyncResult ar)
        {
            try
            {
                if (check_client())
                {
                    m_client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), m_client);
                    hasClient = true;
                    while (hasClient)
                    {
                        Thread.Sleep(500);
                        if (!check_client())
                        {
                            break;
                        }
                    }
                    hasClient = false;
                    Logger.LogApp.Info("监听到Socket断线");
                }
                if (isOpen)
                    Open();
            }
            catch
            {
            }
        }
        void ReceiveCallBack(IAsyncResult ar)
        {
            try
            {
                var client = ar.AsyncState as Socket;
                int length = client.EndReceive(ar);
                if (length > 0)
                    OnDataRecive?.Invoke(buffer.Take(length).ToArray());

                //接收一下个信息
                client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client);
            }
            catch (Exception ex) { }
        }

        public event Action<byte[]> OnDataRecive;
        string m_ip;
        int m_port;
        public void Open(string ip, int port)
        {
            //
            Close();

            //
            IPEndPoint serverip = new IPEndPoint(IPAddress.Parse(ip), port);
            m_client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            m_client.BeginConnect(serverip, AcceptCallBack, m_client);

            //
            isOpen = true;
            m_ip = ip;
            m_port = port;
        }
        public void Open()
        {
            Open(m_ip, m_port);
        }
        public void Close()
        {
            //
            if (m_client != null)
            {
                if (m_client.Connected)
                    m_client.Shutdown(SocketShutdown.Both);
                m_client.Close();
                m_client = null;
            }

            //
            hasClient = false;
            isOpen = false;
        }
        public bool IsOpen()
        {
            return isOpen;
        }
        public bool IsConnected()
        {
            return hasClient;
        }

        public void Send(byte[] data)
        {
            if (hasClient)
            {
                m_client.Send(data);
            }
        }

        public void Send(string str)
        {
            if (hasClient)
            {
                m_client.Send(Encoding.Default.GetBytes(str));
                Logger.LogApp.Info("A工位通过Socket发送" + str.ToString());
            }
            else
            {
                Logger.LogApp.Info("Socket断线，数据未发送，数据为" + str.ToString());
            }
        }

    }

    class TcpServer
    {

        Socket m_server;
        Socket m_client;

        byte[] buffer = new byte[1024];
        bool isOpen = false;
        bool hasClient = false;

        bool check_client()
        {
            try
            {
                if (m_client == null)
                    return false;

                bool isConnect = !(m_client.Poll(1000, SelectMode.SelectRead) && m_client.Available == 0) && m_client.Connected;
                return isConnect;
            }
            catch
            {
                return false;
            }
        }

        void AcceptCallBack(IAsyncResult ar)
        {
            try
            {
                var server = ar.AsyncState as Socket;
                var client = server.EndAccept(ar);
                m_client = client;
                m_client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), m_client);

                hasClient = true;
                while (true)
                {
                    Thread.Sleep(100);
                    if (!check_client())
                    {
                        if (m_client.Connected)
                            m_client.Shutdown(SocketShutdown.Both);
                        m_client.Close();
                        m_client = null;
                        break;
                    }
                }
                hasClient = false;

                if (m_server != null)
                {
                    m_server.BeginAccept(new AsyncCallback(AcceptCallBack), m_server);
                }
            }
            catch { }
        }
        void ReceiveCallBack(IAsyncResult ar)
        {
            try
            {
                var client = ar.AsyncState as Socket;
                int length = client.EndReceive(ar);
                OnDataRecive?.Invoke(buffer.Take(length).ToArray());

                //接收一下个信息
                client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client);
            }
            catch { }
        }

        public event Action<byte[]> OnDataRecive;

        public void Open(string ip, int port)
        {

            //
            Close();

            //
            IPEndPoint serverip = new IPEndPoint(IPAddress.Parse(ip), port);
            m_server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            m_server.Bind(serverip);
            m_server.Listen(0);
            m_server.BeginAccept(new AsyncCallback(AcceptCallBack), m_server);

            //
            isOpen = true;
        }
        public void Close()
        {

            //
            hasClient = false;
            isOpen = false;

            //
            if (m_server != null)
            {
                if (m_server.Connected)
                    m_server.Shutdown(SocketShutdown.Both);
                m_server.Close();
                m_server = null;
            }

            //
            if (m_client != null)
            {
                if (m_client.Connected)
                    m_client.Shutdown(SocketShutdown.Both);
                m_client.Close();
                m_client = null;
            }

        }
        public bool IsOpen()
        {
            return isOpen;
        }
        public bool IsConnected()
        {
            return hasClient;
        }

        public void Send(byte[] data)
        {
            if (hasClient)
            {
                m_client.Send(data);
            }
        }

    }

}

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;using System.Net.Sockets;using System.Net;using System.Threading;
namespace BatteryDetectWorkA{    class SocketClient    {        byte[] buffer = new byte[2048];        Socket socket;        Thread thread;        string ip, port;        public bool connect(string ip, string port)        {            bool result = true;            try            {                //实例化socket                socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);                //连接服务器                this.ip = ip; this.port = port;                socket.Connect(new IPEndPoint(IPAddress.Parse(this.ip), int.Parse(this.port)));
                thread = new Thread(StartReceive);                thread.IsBackground = true;                thread.Start(socket);            }            catch (Exception ex)            {                //SetMessage("连接服务器异常:" + ex.Message);                result = false;            }            return result;        }
        private void StartReceive(object obj)        {            string str;            while (true)            {                Socket receiveSocket = obj as Socket;                try                {                    int result = receiveSocket.Receive(buffer);                    if (result == 0)                    {                        break;                    }                    else                    {                        str = Encoding.Default.GetString(buffer);
                    }
                }                catch (Exception ex)                {                    //SetMessage("服务器异常:" + ex.Message);
                }            }
        }
        /// <summary>        /// 关闭连接        /// </summary>        /// <param name="sender"></param>        /// <param name="e"></param>        public bool close()        {            bool result = true;            try            {                socket.Shutdown(SocketShutdown.Both);                socket.Close();                socket.Dispose();                thread.Abort();                socket = null;                thread = null;                GC.Collect();            }            catch (Exception ex)            {                result = false;            }            return result;        }
        public void send(string str)        {            socket.Send(Encoding.Default.GetBytes(str));        }
        public void sendbytes(byte[] buffer)        {            socket.Send(buffer);        }
        public bool isConnection()        {
            bool blockingState = socket.Blocking;            try            {                if (!socket.Connected)                {                    try                    {                        close();                        connect(this.ip, this.port);                    }                    catch (Exception ex)                    {                        return false;                    }                }                byte[] tmp = new byte[1];                socket.Blocking = false;                socket.Send(tmp, 0, 0);                socket.Blocking = blockingState;    // 恢复状态                return true;            }            catch (SocketException e)            {                //try                //{                //   // socket.Close();                //    socket.Connect(new IPEndPoint(IPAddress.Parse(this.ip), int.Parse(this.port)));                //}                //catch(Exception ex) { }                // 产生 10035 == WSAEWOULDBLOCK 错误，说明被阻止了，但是还是连接的                //if (e.NativeErrorCode.Equals(10035))                return false;                //else                //    return true;            }            //finally            //{            //    socket.Blocking = blockingState;    // 恢复状态            //}
        }
    }
    class SocketServer    {        private static Dictionary<string, Socket> socketList = new Dictionary<string, Socket>();        public SocketServer(string ip, string port)        {            try            {
                Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                IPEndPoint IEP = new IPEndPoint(IPAddress.Parse(ip), int.Parse(port));                //绑定ip和端口                socket.Bind(IEP);                //开启监听                socket.Listen(20);                //Logger.WriteLog(ip + ':' + port + "开始监听");
                Thread thread = new Thread(new ParameterizedThreadStart(StartServer));                thread.IsBackground = true;                thread.Start(socket);
            }            catch (Exception ex)            {                // Logger.WriteLog(ex.Message.ToString(), ex);
            }        }
        public void StartServer(object obj)        {            string str;            while (true)            {                //等待接收客户端连接 Accept方法返回一个用于和该客户端通信的Socket                Socket recviceSocket = ((Socket)obj).Accept();                //获取客户端ip和端口号                str = recviceSocket.RemoteEndPoint.ToString();                socketList.Add(str, recviceSocket);                //Logger.LogOperate.Info(str + "已连接");
                //Accept()执行过后 当前线程会阻塞 只有在有客户端连接时才会继续执行                //创建新线程,监控接收新客户端的请求数据                Thread thread = new Thread(startRecive);                thread.IsBackground = true;                thread.Start(recviceSocket);            }        }

        public void startRecive(object obj)        {
            while (true)            {                try                {                    byte[] buffer = new byte[2048];                    int count = ((Socket)obj).Receive(buffer);                    if (count == 0) break;                    string str = Encoding.Default.GetString(buffer, 0, count);                    string ip = ((Socket)obj).RemoteEndPoint.ToString();
                }                catch (Exception ex)                {                    // Logger.WriteLog(ex.Message.ToString(), ex);
                }            }        }        private void send2Client(string ip, string str)        {            byte[] bytes = new byte[2048];            bytes = Encoding.Default.GetBytes(str);            if (socketList.ContainsKey(ip))            {                Logger.QuiesceThread(new Action(() => {                    try                    {                        socketList[ip].Send(bytes);                    }                    catch (Exception ex)                    { }                }));            }
        }

    }
    public class TcpClient    {
        Socket m_client;
        byte[] buffer = new byte[3072 * 2048];        bool isOpen = false;        bool hasClient = false;
        bool check_client()        {            try            {                if (m_client == null)                    return false;
                bool isConnect = !(m_client.Poll(1000, SelectMode.SelectRead) && m_client.Available == 0) && m_client.Connected;                return isConnect;            }            catch            {                return false;            }        }
        void AcceptCallBack(IAsyncResult ar)        {            try            {                if (check_client())                {                    m_client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), m_client);                    hasClient = true;                    while (hasClient)                    {                        Thread.Sleep(500);                        if (!check_client())                        {                            break;                        }                    }                    hasClient = false;                    Logger.LogApp.Info("监听到Socket断线");                }                if (isOpen)                    Open();            }            catch            {            }        }        void ReceiveCallBack(IAsyncResult ar)        {            try            {                var client = ar.AsyncState as Socket;                int length = client.EndReceive(ar);                if (length > 0)                    OnDataRecive?.Invoke(buffer.Take(length).ToArray());
                //接收一下个信息                client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client);            }            catch (Exception ex) { }        }
        public event Action<byte[]> OnDataRecive;        string m_ip;        int m_port;        public void Open(string ip, int port)        {            //            Close();
            //            IPEndPoint serverip = new IPEndPoint(IPAddress.Parse(ip), port);            m_client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);            m_client.BeginConnect(serverip, AcceptCallBack, m_client);
            //            isOpen = true;            m_ip = ip;            m_port = port;        }        public void Open()        {            Open(m_ip, m_port);        }        public void Close()        {            //            if (m_client != null)            {                if (m_client.Connected)                    m_client.Shutdown(SocketShutdown.Both);                m_client.Close();                m_client = null;            }
            //            hasClient = false;            isOpen = false;        }        public bool IsOpen()        {            return isOpen;        }        public bool IsConnected()        {            return hasClient;        }
        public void Send(byte[] data)        {            if (hasClient)            {                m_client.Send(data);            }        }
        public void Send(string str)        {            if (hasClient)            {                m_client.Send(Encoding.Default.GetBytes(str));                Logger.LogApp.Info("A工位通过Socket发送" + str.ToString());            }            else            {                Logger.LogApp.Info("Socket断线，数据未发送，数据为" + str.ToString());            }        }
    }

    class TcpServer    {
        Socket m_server;        Socket m_client;
        byte[] buffer = new byte[1024];        bool isOpen = false;        bool hasClient = false;
        bool check_client()        {            try            {                if (m_client == null)                    return false;
                bool isConnect = !(m_client.Poll(1000, SelectMode.SelectRead) && m_client.Available == 0) && m_client.Connected;                return isConnect;            }            catch            {                return false;            }        }
        void AcceptCallBack(IAsyncResult ar)        {            try            {                var server = ar.AsyncState as Socket;                var client = server.EndAccept(ar);                m_client = client;                m_client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), m_client);
                hasClient = true;                while (true)                {                    Thread.Sleep(100);                    if (!check_client())                    {                        if (m_client.Connected)                            m_client.Shutdown(SocketShutdown.Both);                        m_client.Close();                        m_client = null;                        break;                    }                }                hasClient = false;
                if (m_server != null)                {                    m_server.BeginAccept(new AsyncCallback(AcceptCallBack), m_server);                }            }            catch { }        }        void ReceiveCallBack(IAsyncResult ar)        {            try            {                var client = ar.AsyncState as Socket;                int length = client.EndReceive(ar);                OnDataRecive?.Invoke(buffer.Take(length).ToArray());
                //接收一下个信息                client.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallBack), client);            }            catch { }        }
        public event Action<byte[]> OnDataRecive;
        public void Open(string ip, int port)        {
            //            Close();
            //            IPEndPoint serverip = new IPEndPoint(IPAddress.Parse(ip), port);            m_server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);            m_server.Bind(serverip);            m_server.Listen(0);            m_server.BeginAccept(new AsyncCallback(AcceptCallBack), m_server);
            //            isOpen = true;        }        public void Close()        {
            //            hasClient = false;            isOpen = false;
            //            if (m_server != null)            {                if (m_server.Connected)                    m_server.Shutdown(SocketShutdown.Both);                m_server.Close();                m_server = null;            }
            //            if (m_client != null)            {                if (m_client.Connected)                    m_client.Shutdown(SocketShutdown.Both);                m_client.Close();                m_client = null;            }
        }        public bool IsOpen()        {            return isOpen;        }        public bool IsConnected()        {            return hasClient;        }
        public void Send(byte[] data)        {            if (hasClient)            {                m_client.Send(data);            }        }
    }
}