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);
            }
        }

    }

}