Tidak dapat menentukan pengubah 'async' pada metode 'Utama' pada aplikasi konsol

Saya baru mengenal pemrograman asinkron dengan asyncpengubah. Saya mencoba mencari cara untuk memastikan bahwa Mainmetode aplikasi konsol saya benar-benar berjalan secara tidak sinkron.

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

Saya tahu ini tidak berjalan secara tidak sinkron dari "atas." Karena tidak mungkin untuk menentukan asyncpengubah pada Mainmetode, bagaimana saya bisa menjalankan kode secara tidak mainsinkron?

Seperti yang Anda temukan, di VS11 kompiler akan melarang async Mainmetode. Ini diizinkan (tapi tidak pernah disarankan) di VS2010 dengan CTP Async.

Saya memiliki posting blog baru-baru ini tentang program konsol async / await dan asynchronous pada khususnya. Berikut beberapa informasi latar belakang dari pos pengantar:

Jika "menunggu" melihat bahwa yang ditunggu belum selesai, maka ia bertindak secara serempak. Ini memberitahu yang ditunggu untuk menjalankan sisa metode ketika selesai, dan kemudian kembali dari metode async. Menunggu juga akan menangkap konteks saat ini ketika melewati sisa metode ke menunggu.

Kemudian, ketika selesai menunggu, itu akan mengeksekusi sisa metode async (dalam konteks yang ditangkap).

Inilah mengapa ini menjadi masalah dalam program Konsol dengan async Main:

Ingat dari pos intro kami bahwa metode async akan kembali ke pemanggilnya sebelum selesai. Ini berfungsi dengan baik di aplikasi UI (metode ini hanya kembali ke loop peristiwa UI) dan aplikasi ASP.NET (metode ini kembali dari utas tetapi menjaga permintaan tetap hidup). Itu tidak bekerja dengan baik untuk program-program Konsol: Main kembali ke OS - jadi program Anda keluar.

Salah satu solusinya adalah menyediakan konteks Anda sendiri - "loop utama" untuk program konsol Anda yang kompatibel dengan async.

