C# 异步 TCP 服务器完整实现

TCP异步Socket模型

C#的TCP异步Socket模型是通过Begin-End模式实现的。例如提供 BeginConnect、BeginAccept、BeginSend 和 BeginReceive等。

IAsyncResult BeginAccept(AsyncCallback callback, object state);

AsyncCallback 回调在函数执行完毕后执行。state 对象被用于在执行函数和回调函数间传输信息。

Socket socket = new Socket(
AddressFamily.InterNetwork,
SocketType.Stream,
ProtocolType.Tcp);
IPEndPoint iep = new IPEndPoint(IPAddress.Any, 8888);
socket.Bind(iep);
socket.Listen(5);
socket.BeginAccept (new AsyncCallback(CallbackAccept), socket);

private void CallbackAccept(IAsyncResult iar)
{
Socket server = (Socket)iar.AsyncState;
Socket client = server.EndAccept(iar);
}

则在Accept一个TcpClient，需要维护TcpClient列表。

private List<TcpClientState> clients;

异步TCP服务器完整实现

/// <summary>
/// 异步TCP服务器
/// </summary>
public class AsyncTcpServer : IDisposable
{
#region Fields

private TcpListener listener;
private List<TcpClientState> clients;
private bool disposed = false;

#endregion

#region Ctors

/// <summary>
/// 异步TCP服务器
/// </summary>
/// <param name="listenPort">监听的端口</param>
public AsyncTcpServer(int listenPort)
: this(IPAddress.Any, listenPort)
{
}

/// <summary>
/// 异步TCP服务器
/// </summary>
/// <param name="localEP">监听的终结点</param>
public AsyncTcpServer(IPEndPoint localEP)
: this(localEP.Address, localEP.Port)
{
}

/// <summary>
/// 异步TCP服务器
/// </summary>
/// <param name="localIPAddress">监听的IP地址</param>
/// <param name="listenPort">监听的端口</param>
public AsyncTcpServer(IPAddress localIPAddress, int listenPort)
{
Address = localIPAddress;
Port = listenPort;
this.Encoding = Encoding.Default;

clients = new List<TcpClientState>();

listener = new TcpListener(Address, Port);
listener.AllowNatTraversal(true);
}

#endregion

#region Properties

/// <summary>
/// 服务器是否正在运行
/// </summary>
public bool IsRunning { get; private set; }
/// <summary>
/// 监听的IP地址
/// </summary>
public IPAddress Address { get; private set; }
/// <summary>
/// 监听的端口
/// </summary>
public int Port { get; private set; }
/// <summary>
/// 通信使用的编码
/// </summary>
public Encoding Encoding { get; set; }

#endregion

#region Server

/// <summary>
/// 启动服务器
/// </summary>
/// <returns>异步TCP服务器</returns>
public AsyncTcpServer Start()
{
if (!IsRunning)
{
IsRunning = true;
listener.Start();
listener.BeginAcceptTcpClient(
new AsyncCallback(HandleTcpClientAccepted), listener);
}
return this;
}

/// <summary>
/// 启动服务器
/// </summary>
/// <param name="backlog">
/// 服务器所允许的挂起连接序列的最大长度
/// </param>
/// <returns>异步TCP服务器</returns>
public AsyncTcpServer Start(int backlog)
{
if (!IsRunning)
{
IsRunning = true;
listener.Start(backlog);
listener.BeginAcceptTcpClient(
new AsyncCallback(HandleTcpClientAccepted), listener);
}
return this;
}

/// <summary>
/// 停止服务器
/// </summary>
/// <returns>异步TCP服务器</returns>
public AsyncTcpServer Stop()
{
if (IsRunning)
{
IsRunning = false;
listener.Stop();

lock (this.clients)
{
for (int i = 0; i < this.clients.Count; i++)
{
this.clients[i].TcpClient.Client.Disconnect(false);
}
this.clients.Clear();
}

}
return this;
}

#endregion

#region Receive

private void HandleTcpClientAccepted(IAsyncResult ar)
{
if (IsRunning)
{
TcpListener tcpListener = (TcpListener)ar.AsyncState;

TcpClient tcpClient = tcpListener.EndAcceptTcpClient(ar);
byte[] buffer = new byte[tcpClient.ReceiveBufferSize];

TcpClientState internalClient
= new TcpClientState(tcpClient, buffer);
lock (this.clients)
{
this.clients.Add(internalClient);
RaiseClientConnected(tcpClient);
}

NetworkStream networkStream = internalClient.NetworkStream;
networkStream.BeginRead(
internalClient.Buffer,
0,
internalClient.Buffer.Length,
HandleDatagramReceived,
internalClient);

tcpListener.BeginAcceptTcpClient(
new AsyncCallback(HandleTcpClientAccepted), ar.AsyncState);
}
}

private void HandleDatagramReceived(IAsyncResult ar)
{
if (IsRunning)
{
TcpClientState internalClient = (TcpClientState)ar.AsyncState;
NetworkStream networkStream = internalClient.NetworkStream;

int numberOfReadBytes = 0;
try
{
numberOfReadBytes = networkStream.EndRead(ar);
}
catch
{
numberOfReadBytes = 0;
}

if (numberOfReadBytes == 0)
{
// connection has been closed
lock (this.clients)
{
this.clients.Remove(internalClient);
RaiseClientDisconnected(internalClient.TcpClient);
return;
}
}

// received byte and trigger event notification
byte[] receivedBytes = new byte[numberOfReadBytes];
Buffer.BlockCopy(
internalClient.Buffer, 0,
receivedBytes, 0, numberOfReadBytes);
RaiseDatagramReceived(internalClient.TcpClient, receivedBytes);
RaisePlaintextReceived(internalClient.TcpClient, receivedBytes);

// continue listening for tcp datagram packets
networkStream.BeginRead(
internalClient.Buffer,
0,
internalClient.Buffer.Length,
HandleDatagramReceived,
internalClient);
}
}

#endregion

#region Events

/// <summary>
/// 接收到数据报文事件
/// </summary>
public event EventHandler<TcpDatagramReceivedEventArgs<byte[]>> DatagramReceived;
/// <summary>
/// 接收到数据报文明文事件
/// </summary>
public event EventHandler<TcpDatagramReceivedEventArgs<string>> PlaintextReceived;

private void RaiseDatagramReceived(TcpClient sender, byte[] datagram)
{
if (DatagramReceived != null)
{
DatagramReceived(this, new TcpDatagramReceivedEventArgs<byte[]>(sender, datagram));
}
}

private void RaisePlaintextReceived(TcpClient sender, byte[] datagram)
{
if (PlaintextReceived != null)
{
PlaintextReceived(this, new TcpDatagramReceivedEventArgs<string>(
sender, this.Encoding.GetString(datagram, 0, datagram.Length)));
}
}

/// <summary>
/// 与客户端的连接已建立事件
/// </summary>
public event EventHandler<TcpClientConnectedEventArgs> ClientConnected;
/// <summary>
/// 与客户端的连接已断开事件
/// </summary>
public event EventHandler<TcpClientDisconnectedEventArgs> ClientDisconnected;

private void RaiseClientConnected(TcpClient tcpClient)
{
if (ClientConnected != null)
{
ClientConnected(this, new TcpClientConnectedEventArgs(tcpClient));
}
}

private void RaiseClientDisconnected(TcpClient tcpClient)
{
if (ClientDisconnected != null)
{
ClientDisconnected(this, new TcpClientDisconnectedEventArgs(tcpClient));
}
}

#endregion

#region Send

/// <summary>
/// 发送报文至指定的客户端
/// </summary>
/// <param name="tcpClient">客户端</param>
/// <param name="datagram">报文</param>
public void Send(TcpClient tcpClient, byte[] datagram)
{
if (!IsRunning)
throw new InvalidProgramException("This TCP server has not been started.");

if (tcpClient == null)
throw new ArgumentNullException("tcpClient");

if (datagram == null)
throw new ArgumentNullException("datagram");

tcpClient.GetStream().BeginWrite(
datagram, 0, datagram.Length, HandleDatagramWritten, tcpClient);
}

private void HandleDatagramWritten(IAsyncResult ar)
{
((TcpClient)ar.AsyncState).GetStream().EndWrite(ar);
}

/// <summary>
/// 发送报文至指定的客户端
/// </summary>
/// <param name="tcpClient">客户端</param>
/// <param name="datagram">报文</param>
public void Send(TcpClient tcpClient, string datagram)
{
Send(tcpClient, this.Encoding.GetBytes(datagram));
}

/// <summary>
/// 发送报文至所有客户端
/// </summary>
/// <param name="datagram">报文</param>
public void SendAll(byte[] datagram)
{
if (!IsRunning)
throw new InvalidProgramException("This TCP server has not been started.");

for (int i = 0; i < this.clients.Count; i++)
{
Send(this.clients[i].TcpClient, datagram);
}
}

/// <summary>
/// 发送报文至所有客户端
/// </summary>
/// <param name="datagram">报文</param>
public void SendAll(string datagram)
{
if (!IsRunning)
throw new InvalidProgramException("This TCP server has not been started.");

SendAll(this.Encoding.GetBytes(datagram));
}

#endregion

#region IDisposable Members

/// <summary>
/// Performs application-defined tasks associated with freeing,
/// releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}

/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release
/// both managed and unmanaged resources; <c>false</c>
/// to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
try
{
Stop();

if (listener != null)
{
listener = null;
}
}
catch (SocketException ex)
{
ExceptionHandler.Handle(ex);
}
}

