关于socket通讯的server类(C#)

左手的ㄟ右手 2022-07-14 14:24 234阅读 0赞

最近项目完结，翻看之前的代码，发现了一些比较好的代码，贴出来给大家分享。有关于Socket通讯![偷笑][titter.gif]

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading;
    
    namespace Core.Sockets
    {
    
        // Implements the connection logic for the socket server.  
        // After accepting a connection, all data read from the client 
        // is sent back to the client. The read and echo back to the client pattern 
        // is continued until the client disconnects.
        public class Server
        {
            private int m_numConnections;   // the maximum number of connections the sample is designed to handle simultaneously 
            private int m_receiveBufferSize;// buffer size to use for each socket I/O operation 
            BufferManager m_bufferManager;  // represents a large reusable set of buffers for all socket operations
            const int opsToPreAlloc = 2;    // read, write (don't alloc buffer space for accepts)
            Socket listenSocket;            // the socket used to listen for incoming connection requests
            // pool of reusable SocketAsyncEventArgs objects for write, read and accept socket operations
            protected SocketAsyncEventArgsPool m_readWritePool;
            int m_totalBytesRead;           // counter of the total # bytes received by the server
            int m_numConnectedSockets;      // the total number of clients connected to the server 
            Semaphore m_maxNumberAcceptedClients;
    
            // Create an uninitialized server instance.  
            // To start the server listening for connection requests
            // call the Init method followed by Start method 
            //
            // <param name="numConnections">the maximum number of connections the sample is designed to handle simultaneously</param>
            // <param name="receiveBufferSize">buffer size to use for each socket I/O operation</param>
            public Server(int numConnections, int receiveBufferSize)
            {
                m_totalBytesRead = 0;
                m_numConnectedSockets = 0;
                m_numConnections = numConnections;
                m_receiveBufferSize = receiveBufferSize;
                // allocate buffers such that the maximum number of sockets can have one outstanding read and 
                //write posted to the socket simultaneously  
                m_bufferManager = new BufferManager(receiveBufferSize * numConnections * opsToPreAlloc,
                    receiveBufferSize);
    
                m_readWritePool = new SocketAsyncEventArgsPool(numConnections);
                m_maxNumberAcceptedClients = new Semaphore(numConnections, numConnections);
            }
    
            // Initializes the server by preallocating reusable buffers and 
            // context objects.  These objects do not need to be preallocated 
            // or reused, but it is done this way to illustrate how the API can 
            // easily be used to create reusable objects to increase server performance.
            //
            public void Init()
            {
                // Allocates one large byte buffer which all I/O operations use a piece of.  This gaurds 
                // against memory fragmentation
                m_bufferManager.InitBuffer();
    
                // preallocate pool of SocketAsyncEventArgs objects
                SocketAsyncEventArgs readWriteEventArg;
    
                for (int i = 0; i < m_numConnections; i++)
                {
                    //Pre-allocate a set of reusable SocketAsyncEventArgs
                    readWriteEventArg = new SocketAsyncEventArgs();
                    readWriteEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(IO_Completed);
                    readWriteEventArg.UserToken = new AsyncUserToken();
    
                    // assign a byte buffer from the buffer pool to the SocketAsyncEventArg object
                    m_bufferManager.SetBuffer(readWriteEventArg);
    
                    // add SocketAsyncEventArg to the pool
                    m_readWritePool.Push(readWriteEventArg);
                }
    
            }
    
            // Starts the server such that it is listening for 
            // incoming connection requests.    
            //
            // <param name="localEndPoint">The endpoint which the server will listening 
            // for connection requests on</param>
            public void Start(IPEndPoint localEndPoint)
            {
                // create the socket which listens for incoming connections
                listenSocket = new Socket(localEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                listenSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
                listenSocket.Bind(localEndPoint);
                // start the server with a listen backlog of 100 connections
                listenSocket.Listen(100);
    
                // post accepts on the listening socket
                StartAccept(null);
            }
    
    
            // Begins an operation to accept a connection request from the client 
            //
            // <param name="acceptEventArg">The context object to use when issuing 
            // the accept operation on the server's listening socket</param>
            public void StartAccept(SocketAsyncEventArgs acceptEventArg)
            {
                if (acceptEventArg == null)
                {
                    acceptEventArg = new SocketAsyncEventArgs();
                    acceptEventArg.Completed += new EventHandler<SocketAsyncEventArgs>(AcceptEventArg_Completed);
                }
                else
                {
                    // socket must be cleared since the context object is being reused
                    acceptEventArg.AcceptSocket = null;
                }
    
                m_maxNumberAcceptedClients.WaitOne();
                try
                {
                    bool willRaiseEvent = listenSocket.AcceptAsync(acceptEventArg);
                    if (!willRaiseEvent)
                    {
                        ProcessAccept(acceptEventArg);
                    }
                }
                catch
                {
    
                }
            }
    
            // This method is the callback method associated with Socket.AcceptAsync 
            // operations and is invoked when an accept operation is complete
            //
            void AcceptEventArg_Completed(object sender, SocketAsyncEventArgs e)
            {
                ProcessAccept(e);
            }
    
            private void ProcessAccept(SocketAsyncEventArgs e)
            {
                Interlocked.Increment(ref m_numConnectedSockets);
    
                // Get the socket for the accepted client connection and put it into the 
                //ReadEventArg object user token
                SocketAsyncEventArgs readEventArgs = m_readWritePool.Pop();
                ((AsyncUserToken)readEventArgs.UserToken).Socket = e.AcceptSocket;
    
                // As soon as the client is connected, post a receive to the connection
                bool willRaiseEvent = e.AcceptSocket.ReceiveAsync(readEventArgs);
                if (!willRaiseEvent)
                {
                    ProcessReceive(readEventArgs);
                }
    
                // Accept the next connection request
                StartAccept(e);
            }
    
            // This method is called whenever a receive or send operation is completed on a socket 
            //
            // <param name="e">SocketAsyncEventArg associated with the completed receive operation</param>
            void IO_Completed(object sender, SocketAsyncEventArgs e)
            {
                // determine which type of operation just completed and call the associated handler
                switch (e.LastOperation)
                {
                    case SocketAsyncOperation.Receive:
                        ProcessReceive(e);
                        break;
                    case SocketAsyncOperation.Send:
                        ProcessSend(e);
                        break;
                    default:
                        throw new ArgumentException("The last operation completed on the socket was not a receive or send");
                }
    
            }
    
            // This method is invoked when an asynchronous receive operation completes. 
            // If the remote host closed the connection, then the socket is closed.  
            // If data was received then the data is echoed back to the client.
            //
            protected virtual void ProcessReceive(SocketAsyncEventArgs e)
            {
                // check if the remote host closed the connection
                AsyncUserToken token = (AsyncUserToken)e.UserToken;
                if (e.BytesTransferred > 0 && e.SocketError == SocketError.Success)
                {
                    //increment the count of the total bytes receive by the server
                    Interlocked.Add(ref m_totalBytesRead, e.BytesTransferred);
    
    
                    //echo the data received back to the client
                    e.SetBuffer(e.Offset, e.BytesTransferred);
                    bool willRaiseEvent = token.Socket.SendAsync(e);
                    if (!willRaiseEvent)
                    {
                        ProcessSend(e);
                    }
    
                }
                else
                {
                    CloseClientSocket(e);
                }
            }
    
            // This method is invoked when an asynchronous send operation completes.  
            // The method issues another receive on the socket to read any additional 
            // data sent from the client
            //
            // <param name="e"></param>
            protected void ProcessSend(SocketAsyncEventArgs e)
            {
                if (e.SocketError == SocketError.Success)
                {
                    // done echoing data back to the client
                    AsyncUserToken token = (AsyncUserToken)e.UserToken;
                    // read the next block of data send from the client
                    bool willRaiseEvent = token.Socket.ReceiveAsync(e);
                    if (!willRaiseEvent)
                    {
                        ProcessReceive(e);
                    }
                }
                else
                {
                    CloseClientSocket(e);
                }
            }
    
            protected void CloseClientSocket(SocketAsyncEventArgs e)
            {
                AsyncUserToken token = e.UserToken as AsyncUserToken;
    
                // close the socket associated with the client
                try
                {
                    token.Socket.Shutdown(SocketShutdown.Send);
                }
                // throws if client process has already closed
                catch (Exception) { }
                token.Socket.Close();
    
                // decrement the counter keeping track of the total number of clients connected to the server
                Interlocked.Decrement(ref m_numConnectedSockets);
                m_maxNumberAcceptedClients.Release();
    
                // Free the SocketAsyncEventArg so they can be reused by another client
                m_readWritePool.Push(e);
            }
    
        }    
    }

[titter.gif]: /images/20220714/959bbcb188dc4cb195c8005128ac930a.png