Jika Anda memiliki mesin dengan CTP Async, Anda dapat menggunakan GeneralThreadAffineContextdari My Documents \ Microsoft Visual Studio Async CTP \ Sampel (C # Testing) Unit Testing \ AsyncTestUtilities . Atau, Anda dapat menggunakan AsyncContextdari paket NuGet Nito.AsyncEx saya .

Berikut ini contoh menggunakan AsyncContext; GeneralThreadAffineContextmemiliki penggunaan yang hampir identik:

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

Atau, Anda bisa memblokir utas Konsol utama sampai pekerjaan asinkron Anda selesai:

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

Perhatikan penggunaan GetAwaiter().GetResult(); ini menghindari AggregateExceptionpembungkus yang terjadi jika Anda menggunakan Wait()atau Result.

Pembaruan, 2017-11-30: Pada Visual Studio 2017 Pembaruan 3 (15,3), bahasa sekarang mendukung async Main- selama kembali Taskatau Task<T>. Jadi sekarang Anda dapat melakukan ini:

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

Semantik tampaknya sama dengan GetAwaiter().GetResult()gaya memblokir utas. Namun, belum ada spesifikasi bahasa untuk C # 7.1, jadi ini hanya asumsi.

Anda dapat menyelesaikan ini dengan konstruksi sederhana ini:

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

Itu akan menempatkan semua yang Anda lakukan di ThreadPool di tempat yang Anda inginkan (jadi Tugas lain yang Anda mulai / tunggu jangan mencoba untuk bergabung kembali dengan Thread yang seharusnya tidak mereka lakukan), dan tunggu sampai semuanya selesai sebelum menutup aplikasi Konsol. Tidak perlu untuk loop khusus atau lib luar.

Sunting: Memasukkan solusi Andrew untuk Pengecualian yang tidak tertangkap.

Anda dapat melakukan ini tanpa perlu perpustakaan eksternal juga dengan melakukan hal berikut:

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

Dalam C # 7.1 Anda akan dapat melakukan Main async yang tepat . Tanda tangan yang sesuai untuk Mainmetode telah diperluas ke:

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

Misalnya Anda bisa melakukan:

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

Pada waktu kompilasi, metode titik masuk async akan diterjemahkan ke panggilan GetAwaitor().GetResult() .

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

EDIT:

Untuk mengaktifkan fitur bahasa C # 7.1, Anda perlu klik kanan pada proyek dan klik "Properties" lalu pergi ke tab "Build". Di sana, klik tombol lanjutan di bagian bawah:

Dari menu tarik-turun versi bahasa, pilih "7.1" (atau nilai yang lebih tinggi):

Standarnya adalah "versi utama terbaru" yang akan mengevaluasi (pada saat penulisan ini) ke C # 7.0, yang tidak mendukung async utama di aplikasi konsol.

Saya akan menambahkan fitur penting yang diabaikan semua jawaban lainnya: pembatalan.

Salah satu hal besar dalam TPL adalah dukungan pembatalan, dan aplikasi konsol memiliki metode pembatalan bawaan (CTRL + C). Sangat mudah untuk mengikat mereka bersama. Ini adalah bagaimana saya menyusun semua aplikasi konsol async saya:

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 (menggunakan vs 2017 pembaruan 3) memperkenalkan async main

Kamu bisa menulis:

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

Untuk detail lebih lanjut C # 7 Series, Bagian 2: Async Main

Memperbarui:

Anda mungkin mendapatkan kesalahan kompilasi:

Program tidak mengandung metode 'Utama' statis yang cocok untuk titik masuk

Kesalahan ini disebabkan bahwa vs2017.3 dikonfigurasi secara default sebagai c # 7.0 bukan c # 7.1.

Anda harus secara eksplisit mengubah pengaturan proyek Anda untuk menetapkan fitur c # 7.1.

Anda dapat mengatur c # 7.1 dengan dua metode:

Metode 1: Menggunakan jendela pengaturan proyek:

• Buka pengaturan proyek Anda
• Pilih tab Bangun
• Klik tombol Lanjut
• Pilih versi yang Anda inginkan Seperti yang ditunjukkan pada gambar berikut:

Metode2: Ubah PropertyGroup dari .csproj secara manual

Tambahkan properti ini:

    <LangVersion>7.1</LangVersion>

contoh:

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

Jika Anda menggunakan C # 7.1 atau lebih baru, pergilah dengan jawaban nawfal dan cukup ubah jenis pengembalian metode Utama Anda ke Taskatau Task<int>. Jika tidak:

• Miliki async Task MainAsync seperti kata Johan .
• Sebut .GetAwaiter().GetResult()untuk menangkap pengecualian yang mendasarinya seperti kata do0g .
• Mendukung pembatalan seperti kata Cory .
• Yang kedua CTRL+Charus segera menghentikan proses. (Terima kasih binki !)
• Tangani OperationCancelledException- kembalikan kode kesalahan yang sesuai.

Kode akhir terlihat seperti:

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

Belum terlalu membutuhkan ini, tetapi ketika saya telah menggunakan aplikasi konsol untuk tes cepat dan diperlukan async saya baru saja menyelesaikannya seperti ini:

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

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

Untuk tugas panggilan yang tidak sinkron dari Utama, gunakan

1. Tugas.Jalankan () untuk .NET 4.5

2. Task.Factory.StartNew () untuk .NET 4.0 (Mungkin memerlukan perpustakaan Microsoft.Bcl.Async untuk async dan menunggu kata kunci)

Detail: http://blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

Di Utama, coba ubah panggilan ke GetList ke:

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

Ketika C # 5 CTP diperkenalkan, Anda tentu bisa menandai Main denganasync ... meskipun itu umumnya bukan ide yang baik untuk melakukannya. Saya percaya ini diubah oleh rilis VS 2013 menjadi kesalahan.

Kecuali jika Anda telah memulai utas latar depan lainnya , program Anda akan keluar saat Mainselesai, bahkan jika itu memulai beberapa pekerjaan latar belakang.

Apa yang sebenarnya ingin Anda lakukan? Perhatikan bahwa GetList()metode Anda benar-benar tidak perlu async saat ini - itu menambahkan lapisan tambahan tanpa alasan nyata. Secara logis setara dengan (tetapi lebih rumit dari):

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

Versi terbaru dari C # - C # 7.1 memungkinkan untuk membuat aplikasi konsol async. Untuk mengaktifkan C # 7.1 dalam proyek, Anda harus meningkatkan VS Anda ke setidaknya 15,3, dan mengubah versi C # ke C# 7.1atau C# latest minor version. Untuk melakukannya, buka Properti proyek -> Bangun -> Tingkat Lanjut -> Versi bahasa.

Setelah ini, kode berikut akan berfungsi:

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

Pada MSDN, dokumentasi untuk Metode Task.Run (Tindakan) memberikan contoh ini yang menunjukkan cara menjalankan metode secara asinkron dari 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

Perhatikan pernyataan ini yang mengikuti contoh:

Contoh menunjukkan bahwa tugas asinkron dijalankan pada utas berbeda dari utas aplikasi utama.

Jadi, jika Anda ingin tugas dijalankan di utas aplikasi utama, lihat jawabannya oleh @StephenCleary .

Dan mengenai utas tempat tugas itu berjalan, perhatikan juga komentar Stephen tentang jawabannya:

Anda bisa menggunakan yang sederhana Waitatau Result, dan tidak ada yang salah dengan itu. Tetapi perlu diketahui bahwa ada dua perbedaan penting: 1) semua asynckelanjutan berjalan di kolam utas daripada utas utama, dan 2) setiap pengecualian dibungkus dalam AggregateException.

(Lihat Penanganan Pengecualian (Perpustakaan Tugas Paralel) untuk cara menggabungkan penanganan pengecualian untuk menangani AggregateException.)

Akhirnya, di MSDN dari dokumentasi untuk Metode Task.Delay (TimeSpan) , contoh ini menunjukkan cara menjalankan tugas asinkron yang mengembalikan nilai:

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

Perhatikan bahwa alih-alih meneruskan delegateke Task.Run, Anda dapat meneruskan fungsi lambda seperti ini:

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

Untuk menghindari pembekuan ketika Anda memanggil suatu fungsi di suatu tempat di tumpukan panggilan yang mencoba untuk bergabung kembali dengan utas saat ini (yang terjebak dalam Tunggu), Anda perlu melakukan hal berikut:

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

(Para pemain hanya diminta untuk menyelesaikan ambiguitas)

Dalam kasus saya, saya memiliki daftar pekerjaan yang ingin saya jalankan di async dari metode utama saya, telah menggunakan ini dalam produksi selama beberapa waktu dan berfungsi dengan baik.

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