Не удается указать модификатор «async» в методе «Main» консольного приложения

Я новичок в асинхронном программировании с 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 также будет захватывать текущий контекст, когда он передает оставшуюся часть метода ожидающему.

Позже, когда ожидаемое завершится, оно выполнит оставшуюся часть асинхронного метода (в захваченном контексте).

Вот почему это проблема в консольных программах с async Main:

Помните из нашего вступительного поста, что асинхронный метод вернется к своему вызывающему до завершения. Это прекрасно работает в приложениях пользовательского интерфейса (метод просто возвращается в цикл событий пользовательского интерфейса) и приложениях ASP.NET (метод возвращает поток, но поддерживает запрос в действии). Это не очень хорошо работает с консольными программами: Main возвращается в ОС, поэтому ваша программа завершает работу.

Одним из решений является предоставление собственного контекста - «основного цикла» для вашей консольной программы, который является асинхронным.

Если у вас есть машина с Async CTP, вы можете использовать GeneralThreadAffineContextиз Моих документов \ Microsoft Visual Studio Async CTP \ Samples (C # Testing) Unit Testing \ 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, где вы этого хотите (поэтому другие задачи, которые вы запускаете / ожидаете, не пытаются присоединиться к потоку, которые они не должны), и ждут, пока все будет сделано, прежде чем закрывать консольное приложение. Нет необходимости в специальных петлях или наружных конечностях.

Изменить: включить решение Эндрю для необъяснимых исключений.

Вы можете сделать это без необходимости использования внешних библиотек, выполнив следующие действия:

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();
}

Во время компиляции асинхронный метод точки входа будет переведен для вызова 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 года обновление 3) вводит основной асинхронный

Ты можешь написать:

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

Для получения дополнительной информации C # 7 Series, часть 2: Async Main

Обновить:

Вы можете получить ошибку компиляции:

Программа не содержит статического метода Main, подходящего для точки входа

Эта ошибка связана с тем, что vs2017.3 по умолчанию настроен как c # 7.0, а не c # 7.1.

Вы должны явно изменить настройки вашего проекта, чтобы установить функции c # 7.1.

Вы можете установить c # 7.1 двумя способами:

Способ 1. Использование окна настроек проекта:

• Откройте настройки вашего проекта
• Выберите вкладку Build
• Нажмите кнопку Дополнительно
• Выберите нужную версию, как показано на следующем рисунке:

Метод 2: Изменить PropertyGroup .csproj вручную

Добавьте это свойство:

    <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 .
• Поддержка отмены, как сказал Кори .
• Секунда CTRL+Cдолжна немедленно прекратить процесс. (Спасибо, Бинки !)
• Ручка 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. Task.Run () для .NET 4.5

2. Task.Factory.StartNew () для .NET 4.0 (может потребоваться библиотека Microsoft.Bcl.Async для асинхронных и ожидающих ключевых слов)

Подробности: http://blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

В Main попробуйте изменить вызов GetList на:

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

Когда был представлен CTP 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.1or C# latest minor version. Для этого перейдите в Свойства проекта -> Сборка -> Дополнительно -> Языковая версия.

После этого будет работать следующий код:

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

В MSDN документация для метода Task.Run (Action) предоставляет этот пример, который показывает, как асинхронно запускать метод из 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 .

Что касается потока, в котором выполняется задача, также обратите внимание на комментарий Стивена к его ответу:

Вы можете использовать простой Waitили Result, и в этом нет ничего плохого. Но имейте asyncв виду, что есть два важных различия: 1) все продолжения выполняются в пуле потоков, а не в основном потоке, и 2) все исключения помещаются в AggregateException.

(См. Обработка исключений (Task Parallel Library) для получения информации о том, как включить обработку исключений для работы с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

Обратите внимание, что вместо того, чтобы передавать delegateв Task.Run, вы можете вместо этого передавать лямбда-функцию следующим образом:

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

Чтобы избежать зависания при вызове функции где-нибудь в стеке вызовов, которая пытается повторно присоединиться к текущему потоку (который застрял в ожидании), вам необходимо сделать следующее:

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 ...
}