无法在控制台应用程序的“主要”方法上指定“异步”修饰符

我是使用async修饰符进行异步编程的新手。我试图弄清楚如何确保Main控制台应用程序的方法实际上异步运行。

class Program
{
    static void Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = bs.GetList();
    }
}

public class Bootstrapper {

    public async Task<List<TvChannel>> GetList()
    {
        GetPrograms pro = new GetPrograms();

        return await pro.DownloadTvChannels();
    }
}

我知道这不是从“顶部”异步运行的。由于无法async在Main方法上指定修饰符，因此如何在main异步方式内运行代码？

如您所见，在VS11中，编译器将禁止使用async Main方法。在VS2010中，使用Async CTP允许（但绝不建议这样做）。

我最近在博客文章中特别提到了异步/等待和异步控制台程序。以下是介绍性帖子的一些背景信息：

如果“ await”看到awaitable尚未完成，则它将异步执行。它告诉可等待的对象在完成时运行该方法的其余部分，然后从异步方法中返回。当等待方法将其余方法传递给等待方法时，它还将捕获当前上下文。

稍后，当awaitable完成时，它将执行async方法的其余部分（在捕获的上下文中）。

这就是在控制台程序中使用出现问题的原因async Main：

请记住，在我们的介绍性帖子中，异步方法将在完成之前返回其调用方。这在UI应用程序（该方法仅返回到UI事件循环）和ASP.NET应用程序（该方法从线程返回但使请求保持活动状态）中完美地工作。对于Console程序，效果不是很好：Main返回OS-因此程序退出。

一种解决方案是提供您自己的上下文-异步兼容的控制台程序的“主循环”。

如果您有一台具有异步CTP的计算机，则可以GeneralThreadAffineContext从“ 我的文档” \“ Microsoft Visual Studio”中，使用“异步CTP” \“样本（C＃测试）”单元测试\“ AsyncTestUtilities”。或者，您可以AsyncContext从我的Nito.AsyncEx NuGet包中使用。

这是一个使用AsyncContext; 的例子。GeneralThreadAffineContext具有几乎相同的用法：

using Nito.AsyncEx;
class Program
{
    static void Main(string[] args)
    {
        AsyncContext.Run(() => MainAsync(args));
    }

    static async void MainAsync(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = await bs.GetList();
    }
}

或者，您可以仅阻塞主控制台线程，直到异步工作完成：

class Program
{
    static void Main(string[] args)
    {
        MainAsync(args).GetAwaiter().GetResult();
    }

    static async Task MainAsync(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = await bs.GetList();
    }
}

注意使用GetAwaiter().GetResult(); 这样可以避免AggregateException使用Wait()或时发生的换行Result。

更新，2017-11-30：从Visual Studio 2017更新3（15.3）开始，该语言现在支持async Main-，只要它返回Task或即可Task<T>。因此，您现在可以执行以下操作：

class Program
{
    static async Task Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var list = await bs.GetList();
    }
}

语义似乎与GetAwaiter().GetResult()阻塞主线程的样式相同。但是，尚无C＃7.1的语言规范，因此这只是一个假设。

您可以使用以下简单结构解决此问题：

class Program
{
    static void Main(string[] args)
    {
        Task.Run(async () =>
        {
            // Do any async anything you need here without worry
        }).GetAwaiter().GetResult();
    }
}

这会将您执行的所有操作放在所需的ThreadPool上（因此，您启动/等待的其他任务不会尝试重新加入不应执行的线程），并等待所有操作完成后再关闭Console应用程序。不需要特殊的循环或外部库。

编辑：合并未捕获的异常的安德鲁的解决方案。

您还可以通过执行以下操作来执行此操作，而无需外部库：

class Program
{
    static void Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        var getListTask = bs.GetList(); // returns the Task<List<TvChannel>>

        Task.WaitAll(getListTask); // block while the task completes

        var list = getListTask.Result;
    }
}

在C＃7.1中，您将能够执行适当的异步Main。Main方法的适当签名已扩展到：

public static Task Main();
public static Task<int> Main();
public static Task Main(string[] args);
public static Task<int> Main(string[] args);

