在 c# 中进行正确且快速的 TCP 网络连接
Posted
技术标签:
【中文标题】在 c# 中进行正确且快速的 TCP 网络连接【英文标题】：Do correct & fast TCP-Networking in c# 【发布时间】：2011-12-26 08:03:47 【问题描述】：我正在尝试实施一个解决方案，在该解决方案中，将一些工作安排给多个工人。调度本身应该通过自定义的基于 tcp 的协议进行，因为 Worker 可以在相同或不同的机器上运行。
经过一番研究，我发现了this 的帖子。看完后，我发现至少有 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;
我的问题是：服务器只接收一部分数据（在示例中它只接收'EFGHA1B2'）。此外，如果我只发送 4 字节的数据，则服务器在连接关闭之前不会收到它。 我错过了什么或做错了什么？
另一件事是，目前我对不同的可能性感到非常困惑，我这样做的方式是一个好的解决方案吗？还是我应该尝试其他方法？
任何帮助将不胜感激！
【问题讨论】：
为什么将缓冲区大小设置为8字节而不是设置为您需要发送的文本量的大小。 缓冲区大小是如此之低，因为它是一些测试代码，在我的生产应用程序中，我可能要处理大于可用缓冲区空间的数据量。无论如何，在任何情况下都不应该覆盖缓冲区，所以我一定在这里做错了什么。问题是：什么？ 让您的 Worker 应用程序/服务托管 WCF 服务可能比直接使用套接字编程更容易。您可以将 WCF 服务配置为通过 TCP 进行通信，但实际的套接字通信是从您那里抽象出来的，因此您只需要真正担心定义 Worker 公开的操作以及传递给每个操作的数据结构。 【参考方案1】：问题是，在收到前几个字节后，您会立即用下一批覆盖它们：
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());
EndReceive 会将接收到的数据放入您的缓冲区中，因此之后无需调用Receive。之所以只得到中间的 8 个字节，是因为在收到最后一批后，Receive 中的代码块，等待更多数据。当客户端关闭连接时，Receive 返回0，不会修改缓冲区，并且您的回调将使用EndReceive 收到的任何内容调用。
【讨论】：
我不知道 EndReceive() 确实已经读取了字节，并且整天问自己“我如何从那个套接字读取？”，并且很难看到 Dr.威利的回答。现在我清楚了，谢谢！【参考方案2】：我怀疑套接字仅在接收到的字节数等于您在调用 BeginReceive 时指定的长度或套接字已关闭时才调用您的回调方法。
我认为您需要问自己的问题是您将通过此连接发送的数据的性质是什么。数据真的是不间断的字节流，例如文件的内容吗？如果是这样，那么也许您可以合理地期望客户端发送所有字节，然后立即关闭连接。如您所说，如果客户端关闭连接，则将为剩余字节调用您的回调方法。
如果连接将保持打开状态并用于发送单独的消息，那么您可能需要为该通信设计一个简单的协议。客户端会发送多个任意长的字符串，服务器是否需要分别处理每个字符串？如果是这样，那么一种方法可能是在每个字符串前面加上一个整数值（比如说 4 个字节），表示您将发送的字符串的长度。然后您的服务器可以首先调用 BeginReceive 指定 4 个字节的长度，使用这 4 个字节来确定传入字符串的长度，然后调用 Receive 指定传入字符串的长度。如果传入字符串的长度超过缓冲区的大小，那么您也需要处理这种情况。
-
调用 BeginReceive 等待接收 4 个字节。
根据这 4 个字节计算传入字符串的长度。
调用 Receive 以等待接收传入字符串的字节。
对下一个字符串重复步骤 1-3。
我创建了一个小型示例服务器和客户端应用程序来实现这种方法。我将缓冲区硬编码为 2048 字节，但如果您指定一个小至 4 字节的缓冲区，它仍然可以工作。
在我的方法中，如果传入的数据超过了我现有缓冲区的大小，那么我会创建一个单独的字节数组来存储传入的数据。这可能不是处理这种情况的最佳方式，但我认为你如何处理这种情况取决于你实际处理数据的方式。
服务器
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));
【讨论】：
以上是关于在 c# 中进行正确且快速的 TCP 网络连接的主要内容，如果未能解决你的问题，请参考以下文章