Async в Program.cs [duplicate]

Вы можете решить эту проблему с помощью этой простой конструкции:

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

Это поместит все, что вы делаете, на ThreadPool, где вы захотите (так что другие Задачи, которые вы запускаете / ожидаете, не пытаются для воссоединения нити они не должны), и дождитесь, пока все будет сделано до закрытия приложения консоли. Нет необходимости в специальных циклах или вне libs.

Изменить: включить решение Андрея для неперехваченных исключений.

В MSDN документация для Task.Run Method (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, и нет ничего плохого в том, что. Но имейте в виду, что существуют два важных отличия: 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

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

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

Я добавлю важную особенность, которую игнорировали все остальные ответы: отмена.

. Одна из больших вещей в 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)
{
    ...
}

В главном случае попробуйте изменить вызов GetList на:

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

Этого еще не нужно, но когда я использовал консольное приложение для быстрых тестов и требуемого async, я просто решил его следующим образом:

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

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

Когда был введен CTP C # 5, вы, конечно, могли бы отметить Main с async ... хотя, как правило, это не очень хорошая идея. Я полагаю, что это было изменено выпуском VS 2013, чтобы стать ошибкой.

Если вы не запустили какие-либо другие потоки foreground , ваша программа выйдет, когда Main завершает работу, даже если он запустил некоторые фоновые работы.

Что вы действительно пытаетесь сделать? Обратите внимание, что ваш метод GetList() действительно не должен быть асинхронным в настоящий момент - он добавляет дополнительный уровень без какой-либо реальной причины. Это логически эквивалентно (но более сложному):

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

Самая новая версия C # - C # 7.1 позволяет создавать консольное приложение async. Чтобы включить C # 7.1 в проекте, вам необходимо обновить VS до не менее 15.3 и изменить версию C # на C# 7.1 или C# latest minor version. Для этого перейдите в Свойства проекта -> Сборка -> Дополнительно -> Языковая версия.

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

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

C # 7.1 (с использованием vs 2017 update 3) вводит async main

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

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

Подробнее C # 7 Series, часть 2: Async Main

Обновление:

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

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

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

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

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

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

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

Способ2: Изменить свойствоGroup .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 вы сможете сделать правильный async 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

EDIT:

Чтобы включить C # 7.1, вам нужно щелкнуть правой кнопкой мыши по проекту и нажать «Свойства», затем перейти на вкладку «Построить». Там нажмите кнопку «Дополнительно» внизу:

В раскрывающемся меню языковой версии выберите «7.1» (или любое более высокое значение) :

По умолчанию используется «последняя основная версия», которая будет оценивать (на момент написания этой статьи) C # 7.0, которая не поддерживает async в консольных приложениях.

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

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

(приведение требуется только для устранения двусмысленности)

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

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 или более позднюю версию, перейдите к ответу nawfal и просто измените тип возврата вашего метода Main на Task или Task<int>. Если вы не:

• У вас есть async Task MainAsync , как сказал Йохан .
• Вызовите его .GetAwaiter().GetResult(), чтобы поймать основное исключение , как do0g сказал .
• Поддержка отмены , как Cory сказал .
• Вторая CTRL+C должна немедленно прекратить процесс. (Спасибо binki !) [/ ​​G8]
• Ручка 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.
}

Для асинхронной задачи вызова из 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

В моем случае у меня был список заданий, которые я хотел запустить в async из моего основного метода, уже давно использовал это в производстве и отлично работает.

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