C# 做正确的事&；c语言中的快速TCP网络#

我正在尝试实现一个解决方案，在服务计划中，一些工作分配给一些工人。调度本身应该通过自定义的基于tcp的协议进行，因为工人可以在同一台机器上运行，也可以在不同的机器上运行

经过一些研究，我找到了这篇文章。读完后，我发现至少有3种不同的解决方案，每种都有其优缺点

我决定使用Begin-End解决方案，并编写了一个小测试程序来处理它。 我的客户端只是一个简单的程序，它向服务器发送一些数据，然后退出。 这是客户端代码：

class Client
{
    static void Main(string[] args)
    {
        var ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345);
        var s = new Socket(ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
        s.Connect(ep);
        Console.WriteLine("client Startet, socket connected");
        s.Send(Encoding.ASCII.GetBytes("1234"));
        s.Send(Encoding.ASCII.GetBytes("ABCDEFGH"));
        s.Send(Encoding.ASCII.GetBytes("A1B2C3D4E5F6"));
        Console.ReadKey();
        s.Close();
    }
}

我的服务器几乎与提供的示例一样简单：

class Program
{
    static void Main(string[] args)
    {
        var server = new BeginEndTcpServer(8, 1, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345));
        // var server = new ThreadedTcpServer(8, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345));
        //server.ClientConnected += new EventHandler<ClientConnectedEventArgs>(server_ClientConnected);
        server.DataReceived += new EventHandler<DataReceivedEventArgs>(server_DataReceived);
        server.Start();
        Console.WriteLine("Server Started");
        Console.ReadKey();
    }

    static void server_DataReceived(object sender, DataReceivedEventArgs e)
    {
        Console.WriteLine("Receveived Data: " + Encoding.ASCII.GetString(e.Data));
    }
}


using System;
using System.Collections.Generic;
using System.Net; 
using System.Net.Sockets;

namespace TcpServerTest
{
public sealed class BeginEndTcpServer
{
    private class Connection
    {
        public Guid id;
        public byte[] buffer;
        public Socket socket;
    }

    private readonly Dictionary<Guid, Connection> _sockets;
    private Socket _serverSocket;
    private readonly int _bufferSize;
    private readonly int _backlog;
    private readonly IPEndPoint serverEndPoint;

    public BeginEndTcpServer(int bufferSize, int backlog, IPEndPoint endpoint)
    {
        _sockets = new Dictionary<Guid, Connection>();
        serverEndPoint = endpoint;
        _bufferSize = bufferSize;
        _backlog = backlog;
    }

