이 기사에서는
TcpListener 클래스는 차단 동기화 모드에서 들어오는 연결 요청을 수신하고 수락하기 위한 몇 가지 간단한 메서드를 제공합니다. TcpListener는 TcpClient 또는 Socket을 사용하여 연결할 수 있습니다. TcpListener는 IPEndPoint, 로컬 IP 주소 및 포트 번호 또는 포트 번호만 사용하여 생성할 수 있습니다. 기본 서비스 공급자가 이러한 값을 할당하도록 하려면 로컬 IP 주소를 임의로 지정하고 로컬 포트 번호를 0으로 지정할 수 있습니다.
이렇게 하기로 선택한 경우 LocalEndpoint 속성을 사용하여 소켓에 연결한 후 지정된 정보를 식별할 수 있습니다. 들어오는 연결 요청 수신 대기를 시작하려면 Start 메서드를 사용합니다. Start는 Stop 메서드를 호출하거나 MaxConnections 대기열 작업을 완료할 때까지 들어오는 연결을 대기열에 넣습니다. AcceptSocket 또는 AcceptTcpClient를 사용하여 들어오는 연결 요청 대기열에서 연결을 추출할 수 있습니다. 두 방법 모두 차단됩니다. 차단을 방지하려면 먼저 Pending 메서드를 사용하여 큐에 사용 가능한 연결 요청이 있는지 확인하세요.
TcpListener가 꽤 잘 캡슐화되었지만 우리는 이를 사용하여 비교적 좋은 비동기 TCP 서버를 구성합니다. 여기서는 여전히 첫 번째와 동일합니다. 두 장에서와 마찬가지로 서버의 코드를 제공하고 코드의 주석은 매우 자세하며 관련 캡슐화 클래스도 제공합니다.
TcpListener 비동기 TCP 서버
서버 코드
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
using System.Net;
namespace NetFrame.Net.TCP.Listener.Asynchronous
{
/// <summary>
/// TcpListener实现异步TCP服务器
/// </summary>
public class AsyncTCPServer : IDisposable
{
#region Fields
/// <summary>
/// 服务器程序允许的最大客户端连接数
/// </summary>
private int _maxClient;
/// <summary>
/// 当前的连接的客户端数
/// </summary>
private int _clientCount;
/// <summary>
/// 服务器使用的异步TcpListener
/// </summary>
private TcpListener _listener;
/// <summary>
/// 客户端会话列表
/// </summary>
private List<Object> _clients;
private bool disposed = false;
#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 构造函数
/// <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<Object>();
_listener = new TcpListener(Address, Port);
_listener.AllowNatTraversal(true);
}
#endregion
#region Method
/// <summary>
/// 启动服务器
/// </summary>
public void Start()
{
if (!IsRunning)
{
IsRunning = true;
_listener.Start();
_listener.BeginAcceptTcpClient(
new AsyncCallback(HandleTcpClientAccepted), _listener);
}
}
/// <summary>
/// 启动服务器
/// </summary>
/// <param name="backlog">
/// 服务器所允许的挂起连接序列的最大长度
/// </param>
public void Start(int backlog)
{
if (!IsRunning)
{
IsRunning = true;
_listener.Start(backlog);
_listener.BeginAcceptTcpClient(
new AsyncCallback(HandleTcpClientAccepted), _listener);
}
}
/// <summary>
/// 停止服务器
/// </summary>
public void Stop()
{
if (IsRunning)
{
IsRunning = false;
_listener.Stop();
lock (_clients)
{
//关闭所有客户端连接
CloseAllClient();
}
}
}
/// <summary>
/// 处理客户端连接的函数
/// </summary>
/// <param name="ar"></param>
private void HandleTcpClientAccepted(IAsyncResult ar)
{
if (IsRunning)
{
//TcpListener tcpListener = (TcpListener)ar.AsyncState;
TcpClient client = _listener.EndAcceptTcpClient(ar);
byte[] buffer = new byte[client.ReceiveBufferSize];
TCPClientState state
= new TCPClientState(client, buffer);
lock (_clients)
{
_clients.Add(state);
RaiseClientConnected(state);
}
NetworkStream stream = state.NetworkStream;
//开始异步读取数据
stream.BeginRead(state.Buffer, 0, state.Buffer.Length, HandleDataReceived, state);
_listener.BeginAcceptTcpClient(
new AsyncCallback(HandleTcpClientAccepted), ar.AsyncState);
}
}
/// <summary>
/// 数据接受回调函数
/// </summary>
/// <param name="ar"></param>
private void HandleDataReceived(IAsyncResult ar)
{
if (IsRunning)
{
TCPClientState state = (TCPClientState)ar.AsyncState;
NetworkStream stream = state.NetworkStream;
int recv = 0;
try
{
recv = stream.EndRead(ar);
}
catch
{
recv = 0;
}
if (recv == 0)
{
// connection has been closed
lock (_clients)
{
_clients.Remove(state);
//触发客户端连接断开事件
RaiseClientDisconnected(state);
return;
}
}
// received byte and trigger event notification
byte[] buff = new byte[recv];
Buffer.BlockCopy(state.Buffer, 0, buff, 0, recv);
//触发数据收到事件
RaiseDataReceived(state);
// continue listening for tcp datagram packets
stream.BeginRead(state.Buffer, 0, state.Buffer.Length, HandleDataReceived, state);
}
}
/// <summary>
/// 发送数据
/// </summary>
/// <param name="state">接收数据的客户端会话</param>
/// <param name="data">数据报文</param>
public void Send(TCPClientState state, byte[] data)
{
RaisePrepareSend(state);
Send(state.TcpClient, data);
}
/// <summary>
/// 异步发送数据至指定的客户端
/// </summary>
/// <param name="client">客户端</param>
/// <param name="data">报文</param>
public void Send(TcpClient client, byte[] data)
{
if (!IsRunning)
throw new InvalidProgramException("This TCP Scoket server has not been started.");
if (client == null)
throw new ArgumentNullException("client");
if (data == null)
throw new ArgumentNullException("data");
client.GetStream().BeginWrite(data, 0, data.Length, SendDataEnd, client);
}
/// <summary>
/// 发送数据完成处理函数
/// </summary>
/// <param name="ar">目标客户端Socket</param>
private void SendDataEnd(IAsyncResult ar)
{
((TcpClient)ar.AsyncState).GetStream().EndWrite(ar);
RaiseCompletedSend(null);
}
#endregion
#region 事件
/// <summary>
/// 与客户端的连接已建立事件
/// </summary>
public event EventHandler<AsyncEventArgs> ClientConnected;
/// <summary>
/// 与客户端的连接已断开事件
/// </summary>
public event EventHandler<AsyncEventArgs> ClientDisconnected;
/// <summary>
/// 触发客户端连接事件
/// </summary>
/// <param name="state"></param>
private void RaiseClientConnected(TCPClientState state)
{
if (ClientConnected != null)
{
ClientConnected(this, new AsyncEventArgs(state));
}
}
/// <summary>
/// 触发客户端连接断开事件
/// </summary>
/// <param name="client"></param>
private void RaiseClientDisconnected(TCPClientState state)
{
if (ClientDisconnected != null)
{
ClientDisconnected(this, new AsyncEventArgs("连接断开"));
}
}
/// <summary>
/// 接收到数据事件
/// </summary>
public event EventHandler<AsyncEventArgs> DataReceived;
private void RaiseDataReceived(TCPClientState state)
{
if (DataReceived != null)
{
DataReceived(this, new AsyncEventArgs(state));
}
}
/// <summary>
/// 发送数据前的事件
/// </summary>
public event EventHandler<AsyncEventArgs> PrepareSend;
/// <summary>
/// 触发发送数据前的事件
/// </summary>
/// <param name="state"></param>
private void RaisePrepareSend(TCPClientState state)
{
if (PrepareSend != null)
{
PrepareSend(this, new AsyncEventArgs(state));
}
}
/// <summary>
/// 数据发送完毕事件
/// </summary>
public event EventHandler<AsyncEventArgs> CompletedSend;
/// <summary>
/// 触发数据发送完毕的事件
/// </summary>
/// <param name="state"></param>
private void RaiseCompletedSend(TCPClientState state)
{
if (CompletedSend != null)
{
CompletedSend(this, new AsyncEventArgs(state));
}
}
/// <summary>
/// 网络错误事件
/// </summary>
public event EventHandler<AsyncEventArgs> NetError;
/// <summary>
/// 触发网络错误事件
/// </summary>
/// <param name="state"></param>
private void RaiseNetError(TCPClientState state)
{
if (NetError != null)
{
NetError(this, new AsyncEventArgs(state));
}
}
/// <summary>
/// 异常事件
/// </summary>
public event EventHandler<AsyncEventArgs> OtherException;
/// <summary>
/// 触发异常事件
/// </summary>
/// <param name="state"></param>
private void RaiseOtherException(TCPClientState state, string descrip)
{
if (OtherException != null)
{
OtherException(this, new AsyncEventArgs(descrip, state));
}
}
private void RaiseOtherException(TCPClientState state)
{
RaiseOtherException(state, "");
}
#endregion
#region Close
/// <summary>
/// 关闭一个与客户端之间的会话
/// </summary>
/// <param name="state">需要关闭的客户端会话对象</param>
public void Close(TCPClientState state)
{
if (state != null)
{
state.Close();
_clients.Remove(state);
_clientCount--;
//TODO 触发关闭事件
}
}
/// <summary>
/// 关闭所有的客户端会话,与所有的客户端连接会断开
/// </summary>
public void CloseAllClient()
{
foreach (TCPClientState client in _clients)
{
Close(client);
}
_clientCount = 0;
_clients.Clear();
}
#endregion
#region 释放
/// <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)
{
//TODO
RaiseOtherException(null);
}
}
disposed = true;
}
}
#endregion
}
}로그인 후 복사
클라이언트 처리 캡슐화 클래스
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Sockets;
namespace NetFrame.Net.TCP.Listener.Asynchronous
{
public class TCPClientState
{
/// <summary>
/// 与客户端相关的TcpClient
/// </summary>
public TcpClient TcpClient { get; private set; }
/// <summary>
/// 获取缓冲区
/// </summary>
public byte[] Buffer { get; private set; }
/// <summary>
/// 获取网络流
/// </summary>
public NetworkStream NetworkStream
{
get { return TcpClient.GetStream(); }
}
public TCPClientState(TcpClient tcpClient, byte[] buffer)
{
if (tcpClient == null)
throw new ArgumentNullException("tcpClient");
if (buffer == null)
throw new ArgumentNullException("buffer");
this.TcpClient = tcpClient;
this.Buffer = buffer;
}
/// <summary>
/// 关闭
/// </summary>
public void Close()
{
//关闭数据的接受和发送
TcpClient.Close();
Buffer = null;
}
}
}로그인 후 복사
서버 이벤트 매개변수 클래스
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace NetFrame.Net.TCP.Listener.Asynchronous
{
/// <summary>
/// 异步TcpListener TCP服务器事件参数类
/// </summary>
public class AsyncEventArgs:EventArgs
{
/// <summary>
/// 提示信息
/// </summary>
public string _msg;
/// <summary>
/// 客户端状态封装类
/// </summary>
public TCPClientState _state;
/// <summary>
/// 是否已经处理过了
/// </summary>
public bool IsHandled { get; set; }
public AsyncEventArgs(string msg)
{
this._msg = msg;
IsHandled = false;
}
public AsyncEventArgs(TCPClientState state)
{
this._state = state;
IsHandled = false;
}
public AsyncEventArgs(string msg, TCPClientState state)
{
this._msg = msg;
this._state = state;
IsHandled = false;
}
}
}로그인 후 복사
위는 C# 네트워크 프로그래밍 시리즈에서 비동기 TCP 서버를 구현하기 위한 TcpListener의 내용입니다(3 ). 더 많은 관련 내용은 PHP 중국어 홈페이지(www.php.cn)를 참고해주세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
