https://learn.microsoft.com/zh-cn/dotnet/api/system.net.sockets.socket.beginaccept?view=net-5.0
要取消对 BeginAccept 方法的挂起调用，请关闭 Socket。当在异步操作正在进行时调用 Close 方法时，将调用提供给 BeginAccept 方法的回调。后续对 EndAccept 方法的调用将引发 ObjectDisposedException，以指示操作已被取消。
这里是 TcpListner.cs 的反编译代码。
[HostProtection(SecurityAction.LinkDemand, ExternalThreading = true)]
public Task<TcpClient> AcceptTcpClientAsync()
{
return Task<TcpClient>.Factory.FromAsync(BeginAcceptTcpClient, EndAcceptTcpClient, null);
}
public TcpClient EndAcceptTcpClient(IAsyncResult asyncResult)
{
if (Logging.On)
{
Logging.Enter(Logging.Sockets, this, "EndAcceptTcpClient", null);
}
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
LazyAsyncResult lazyResult = asyncResult as LazyAsyncResult;
Socket asyncSocket = (lazyResult == null) ? null : (lazyResult.AsyncObject as Socket);
if (asyncSocket == null)
{
throw new ArgumentException(SR.GetString("net_io_invalidasyncresult"), "asyncResult");
}
Socket socket = asyncSocket.EndAccept(asyncResult);
if (Logging.On)
{
Logging.Exit(Logging.Sockets, this, "EndAcceptTcpClient", socket);
}
return new TcpClient(socket);
}
[HostProtection(SecurityAction.LinkDemand, ExternalThreading = true)]
public IAsyncResult BeginAcceptTcpClient(AsyncCallback callback, object state)
{
if (Logging.On)
{
Logging.Enter(Logging.Sockets, this, "BeginAcceptTcpClient", null);
}
if (!m_Active)
{
throw new InvalidOperationException(SR.GetString("net_stopped"));
}
IAsyncResult result = m_ServerSocket.BeginAccept(callback, state);
if (Logging.On)
{
Logging.Exit(Logging.Sockets, this, "BeginAcceptTcpClient", null);
}
return result;
}
并反编译Socket.cs文件。
/// <summary>Asynchronously accepts an incoming connection attempt and creates a new <see cref="T:System.Net.Sockets.Socket" /> to handle remote host communication.</summary>
/// <returns>A <see cref="T:System.Net.Sockets.Socket" /> to handle communication with the remote host.</returns>
/// <param name="asyncResult">An <see cref="T:System.IAsyncResult" /> that stores state information for this asynchronous operation as well as any user defined data. </param>
/// <exception cref="T:System.ArgumentNullException">
/// <paramref name="asyncResult" /> is null. </exception>
/// <exception cref="T:System.ArgumentException">
/// <paramref name="asyncResult" /> was not created by a call to <see cref="M:System.Net.Sockets.Socket.BeginAccept(System.AsyncCallback,System.Object)" />. </exception>
/// <exception cref="T:System.Net.Sockets.SocketException">An error occurred when attempting to access the socket. See the Remarks section for more information. </exception>
/// <exception cref="T:System.ObjectDisposedException">The <see cref="T:System.Net.Sockets.Socket" /> has been closed. </exception>
/// <exception cref="T:System.InvalidOperationException">
/// <see cref="M:System.Net.Sockets.Socket.EndAccept(System.IAsyncResult)" /> method was previously called. </exception>
/// <exception cref="T:System.NotSupportedException">Windows NT is required for this method. </exception>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true" />
/// <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true" />
/// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, ControlEvidence" />
/// <IPermission class="System.Diagnostics.PerformanceCounterPermission, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true" />
/// </PermissionSet>
public Socket EndAccept(IAsyncResult asyncResult)
{
if (s_LoggingEnabled)
{
Logging.Enter(Logging.Sockets, this, "EndAccept", asyncResult);
}
if (CleanedUp)
{
throw new ObjectDisposedException(GetType().FullName);
}
byte[] buffer;
int bytesTransferred;
if (asyncResult != null && asyncResult is AcceptOverlappedAsyncResult)
{
return EndAccept(out buffer, out bytesTransferred, asyncResult);
}
if (asyncResult == null)
{
throw new ArgumentNullException("asyncResult");
}
AcceptAsyncResult castedAsyncResult = asyncResult as AcceptAsyncResult;
if (castedAsyncResult == null || castedAsyncResult.AsyncObject != this)
{
throw new ArgumentException(SR.GetString("net_io_invalidasyncresult"), "asyncResult");
}
if (castedAsyncResult.EndCalled)
{
throw new InvalidOperationException(SR.GetString("net_io_invalidendcall", "EndAccept"));
}
object result = castedAsyncResult.InternalWaitForCompletion();
castedAsyncResult.EndCalled = true;
Exception exception = result as Exception;
if (exception != null)
{
throw exception;
}
if (castedAsyncResult.ErrorCode != 0)
{
SocketException socketException = new SocketException(castedAsyncResult.ErrorCode);
UpdateStatusAfterSocketError(socketException);
if (s_LoggingEnabled)
{
Logging.Exception(Logging.Sockets, this, "EndAccept", socketException);
}
throw socketException;
}
Socket acceptedSocket = (Socket)result;
if (s_LoggingEnabled)
{
Logging.PrintInfo(Logging.Sockets, acceptedSocket, SR.GetString("net_log_socket_accepted", acceptedSocket.RemoteEndPoint, acceptedSocket.LocalEndPoint));
Logging.Exit(Logging.Sockets, this, "EndAccept", result);
}
return acceptedSocket;
}
看起来 AcceptTcpClientAsync() 内部使用了类似于 BeginAccept() 和 EndAccept() 的东西。在 Socket.cs 中，如果 CleanedUp 为 true，则会抛出 ObjectDisposedException，这意味着监听套接字已关闭。
因此，关闭监听套接字会导致 AcceptTcpClientAsync() 抛出 ObjectDisposedException。
namespace TestTcpListenStop {
class Program {
static TcpListener listner;
static void Main(string[] args) {
for (int i = 0; i < 100; ++i) {
StartStopTest();
}
Console.ReadKey();
return;
}
static void StartStopTest() {
listner = new TcpListener(IPAddress.Any, 17000);
listner.Start();
Task tk = AcceptAsync();
Task.Delay(1).Wait();
listner.Stop();
tk.Wait();
return;
}
static async Task AcceptAsync() {
Console.WriteLine("Accepting client...");
TcpClient client;
while (true) {
try {
client = await listner.AcceptTcpClientAsync().ConfigureAwait(false);
Console.WriteLine("A client has been accepted.");
}
catch (ObjectDisposedException) {
Console.WriteLine("This exception means listening socket closed.");
break;
}
client.Client.Shutdown(SocketShutdown.Both);
client.Close();
}
Console.WriteLine("AcceptAsync() terminated.");
}
}
}
https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.wait?view=net-5.0
取消 cancellationToken 取消令牌对正在运行的任务没有影响，除非它也被传递了取消令牌并准备好处理取消。将 cancellationToken 对象传递给此方法只是允许取消等待。
我认为使用取消令牌实际上并不能停止 AcceptTcpClientAsync()。我们只是取消等待，而不是 AcceptTcpClientAsync()，因为 AcceptTcpClientAsync() 没有接收到取消令牌作为参数。只有关闭监听套接字才能取消 AcceptTcpClientAsync()。请参见以下来自 msdn 的内容。
public class Example {
public static void Main() {
CancellationTokenSource ts = new CancellationTokenSource();
Task t = Task.Run(() => {
Console.WriteLine("Calling Cancel...");
ts.Cancel();
Task.Delay(5000).Wait();
Console.WriteLine("Task ended delay...");
});
try {
Console.WriteLine("About to wait for the task to complete...");
t.Wait(ts.Token);
}
catch (OperationCanceledException e) {
Console.WriteLine("{0}: The wait has been canceled. Task status: {1:G}",
e.GetType().Name, t.Status);
Thread.Sleep(6000);
Console.WriteLine("After sleeping, the task status: {0:G}", t.Status);
}
ts.Dispose();
}
}
