一个Task的Output输入到另一个Task

Question

In Winforms, I have following: ProcessClientAsync adds an element to a ConcurrentDictionary. How can I ensure that the forloop runs after the Task.Run(). I tried to remove ConfigureAwait but it freezes the UI.

public async Task Listen(int port)
{
    try
  {
    IPAddress serverAddress = IPAddress.Parse("127.0.0.1"); // localhost

    _listener = new TcpListener(serverAddress, port);
    _listener.Start();

    while (true)
    {  
      TcpClient tcpClient = await _listener.AcceptTcpClientAsync();
      await Task.Run(() => ProcessTcpClientAsync(tcpClient).ConfigureAwait(false));
      _statusText.StatusUpdate = "number of users are " + _mapClient.GetUsers().Count;

    }
  }
  catch (SocketException ex)
  {
    string message = string.Format("Error listening on port {0}. Make sure IIS or another application is not running and consuming your port.", port);
    throw new Exception(message, ex);
  }
}

private async Task<string> ProcessTcpClientAsync(TcpClient tcpClient)
{
  string key = string.Empty;
  WebSocket webSocket = null;

  try
  {
    if (_isDisposed)
      return string.Empty;

    // this worker thread stays alive until either of the following happens:
    // Client sends a close conection request OR
    // An unhandled exception is thrown OR
    // The server is disposed

    // get a secure or insecure stream
    NetworkStream stream = tcpClient.GetStream();
    WebSocketHttpContext context = await _webSocketServerFactory.ReadHttpHeaderFromStreamAsync(stream);

    if (context.IsWebSocketRequest)
    {
      key = GetKeyFromContext(context);

      // _statusText.StatusUpdate = "Connection from origin.";
      webSocket = await _webSocketServerFactory.AcceptWebSocketAsync(context);

      //_statusText.StatusUpdate = "Connection accepted.";
      await RespondToWebSocketRequestAsync(tcpClient, key, webSocket);
    }
    else
    {
      //_statusText.StatusUpdate = "Http header contains no web socket upgrade request. Ignoring...";
    }
  }

  catch (Exception ex)
  {

  }
  finally
  {
    try
    {
      await webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Closed in server by the client", CancellationToken.None);

      tcpClient.Client.Close();
      tcpClient.Close();
    }
    catch (Exception ex)
    {
    }
  }

  return key;
}

Answer 1

You could await the Task.Run , but make sure to make the parent method async

await Task.Run(() => ProcessClientAsync(client).ConfigureAwait(false));

This will wait for the async task to complete, and then execute the rest of the code. I would suggest learning a bit more about async/await.

Answer 2

To block the ProcessClientAsync call you can do the following:

Task.Run(() => ProcessClientAsync(client)).Wait();

If you want to access the result of ProcessClientAsync:

Task<TResult> task = null;
Task.Run(() => task = ProcessClientAsync(client)).Wait();

// task.Result contains the result

Even if this works, it's recommended to await tasks rather than blocking with wait.

Answer 3

Quiz, what is the type of the variable x below?

var x = Task.Run(() => Task.Delay(1000).ConfigureAwait(false));

The type is not Task . It is Task<ConfiguredTaskAwaitable> . That internal ConfigureAwait(false) call is not only meaningless, but it also created a unexpected situation where the return value must now be awaited twice:

await await x;

Don't do this. If you have to use ConfigureAwait(false) for some reason, then you are expected to await the result immediately. Don't pass ConfiguredTaskAwaitable structs around. My advice is to search your code for more instances of this anti-pattern, and eliminate them.

Answer 4

If you don't want to mark the parent method as async, then you could use the following instead:

Task.Wait(Task.Run(() => ProcessClientAsync(client)));

This method has several overloads that allow for configurability of cancellation and timeouts as well:
https://docs.microsoft.com/en-us/dotnet/api/system.threading.tasks.task.wait?view=netframework-4.8

Also, if your code actually says while (true) and has no break conditions, then it will never exit.