例如，您可能正在做：

static async Task Main(string[] args)
{
    Bootstrapper bs = new Bootstrapper();
    var list = await bs.GetList();
}

在编译时，异步入口点方法将转换为call GetAwaitor().GetResult()。

详细信息：https : //blogs.msdn.microsoft.com/mazhou/2017/05/30/c-7-series-part-2-async-main

编辑：

要启用C＃7.1语言功能，您需要右键单击该项目，然后单击“属性”，然后转到“构建”选项卡。在此处，单击底部的高级按钮：

从语言版本下拉菜单中，选择“ 7.1”（或任何更高的值）：

默认值为“最新主要版本”，它将在撰写本文时评估为C＃7.0，该版本在控制台应用程序中不支持异步main。

我将添加一个其他所有答案都忽略的重要功能：取消。

TPL中的一大功能是取消支持，控制台应用程序具有内置的取消方法（CTRL + C）。将它们绑定在一起非常简单。这就是我构造所有异步控制台应用程序的方式：

static void Main(string[] args)
{
    CancellationTokenSource cts = new CancellationTokenSource();

    System.Console.CancelKeyPress += (s, e) =>
    {
        e.Cancel = true;
        cts.Cancel();
    };

    MainAsync(args, cts.Token).Wait();
}

static async Task MainAsync(string[] args, CancellationToken token)
{
    ...
}

C＃7.1（使用vs 2017 Update 3）引入了异步main

你可以写：

   static async Task Main(string[] args)
  {
    await ...
  }

有关更多详细信息，C＃7系列，第2部分：异步主要

更新：

您可能会收到编译错误：

程序不包含适用于入口点的静态“ Main”方法

此错误是由于vs2017.3默认配置为c＃7.0而不是c＃7.1。

您应该显式修改项目的设置以设置c＃7.1功能。

您可以通过两种方法设置c＃7.1：

方法1：使用项目设置窗口：

• 打开项目的设置
• 选择构建选项卡
• 点击高级按钮
• 选择所需的版本，如下图所示：

方法2：手动修改.csproj的PropertyGroup

添加此属性：

    <LangVersion>7.1</LangVersion>

例：

    <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
        <PlatformTarget>AnyCPU</PlatformTarget>
        <DebugSymbols>true</DebugSymbols>
        <DebugType>full</DebugType>
        <Optimize>false</Optimize>
        <OutputPath>bin\Debug\</OutputPath>
        <DefineConstants>DEBUG;TRACE</DefineConstants>
        <ErrorReport>prompt</ErrorReport>
        <WarningLevel>4</WarningLevel>
        <Prefer32Bit>false</Prefer32Bit>
        <LangVersion>7.1</LangVersion>
    </PropertyGroup>    

如果您使用的是C＃7.1或更高版本，请使用nawfal的答案，只需将Main方法的返回类型更改为Task或即可Task<int>。如果您不是：

• 有个async Task MainAsync 喜欢约翰的话。
• 调用它.GetAwaiter().GetResult()以捕获基本异常，如do0g said。
• 支持取消就像Cory所说的。
• 一秒钟CTRL+C应该立即终止该过程。（感谢binki！）
• 处理OperationCancelledException-返回适当的错误代码。

最终代码如下：

private static int Main(string[] args)
{
    var cts = new CancellationTokenSource();
    Console.CancelKeyPress += (s, e) =>
    {
        e.Cancel = !cts.IsCancellationRequested;
        cts.Cancel();
    };

    try
    {
        return MainAsync(args, cts.Token).GetAwaiter().GetResult();
    }
    catch (OperationCanceledException)
    {
        return 1223; // Cancelled.
    }
}

private static async Task<int> MainAsync(string[] args, CancellationToken cancellationToken)
{
    // Your code...

    return await Task.FromResult(0); // Success.
}

并不需要那么多，但是当我使用控制台应用程序进行快速测试并需要异步时，我就这样解决了它：

class Program
{
    static void Main(string[] args)
    {
        MainAsync(args).Wait();
    }

    static async Task MainAsync(string[] args)
    {
        // Code here
    }
}

