Nie można określić modyfikatora "async" w metodzie "Main" aplikacji konsolowej

Możesz to rozwiązać za pomocą prostej konstrukcji:

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

To spowoduje, że wszystko, co robisz, zostanie umieszczone w ThreadPool tam, gdzie chcesz (aby inne zadania, które rozpoczynasz/oczekujesz, nie próbowały ponownie dołączyć do wątku, którego nie powinni) i poczekaj, aż wszystko zostanie zrobione przed zamknięciem aplikacji konsoli. Nie ma potrzeby stosowania specjalnych pętli lub zewnętrznych bibliotek.

Edit: Włącz rozwiązanie Andrew dla nieobciążonych WYJĄTKÓW.

Możesz to zrobić bez konieczności korzystania z zewnętrznych bibliotek, wykonując następujące czynności:

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

W C # 7.1 będziesz mógł wykonać poprawną asynchroniczną magistralę . Odpowiednie podpisy dla metody Main zostały rozszerzone do:

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

Dla np. możesz robić:

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

Podczas kompilacji, metoda punktu wejścia async zostanie przetłumaczona na call GetAwaitor().GetResult().

Szczegóły: https://blogs.msdn.microsoft.com/mazhou/2017/05/30/c-7-series-part-2-async-main

EDIT:

Aby włączyć funkcje języka C # 7.1, musisz kliknąć prawym przyciskiem myszy na projekcie i kliknij "Właściwości", a następnie przejdź do zakładki" Build". Tam kliknij przycisk Zaawansowane na dole:

Z menu rozwijanego wersja językowa wybierz "7.1" (lub dowolną wyższą wartość):

Domyślną wartością jest "latest major version", która oceniałaby (w momencie pisania tego tekstu) do C# 7.0, który nie obsługuje asynchronicznej wersji głównej w aplikacjach konsolowych.

Dodam ważną cechę, którą wszystkie inne odpowiedzi przeoczyły: anulowanie.

Jedną z ważniejszych rzeczy w TPL jest obsługa anulowania, a aplikacje konsolowe mają wbudowaną metodę anulowania (CTRL + C). Bardzo łatwo je połączyć. Tak układam wszystkie moje aplikacje konsoli asynchronicznej:

static void Main(string[] args)
{
    CancellationTokenSource cts = new CancellationTokenSource();
    
    System.Console.CancelKeyPress += (s, e) =>
    {
        e.Cancel = true;
        cts.Cancel();
    };

    MainAsync(args, cts.Token).GetAwaiter.GetResult();
}

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

[[3]} C # 7.1 (using vs 2017 update 3) wprowadza async main

Możesz napisać:

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

Więcej szczegółów C# 7 Series, Part 2: Async Main

Update:

Może pojawić się błąd kompilacji:

Program nie zawiera statycznej "głównej" metody odpowiedniej dla punktu wejścia

Ten błąd jest spowodowany tym, że vs2017.3 jest domyślnie skonfigurowany jako c # 7.0, a nie c#7.1.

Należy jawnie zmodyfikować ustawienie swojego projekt do Ustawienia funkcji c # 7.1.

Możesz ustawić c # 7.1 za pomocą dwóch metod:

Metoda 1: Korzystanie z okna ustawień projektu:

• Otwórz ustawienia swojego projektu
• wybierz zakładkę budowania
• kliknij przycisk Zaawansowane
• wybierz żądaną wersję Jak pokazano na poniższym rysunku:

Method2: Modify PropertyGroup of .csprojekt

Dodaj to własność:

    <LangVersion>7.1</LangVersion>

Przykład:

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

Jeśli używasz C # 7.1 lub nowszego, wybierz odpowiedź nawfala i po prostu zmień typ zwracanej metody głównej na Task lub Task<int>. Jeśli nie:

• mieć async Task MainAsync Jak powiedział Johan .
• zadzwoń do its .GetAwaiter().GetResult(), aby złapać podstawowy wyjątek , jak powiedział do0g.
• anulowanie wsparcia jak powiedział Cory .
• drugi CTRL+C powinien natychmiast zakończyć proces. (Thanks binki !)
• Uchwyt OperationCancelledException - zwraca odpowiedni kod błędu.

Końcowy kod wygląda następująco:

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

Nie potrzebowałem jeszcze tyle, ale kiedy używałem aplikacji konsolowej do szybkich testów i wymagałem asynchronizacji, rozwiązałem to tak:

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

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

Do asynchronicznie wywołania zadania z Main, użyj

1. Zadanie.Run() for. NET 4.5

2. Zadanie.Fabryka.StartNew () dla. NET 4.0 (może wymagać Microsoft.Bcl.Biblioteka Async dla async i oczekujących słów kluczowych)

Szczegóły: http://blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

W Main spróbuj zmienić wywołanie GetList na:

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

Kiedy C# 5 CTP został wprowadzony, z pewnościąmożna oznaczyć Main przez async... chociaż generalnie nie było to dobrym pomysłem. Uważam, że zostało to zmienione przez wydanie VS 2013, aby stać się błędem.

Jeśli nie uruchomiłeś żadnego innego wątku foreground , twój program zakończy działanie po zakończeniu Main, nawet jeśli rozpoczął pracę w tle.

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

Najnowsza wersja C # - C# 7.1 pozwala na tworzenie aplikacji konsoli asynchronicznej. Aby włączyć C# 7.1 w projekcie, musisz uaktualnić swój VS do co najmniej 15.3 I zmienić wersję C# na C# 7.1 lub C# latest minor version. Aby to zrobić, przejdź do Właściwości projektu - > Build - > Advanced - > Wersja Językowa.

Po tym, następujący kod będzie działać:

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

Na MSDN, dokumentacja dla Zadania.Run Method (Akcja) zawiera ten przykład, który pokazuje, jak uruchomić metodę asynchronicznie z 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

Zwróć uwagę na to stwierdzenie, które podąża za przykładem:

Przykłady pokazują, że zadanie asynchroniczne wykonuje na innym wątek niż główny wątek aplikacji.

Więc jeśli zamiast tego chcesz, aby zadanie zostało uruchomione w głównym wątku aplikacji, Zobacz odpowiedź by @ StephenCleary .

A co do wątku, na którym działa zadanie, zwróć również uwagę na komentarz Stephena na jego odpowiedź:

You can use a simple Wait or Result, and there ' s nothing wrong z tym. Należy jednak pamiętać, że istnieją dwie ważne różnice: 1) wszystkie async kontynuacje działają na puli wątków, a nie na głównym thread, oraz 2) wszelkie wyjątki są zawinięte w AggregateException.

(Zobacz Obsługa Wyjątków (Zadanie Parallel Library) dla tego, jak włączyć obsługę wyjątków do obsługi AggregateException.)

Wreszcie, na MSDN z dokumentacji dla zadania.Metoda Delay (TimeSpan) , ten przykład pokazuje jak uruchomić asynchroniczne zadanie, które zwraca wartość:

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

Zauważ, że zamiast przekazać delegate do Task.Run, możesz zamiast tego przekazać funkcję lambda w następujący sposób:

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

W moim przypadku miałem listę zadań, które chciałem uruchomić w asynchronicznym trybie z mojej głównej metody, używałem tego w produkcji od dłuższego czasu i działa dobrze.

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

Aby uniknąć zamrożenia podczas wywoływania funkcji gdzieś na stosie, która próbuje ponownie dołączyć bieżący wątek( który utknął w oczekiwaniu), musisz wykonać następujące czynności:

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

(obsada jest wymagana tylko do rozwiązania niejednoznaczności)

class Program
{
     public static EventHandler AsyncHandler;
     static void Main(string[] args)
     {
        AsyncHandler+= async (sender, eventArgs) => { await AsyncMain(); };
        AsyncHandler?.Invoke(null, null);
     }

     private async Task AsyncMain()
     {
        //Your Async Code
     }
}