disposed = true;
}
}

#endregion
}

使用举例

class Program
{
static AsyncTcpServer server;

static void Main(string[] args)
{
LogFactory.Assign(new ConsoleLogFactory());

server = new AsyncTcpServer(9999);
server.Encoding = Encoding.UTF8;
server.ClientConnected +=
new EventHandler<TcpClientConnectedEventArgs>(server_ClientConnected);
server.ClientDisconnected +=
new EventHandler<TcpClientDisconnectedEventArgs>(server_ClientDisconnected);
server.PlaintextReceived +=
new EventHandler<TcpDatagramReceivedEventArgs<string>>(server_PlaintextReceived);
server.Start();

Console.WriteLine("TCP server has been started.");
Console.WriteLine("Type something to send to client...");
while (true)
{
string text = Console.ReadLine();
server.SendAll(text);
}
}

static void server_ClientConnected(object sender, TcpClientConnectedEventArgs e)
{
Logger.Debug(string.Format(CultureInfo.InvariantCulture,
"TCP client {0} has connected.",
e.TcpClient.Client.RemoteEndPoint.ToString()));
}

static void server_ClientDisconnected(object sender, TcpClientDisconnectedEventArgs e)
{
Logger.Debug(string.Format(CultureInfo.InvariantCulture,
"TCP client {0} has disconnected.",
e.TcpClient.Client.RemoteEndPoint.ToString()));
}

static void server_PlaintextReceived(object sender, TcpDatagramReceivedEventArgs<string> e)
{
if (e.Datagram != "Received")
{
Console.Write(string.Format("Client : {0} --> ",
e.TcpClient.Client.RemoteEndPoint.ToString()));
Console.WriteLine(string.Format("{0}", e.Datagram));
server.Send(e.TcpClient, "Server has received you text : " + e.Datagram);
}
}
}

[b]本文为 Dennis Gao 原创技术文章，发表于博客园博客，未经作者本人允许禁止任何形式的转载。[/b]