对于从Main异步调用任务，请使用

1. 适用于.NET 4.5的Task.Run（）

2. .NET 4.0的Task.Factory.StartNew（）（可能需要Microsoft.Bcl.Async库用于async和await关键字）

详细信息：http : //blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

在Main中，尝试将对GetList的调用更改为：

Task.Run(() => bs.GetList());

引入C＃5 CTP时，您当然可以将Main标记为async ...，尽管这样做通常不是一个好主意。我相信VS 2013的发布已将其更改为错误。

除非您已启动任何其他前台线程，否则Main即使完成一些后台工作，您的程序也会在完成时退出。

什么是你真正想干什么？请注意，您的GetList()方法目前确实不需要异步-它没有任何实际原因添加额外的层。从逻辑上讲，它等效于（但比它复杂）：

public Task<List<TvChannel>> GetList()
{
    return new GetPrograms().DownloadTvChannels();
}

最新版本的C＃-C＃7.1允许创建异步控制台应用程序。要在项目中启用C＃7.1，您必须将VS至少升级到15.3，并将C＃版本更改为C# 7.1或C# latest minor version。为此，请转到项目属性->构建->高级->语言版本。

之后，以下代码将起作用：

internal class Program
{
    public static async Task Main(string[] args)
    {
         (...)
    }

在MSDN上，Task.Run方法（操作）的文档提供了此示例，该示例显示如何从main以下位置异步运行方法：

using System;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
    public static void Main()
    {
        ShowThreadInfo("Application");

        var t = Task.Run(() => ShowThreadInfo("Task") );
        t.Wait();
    }

    static void ShowThreadInfo(String s)
    {
        Console.WriteLine("{0} Thread ID: {1}",
                          s, Thread.CurrentThread.ManagedThreadId);
    }
}
// The example displays the following output:
//       Application thread ID: 1
//       Task thread ID: 3

请注意以下示例后面的语句：

这些示例表明，异步任务在与主应用程序线程不同的线程上执行。

所以，如果不是你想要的主应用程序线程上运行任务时，看到答案通过 @StephenCleary。

关于任务运行的线程，还请注意Stephen 对他的回答的评论：

您可以使用简单的Wait或Result，这没有任何问题。但是请注意，有两个重要区别：1）所有async延续都在线程池上而不是在主线程上运行，并且2）任何异常都包装在中AggregateException。

（有关如何合并异常处理以处理的信息，请参见异常处理（任务并行库）AggregateException。）

最后，在MSDN上，从Task.Delay方法（TimeSpan）的文档开始，此示例演示如何运行返回值的异步任务：

using System;
using System.Threading.Tasks;

public class Example
{
    public static void Main()
    {
        var t = Task.Run(async delegate
                {
                    await Task.Delay(TimeSpan.FromSeconds(1.5));
                    return 42;
                });
        t.Wait();
        Console.WriteLine("Task t Status: {0}, Result: {1}",
                          t.Status, t.Result);
    }
}
// The example displays the following output:
//        Task t Status: RanToCompletion, Result: 42

请注意，您可以像这样传递lambda函数，而不是传递给delegateto Task.Run：

var t = Task.Run(async () =>
        {
            await Task.Delay(TimeSpan.FromSeconds(1.5));
            return 42;
        });

为了避免在尝试重新连接当前线程（卡在Wait中）的调用堆栈下方某个地方调用函数时冻结，您需要执行以下操作：

class Program
{
    static void Main(string[] args)
    {
        Bootstrapper bs = new Bootstrapper();
        List<TvChannel> list = Task.Run((Func<Task<List<TvChannel>>>)bs.GetList).Result;
    }
}

（仅需使用演员表才能解决歧义）

在我的情况下，我有一个要从主要方法异步运行的作业列表，已经在生产环境中使用了一段时间，并且工作正常。

static void Main(string[] args)
{
    Task.Run(async () => { await Task.WhenAll(jobslist.Select(nl => RunMulti(nl))); }).GetAwaiter().GetResult();
}
private static async Task RunMulti(List<string> joblist)
{
    await ...
}