    public bool Start()
    {
        //System.Net.IPHostEntry localhost = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName());
        try
        {
            _serverSocket = new Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
        }
        catch (System.Net.Sockets.SocketException e)
        {
            throw new ApplicationException("Could not create socket, check to make sure not duplicating port", e);
        }
        try
        {
            _serverSocket.Bind(serverEndPoint);
            _serverSocket.Listen(_backlog);
        }
        catch (Exception e)
        {
            throw new ApplicationException("Error occured while binding socket, check inner exception", e);
        }
        try
        {
            //warning, only call this once, this is a bug in .net 2.0 that breaks if 
            // you're running multiple asynch accepts, this bug may be fixed, but
            // it was a major pain in the ass previously, so make sure there is only one
            //BeginAccept running
            _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
        catch (Exception e)
        {
            throw new ApplicationException("Error occured starting listeners, check inner exception", e);
        }
        return true;
    }

    public void Stop()
    {
        _serverSocket.Close();
        lock (_sockets)
            foreach (var s in _sockets)
                s.Value.socket.Close();
    }

    private void AcceptCallback(IAsyncResult result)
    {
        Connection conn = new Connection();
        try
        {
            //Finish accepting the connection
            System.Net.Sockets.Socket s = (System.Net.Sockets.Socket)result.AsyncState;
            conn = new Connection();
            conn.id = Guid.NewGuid();
            conn.socket = s.EndAccept(result);
            conn.buffer = new byte[_bufferSize];
            lock (_sockets)
                _sockets.Add(conn.id, conn);
            OnClientConnected(conn.id);
            //Queue recieving of data from the connection
            conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
            //Queue the accept of the next incomming connection
            _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
        catch (SocketException)
        {
            if (conn.socket != null)
            {
                conn.socket.Close();
                lock (_sockets)
                    _sockets.Remove(conn.id);
            }
            //Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
            _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
        catch (Exception)
        {
            if (conn.socket != null)
            {
                conn.socket.Close();
                lock (_sockets)
                    _sockets.Remove(conn.id);
            }
            //Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
            _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
        }
    }

    private void ReceiveCallback(IAsyncResult result)
    {
        //get our connection from the callback
        Connection conn = (Connection)result.AsyncState;
        //catch any errors, we'd better not have any
        try
        {
            //Grab our buffer and count the number of bytes receives
            int bytesRead = conn.socket.EndReceive(result);
            //make sure we've read something, if we haven't it supposadly means that the client disconnected
            if (bytesRead > 0)
            {
                //put whatever you want to do when you receive data here
                conn.socket.Receive(conn.buffer);
                OnDataReceived(conn.id, (byte[])conn.buffer.Clone());
                //Queue the next receive
                conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
            }
            else
            {
                //Callback run but no data, close the connection
                //supposadly means a disconnect
                //and we still have to close the socket, even though we throw the event later
                conn.socket.Close();
                lock (_sockets)
                    _sockets.Remove(conn.id);
            }
        }
        catch (SocketException)
        {
            //Something went terribly wrong
            //which shouldn't have happened
            if (conn.socket != null)
            {
                conn.socket.Close();
                lock (_sockets)
                    _sockets.Remove(conn.id);
            }
        }
    }

    public bool Send(byte[] message, Guid connectionId)
    {
        Connection conn = null;
        lock (_sockets)
            if (_sockets.ContainsKey(connectionId))
                conn = _sockets[connectionId];
        if (conn != null && conn.socket.Connected)
        {
            lock (conn.socket)
            {
                //we use a blocking mode send, no async on the outgoing
                //since this is primarily a multithreaded application, shouldn't cause problems to send in blocking mode
                conn.socket.Send(message, message.Length, SocketFlags.None);
            }
        }
        else
            return false;
        return true;
    }

    public event EventHandler<ClientConnectedEventArgs> ClientConnected;
    private void OnClientConnected(Guid id)
    {
        if (ClientConnected != null)
            ClientConnected(this, new ClientConnectedEventArgs(id));
    }

    public event EventHandler<DataReceivedEventArgs> DataReceived;
    private void OnDataReceived(Guid id, byte[] data)
    {
        if (DataReceived != null)
            DataReceived(this, new DataReceivedEventArgs(id, data));
    }

    public event EventHandler<ConnectionErrorEventArgs> ConnectionError;

}

public class ClientConnectedEventArgs : EventArgs
{
    private readonly Guid _ConnectionId;
    public Guid ConnectionId { get { return _ConnectionId; } }

    public ClientConnectedEventArgs(Guid id)
    {
        _ConnectionId = id;
    }
}

public class DataReceivedEventArgs : EventArgs
{
    private readonly Guid _ConnectionId;
    public Guid ConnectionId { get { return _ConnectionId; } }

    private readonly byte[] _Data;
    public byte[] Data { get { return _Data; } }

    public DataReceivedEventArgs(Guid id, byte[] data)
    {
        _ConnectionId = id;
        _Data = data;
    }
}

public class ConnectionErrorEventArgs : EventArgs
{
    private readonly Guid _ConnectionId;
    public Guid ConnectionId { get { return _ConnectionId; } }

    private readonly Exception _Error;
    public Exception Error { get { return _Error; } }

    public ConnectionErrorEventArgs(Guid id, Exception ex)
    {
        _ConnectionId = id;
        _Error = ex;
    }
}

类程序
{
静态void Main（字符串[]参数）
{
var server=new beginedtcpserver（8,1，new IPEndPoint（IPAddress.Parse（“127.0.0.1”），12345））；
//var server=newthreadedtcserver（8，newipendpoint（IPAddress.Parse（“127.0.0.1”），12345））；
//server.ClientConnected+=新事件处理程序（server\u ClientConnected）；
server.DataReceived+=新事件处理程序（server_DataReceived）；
server.Start（）；
Console.WriteLine（“服务器已启动”）；
Console.ReadKey（）；
}
静态无效服务器\u DataReceived（对象发送方，DataReceivedEventArgs e）
{
WriteLine（“接收到的数据：+Encoding.ASCII.GetString（e.Data））；
}
}
使用制度；
使用System.Collections.Generic；
Net系统；
使用System.Net.Sockets；
命名空间TcpServerTest
{
公共密封类BeginEndTCServer
{
私有类连接
{
公共Guid id；
公共字节[]缓冲区；
公共插座；
}
专用只读字典_套接字；
专用套接字_serverSocket；
私有只读int_bufferSize；
私有只读int_积压；
专用只读IPEndPoint serverEndPoint；
公共BeginEndCpserver（int bufferSize、int backlog、IPEndPoint端点）
{
_套接字=新字典（）；
serverEndPoint=endpoint；
_缓冲大小=缓冲大小；
_积压=积压；
}
公共bool Start（）
{
//System.Net.IPHostEntry localhost=System.Net.Dns.GetHostEntry（System.Net.Dns.GetHostName（））；
尝试
{
_serverSocket=新套接字（serverEndPoint.Address.AddressFamily，SocketType.Stream，ProtocolType.Tcp）；
}
catch（System.Net.Sockets.SocketException e）
{
抛出新的ApplicationException（“无法创建套接字，请检查以确保不复制端口”，e）；
}
尝试
{
_绑定（serverEndPoint）；
_监听（_backlog）；
}
捕获（例外e）
{
抛出新的ApplicationException（“绑定套接字时出错，请检查内部异常”，e）；
}
尝试
{
//警告，只调用一次，这是.NET2.0中的一个bug，如果
//您正在运行多个异步接受，此错误可能已修复，但是
//这是一个很大的痛苦在驴之前，所以要确保只有一个
//开始接受跑步
_beginacept（新的异步回调（AcceptCallback），\u serverSocket）；
}
捕获（例外e）
{
抛出新的ApplicationException（“启动侦听器时出错，请检查内部异常”，e）；
}
返回true；
}
公共停车场（）
{
_serverSocket.Close（）；
锁（U插座）
foreach（在_套接字中的变量s）
s、 Value.socket.Close（）；
}
私有void AcceptCallback（IAsyncResult结果）
{
连接连接=新连接（）；
尝试
{
//完成接受连接
System.Net.Sockets.Sockets s=（System.Net.Sockets.Socket）result.AsyncState；
conn=新连接（）；
conn.id=Guid.NewGuid（）；
conn.socket=s.EndAccept（结果）；
conn.buffer=新字节[_bufferSize]；
锁（U插座）
_sockets.Add（conn.id，conn）；
OnClientConnected（conn.id）；
//从连接接收数据的队列
conn.socket.BeginReceive（conn.buffer，0，conn.buffer.Length，SocketFlags.None，新异步回调（ReceiveCallback），conn）；
//排队接受下一个输入连接
_beginacept（新的异步回调（AcceptCallback），\u serverSocket）；
}
捕获（SocketException）
{
如果（连接插座！=null）
{
conn.socket.Close（）；
锁（U插座）
_插座。拆除（连接id）；
}
//排队接受下一个，认为应该在这里，停止基于杀死等待的侦听器的攻击
_beginacept（新的异步回调（AcceptCallback），\u serverSocket）；
}
捕获（例外）
{
如果（连接插座！=null）
{
conn.socket.Close（）；
锁（U插座）
_插座。拆除（连接id）；
}
//排队接受下一个，认为应该在这里，停止基于杀死等待的侦听器的攻击
_beginacept（新的异步回调（AcceptCallback），\u serverSocket）；
}
}
私有void ReceiveCallback（IAsyncResult结果）
{
//从回调获取我们的连接
连接conn=（连接）result.AsyncState；
//如果发现任何错误，我们最好不要有任何错误
尝试
{
//抓取缓冲区并计算接收的字节数
int bytesRead=conn.socket.EndReceive（结果）；
//确保我们已经读过一些东西，如果我们没有读到，它可能意味着客户端断开了连接
如果（字节读取>0）
{
//你想放什么就放什么
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace SocketServer
{
    class Connection
    {
        public Socket Socket { get; private set; }
        public byte[] Buffer { get; private set; }
        public Encoding Encoding { get; private set; }

        public Connection(Socket socket)
        {
            this.Socket = socket;
            this.Buffer = new byte[2048];
            this.Encoding = Encoding.UTF8;
        }

        public void WaitForNextString(AsyncCallback callback)
        {
            this.Socket.BeginReceive(this.Buffer, 0, 4, SocketFlags.None, callback, this);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Connection connection;
            using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
            {
                listener.Bind(new IPEndPoint(IPAddress.Loopback, 6767));
                listener.Listen(1);
                Console.WriteLine("Listening for a connection.  Press any key to end the session.");
                connection = new Connection(listener.Accept());
                Console.WriteLine("Connection established.");
            }

            connection.WaitForNextString(ReceivedString);

            Console.ReadKey();
        }

        static void ReceivedString(IAsyncResult asyncResult)
        {
            Connection connection = (Connection)asyncResult.AsyncState;

            int bytesReceived = connection.Socket.EndReceive(asyncResult);

            if (bytesReceived > 0)
            {
                int length = BitConverter.ToInt32(connection.Buffer, 0);

                byte[] buffer;
                if (length > connection.Buffer.Length)
                    buffer = new byte[length];
                else
                    buffer = connection.Buffer;

                int index = 0;
                int remainingLength = length;
                do
                {
                    bytesReceived = connection.Socket.Receive(buffer, index, remainingLength, SocketFlags.None);
                    index += bytesReceived;
                    remainingLength -= bytesReceived;
                }
                while (bytesReceived > 0 && remainingLength > 0);

                if (remainingLength > 0)
                {
                    Console.WriteLine("Connection was closed before entire string could be received");
                }
                else
                {
                    Console.WriteLine(connection.Encoding.GetString(buffer, 0, length));
                }

                connection.WaitForNextString(ReceivedString);
            }
        }
    }
}

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

namespace SocketClient
{
    class Program
    {
        static void Main(string[] args)
        {
            var encoding = Encoding.UTF8;
            using (var connector = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
            {
                connector.Connect(new IPEndPoint(IPAddress.Loopback, 6767));

                string value;

                value = "1234";
                Console.WriteLine("Press any key to send \"" + value + "\".");
                Console.ReadKey();
                SendString(connector, encoding, value);

                value = "ABCDEFGH";
                Console.WriteLine("Press any key to send \"" + value + "\".");
                Console.ReadKey();
                SendString(connector, encoding, value);

                value = "A1B2C3D4E5F6";
                Console.WriteLine("Press any key to send \"" + value + "\".");
                Console.ReadKey();
                SendString(connector, encoding, value);

                Console.WriteLine("Press any key to exit.");
                Console.ReadKey();

                connector.Close();
            }
        }

        static void SendString(Socket socket, Encoding encoding, string value)
        {
            socket.Send(BitConverter.GetBytes(encoding.GetByteCount(value)));
            socket.Send(encoding.GetBytes(value));
        }
    }
}

        int bytesRead = conn.socket.EndReceive(result);
        if (bytesRead > 0)
        {
            //** The line below reads the next batch of data
            conn.socket.Receive(conn.buffer);

            OnDataReceived(conn.id, (byte[])conn.buffer.Clone());