c#Socket 异步通讯（客户端与服务端）

c#Socket 异步通讯（多个客户端与服务端）

最近公司有个项目，涉及到的通讯对象有点多，就拿其中一个库的通讯来说就用到了3个PLC，这里就涉及了一个服务器与多个客户端之间的通讯了，同时上位机既需要做客户端，也需要做服务端，因为跟PLC之间走的Modbus tcp。

下面直接上代码吧：

客户端

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

namespace Communication.CommType
{
    public class AsynClient
    {
        public  class StateObject
        {
            // 当前客户端的Socket
            public   Socket workSocket = null;
            // 可接收的最大字节数
            public  const int BufferSize = 20200;
            // 接收的数据存储
            public   byte[] buffer = new byte[BufferSize];           
        }
        public static  List<byte> RevBuf;
        public static  bool _BoolRevContent = false;
        public static bool BoolRevContent
        {
            get { return _BoolRevContent; }
            set { _BoolRevContent = value; }
        }
        public static Socket clientT;
        public static bool ConnectServercer(string ip, string port)
        {
            try
            {
                IPAddress IP = IPAddress.Parse(ip);
                IPEndPoint Point = new IPEndPoint(IP, int.Parse(port));
                clientT = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                clientT.BeginConnect(Point, new AsyncCallback(ConnectCallback), clientT);
                //connectDone.WaitOne();
                //byte[] A = new byte[] { 0x00, 0x02, 0x06 };
                //Send(client, A);
                //sendDone.WaitOne();
                Receive(clientT);
                //receiveDone.WaitOne();                
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }
        private static void ConnectCallback(IAsyncResult ar)
        {
            Socket client = (Socket)ar.AsyncState;
            client.EndConnect(ar);
            //connectDone.Set();
        }
        private static  void Receive(Socket client)
        {
            StateObject state = new StateObject();
            state.workSocket = client;
            client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
        }

        public static void ReceiveCallback(IAsyncResult ar)
        {
            StateObject state = (StateObject)ar.AsyncState;
            Socket client = state.workSocket;
            int bytesRead = client.EndReceive(ar);
            //byte[] Conn = state.buffer;
            if (bytesRead > 0)
            {              
                BoolRevContent = true;
                client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
                RevBuf = new List<byte>();
                byte[] ActConn = new byte[bytesRead];
                Buffer.BlockCopy(state.buffer, 0, ActConn, 0, bytesRead);
                RevBuf.AddRange(ActConn);
                BoolRevContent = false;
            }
            else
            {

            }
        }

        public static  bool Send(byte[] data)
        {          
            try
            {
                clientT.BeginSend(data, 0, data.Length, 0, new AsyncCallback(SendCallback), clientT);
                return true;
            }
            catch (Exception ex)
            {
                return false;
            }
        }

        private static  void SendCallback(IAsyncResult ar)
        {
            try
            {
                // Retrieve the socket from the state object.
                Socket client = (Socket)ar.AsyncState;
                // Complete sending the data to the remote device.
                int bytesSent = client.EndSend(ar);
                // Signal that all bytes have been sent.
                //sendDone.Set();
            }
            catch (Exception e)
            {

            }
        }
    }
}

服务端

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

namespace Communication.CommType
{
    public class AsynServer
    {
        public class StateObject
        {
            // Client socket.
            public Socket workSocket = null;
            // Size of receive buffer.
            public const int BufferSize = 22000;
            // Receive buffer.
            public byte[] buffer = new byte[BufferSize];
            // Received data string.
            public StringBuilder sb = new StringBuilder();
        }

        public static string ErrorMsg = string.Empty;
        /// <summary>
        /// public delegate void MyDelegate(string S);
        public delegate void MyDelegate(string S);
        public static event MyDelegate MyEvent = null;
        /// <summary>
        /// 将事件设置成单例模式
        /// </summary>
        public class Singleton
        {
            private static Singleton _instance = null;

            private Singleton()
            {
                MyEvent = null;
            }
            public static Singleton CreateInstance()
            {
                if (_instance == null)
                {
                    _instance = new Singleton();
                }
                return _instance;
            }
        }
        /// </summary>
        public static  byte[] SendBuf = new byte[] { };
        /// <summary>
        /// 接收的字节
        /// </summary>
        public static  List<byte> RevBuf;
        /// <summary>
        /// 当前发送数据的客户端
        /// </summary>
        public static  IPEndPoint _CurrentClient;
        public static  IPEndPoint CurrentClient
        {
            get { return _CurrentClient; }
            set { _CurrentClient = value; }
        }

