具有任务控制的异步控制台

Question

请帮助我找到正确的解决方案。 主要问题是通过控制台等待程序完成，同时监控任务。

我写了一些原型，但我不确定它是否有效——在这种方法中，我们花费了一个额外的线程来等待来自控制台的操作。我没有看到替代品，因为 Console 不支持异步（某种 Console.ReadLineAsync）。

更新： 我有两个工作任务（task1、task2）。它们模拟了一些实际工作。 该程序是一个控制台。所以我们需要给用户一个停止程序的机会。默认情况下，在控制台中，这是通过按“Enter”完成的（通过consoleTask）。

问题是。如何等待工作线程完成并监控用户的停止命令。

static void Main(string[] args)
{
  CancellationTokenSource mycts = new CancellationTokenSource();
  var task1 = Task.Run(() =>
  {
  // doing some work, that can throw exception
  Thread.Sleep(1000);

  // how to avoid this closuring ?
  mycts.Token.ThrowIfCancellationRequested();

  throw new InvalidOperationException("test");
  }).ContinueWith((_) => mycts.Cancel()); // Do I need caching this task?

  var task2 = Task.Run(() =>    
  {
  // doing some work, that can throw exception
  Thread.Sleep(5000);

  // again closuring
  mycts.Token.ThrowIfCancellationRequested();
  throw new InvalidOperationException("test");
  }).ContinueWith((_) => mycts.Cancel()); // Do I need caching this task?


  // I do not know how to do better with Console !!
  var consoleTask = Task.Factory.StartNew((cts) =>
  {
  Console.WriteLine("Press Enter to exit");
  Console.ReadLine();
  }, mycts).ContinueWith((_) => mycts.Cancel()); // Do I need caching this task?

  // Waiting for the Completion or Exception
  Task.WaitAny(task1, task2, consoleTask);

  // Now waiting for the completion of workflow
  try
  {
    Task.WaitAll(task1, task2);
  }
  catch (Exception ex)
  {
    // log faulted tasks
  }

  //Exit
  }

Answer 1

您应该遵循一些准则：

1. 不要使用ContinueWith。请改用await。
2. 不要使用Task.Factory.StartNew。请改用Task.Run。
3. 不要混合阻塞和异步代码。对于控制台应用程序，通常最好让Main 调用MainAsync 并等待返回的任务。对于大多数应用程序，这是您应该使用的唯一阻塞。

我不确定how to avoid this closuring? 是什么意思。

在ReadLine（和其他控制台方法）的情况下，你是对的，不幸的是没有异步方法。 可能可以使用单独的线程，但 Console 类（更具体地说，控制台输入和输出流）在幕后发生了一些不寻常的锁定，所以我不是 积极的这会起作用：

static void Main(string[] args)
{
  MainAsync().Wait();
}
static CancellationTokenSource mycts = new CancellationTokenSource();
static async Task MainAsync()
{
  try
  {
    var task1 = CancelAfterSuccessfulCompletionAsync(
        Task.Run(() => SomeWorkThatCanThrowException()));
    var task2 = CancelAfterSuccessfulCompletionAsync(
        Task.Run(() => OtherWorkThatCanThrowException()));
    var consoleTask = CancelAfterSuccessfulCompletionAsync(
        Task.Run(() => MonitorConsole()));
    await Task.WhenAll(task1, task2, consoleTask);
  }
  catch (Exception ex)
  {
    Console.WriteLine(ex);
  }
}
static void OtherWorkThatCanThrowException()
{
  Thread.Sleep(5000);
  mycts.Token.ThrowIfCancellationRequested();
  throw new InvalidOperationException("test");
}
static void SomeWorkThatCanThrowException()
{
  Thread.Sleep(1000);
  mycts.Token.ThrowIfCancellationRequested();
  throw new InvalidOperationException("test");
}
static void MonitorConsole()
{
  Console.WriteLine("Press Enter to exit");
  Console.ReadLine();
}
static async Task CancelAfterSuccessfulCompletionAsync(Task task)
{
  await task;
  mycts.Cancel();
}

Answer 2

由于控制台没有 SynchronizationContext，因此在执行异步操作时，如果不阻塞主线程，您将无能为力。

但是，如果您只是编写代码，就好像它是异步的并以最简单的方式进行阻塞，则要简单得多。我建议将您的所有代码移至异步 MainAsync 并阻塞一次：

static void Main()
{
    MainAsync().Wait();
}

static async Task MainAsync()
{
    // manage tasks asynchronously
}

您可以做的不是阻塞，而是使用自定义上下文来执行异步操作，例如Stephen Cleary's AsyncContext。这使您可以避免在 Task 上同步阻塞：

static void Main()
{
    AsyncContext.Run(MainAsync);
}