        /// <summary>
        /// 触发接收消息的委托
        /// </summary>
        public static bool _RevBool = false;
        public static event EventHandler RevBoolChanged = null;
        public static bool RevBool
        {
            get { return _RevBool; }
            set
            {
                if (_RevBool != value)
                {
                    _RevBool = value;
                    if (_RevBool)
                    {
                        RevBoolChanged?.Invoke(0, EventArgs.Empty);
                    }
                }
            }
        }
        /// <summary>
        /// 存储客户端连接Socket
        /// </summary>
        public static  Dictionary<string, Socket> clientConnectionItems = new Dictionary<string, Socket> { };
        /// <summary>
        /// 打开服务器
        /// </summary>
        /// <returns></returns>
        public static  bool OpenServer(string Ip, string Port)
        {
            try
            {
                IPAddress IP = IPAddress.Parse(Ip);
                IPEndPoint Point = new IPEndPoint(IP, int.Parse(Port));
                Socket ServerClient = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                ServerClient.Bind(Point);
                ServerClient.Listen(10);
                ServerClient.BeginAccept(new AsyncCallback(AcceptCallback), ServerClient);
                MyEvent("服务器打开成功");
                //thServer = new Thread(new ThreadStart(RevState));
                //thServer.IsBackground = true;
                //thServer.Start();
                return true;
            }
            catch (Exception ex)
            {
                ErrorMsg = ex.Message;
                MyEvent("服务器打开失败:"+ex.Message);
                return false;
            }
        }
        /// <summary>
        /// 连接回调
        /// </summary>
        /// <param name="ar"></param>
        public static  void AcceptCallback(IAsyncResult ar)
        {
            try
            {
                Socket listener = ar.AsyncState as Socket;
                if (listener != null)
                {
                    Socket handler = listener.EndAccept(ar);
                    StateObject state = new StateObject();
                    state.workSocket = handler;
                    IPEndPoint clientipe = (IPEndPoint)handler.RemoteEndPoint;
                    //txt_State.AppendText(clientipe.ToString() + "连上咯" + "\r\n");
                    clientConnectionItems.Add(clientipe.ToString(), handler);
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(RevCallback), state);
                    MyEvent(clientipe.ToString()+"----已连上服务器");
                }
                if (listener != null)
                {
                    listener.BeginAccept(new AsyncCallback(AcceptCallback), listener);
                }
            }
            catch (Exception ex)
            {
                ErrorMsg = ex.Message;
                MyEvent(ErrorMsg);
            }
        }
        /// <summary>
        /// 接收回调
        /// </summary>
        /// <param name="ar"></param>
        public static  void RevCallback(IAsyncResult ar)
        {
            StateObject state = (StateObject)ar.AsyncState;
            //Socket socketClient= ar.AsyncState as Socket;
            Socket handler = state.workSocket;
            if (handler != null)
            {
                IPEndPoint clientipe = (IPEndPoint)handler.RemoteEndPoint;
                try
                {
                    // Read data from the client socket.
                    int bytesRead = handler.EndReceive(ar);
                    if (bytesRead > 0)
                    {
                        byte[] a = new byte[bytesRead]; 
                        RevBuf = new List<byte>();
                        Buffer.BlockCopy(state.buffer, 0, a, 0, bytesRead);
                        RevBuf.AddRange(a);
                        //txt_Rev.AppendText(RevBuf[0].ToString() + "\r\n");
                        CurrentClient = clientipe;
                        //Send(handler, new byte[] { 0x00, 0x01, 0x02 });
                        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(RevCallback), state);
                        RevBool = true;
                        RevBool = false;
                    }
                }
                catch (Exception ex)
                {
                    ErrorMsg = clientipe.ToString() + "退出";
                    MyEvent(clientipe.ToString() + "----退出"+ex.Message);
                    //txt_State.AppendText(clientipe.ToString() + "退出" + ex.Message);                   
                }
            }

        }
        /// <summary>
        /// 发送回复客户端
        /// </summary>
        /// <param name="handle">客户端的Socket</param>
        public static  void Send(Socket handle)
        {
            // Convert the string data to byte data using ASCII encoding.           
            // Begin sending the data to the remote device.
            if (SendBuf.Length != 0)//确保发送的字节长度不为0
            {
                handle.BeginSend(SendBuf, 0, SendBuf.Length, 0, new AsyncCallback(SendCallback), handle);
            }
            else
            {

            }
        }
        /// <summary>
        /// 发送回调
        /// </summary>
        /// <param name="ar"></param>
        private static void SendCallback(IAsyncResult ar)
        {
            Socket handler = (Socket)ar.AsyncState;
            int bytesSent = handler.EndSend(ar);
            //handler.Shutdown(SocketShutdown.Both);
            //handler.Close();
        }
    }
}

这两个端都是经过实际测试的，PLC都是用的1200的。

我做的策略是打开服务端的同时连接3个PLC，代码中有几个地方加入了委托，这个的话是根据我实际需求加的，有用到这个代码的朋友不需要委托可以直接去掉就好了。不影响的话在调用此方法的时候记得把委托加入到队列中，否则会报错。

说明：文中有个地方我是把委托 设置成单例模式的，不设置的话会报“未将事例引用到对象的实例”。具体缘由没弄明白。加上单例模式后 就没有报错了。有知道的大佬给小弟解惑解惑。