Bir konsol uygulamasının 'Ana' yönteminde 'zaman uyumsuz' değiştirici belirtilemiyor

asyncDeğiştirici ile eşzamansız programlamada yeniyim. MainBir konsol uygulaması yöntemimin asenkron olarak çalıştığından nasıl emin olacağımı anlamaya çalışıyorum .

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

Bunun "üstten" senkronize olmayan bir şekilde çalışmadığını biliyorum. Yöntemde asyncdeğiştiriciyi belirtmek mümkün olmadığından Main, kodu maineşzamansız olarak nasıl çalıştırabilirim ?

Bildiğiniz gibi, VS11'de derleyici bir async Mainyönteme izin vermeyecektir . Bu, Async CTP ile VS2010'da izin verildi (ancak asla tavsiye edilmedi).

Özellikle async / await ve asenkron konsol programları ile ilgili son blog yayınlarım var . Giriş yazısından bazı arka plan bilgileri:

"Bekliyor", beklemenin tamamlanmadığını görürse, eşzamansız olarak hareket eder. Tamamlandığında yöntemin geri kalanını çalıştırmayı bekler ve ardından zaman uyumsuz yöntemden döner . Await, yöntemin geri kalanını beklenebilir duruma geçirdiğinde mevcut bağlamı da yakalayacaktır .

Daha sonra, beklenen işlem tamamlandığında, async yönteminin geri kalanını (yakalanan bağlam dahilinde) yürütür.

Konsol programlarında aşağıdakilere neden olan bir sorundur async Main:

Giriş yazımızdan, bir zaman uyumsuz yöntemin tamamlanmadan önce arayanına döneceğini unutmayın . Bu, UI uygulamalarında (yöntem yalnızca UI olay döngüsüne geri döner) ve ASP.NET uygulamalarında (yöntem iş parçacığını döndürür ancak isteği canlı tutar) mükemmel çalışır. Konsol programları için pek işe yaramaz: Ana işletim sistemine döner - böylece programınız kapanır.

Çözümlerden biri, kendi içeriğinizi sağlamaktır - konsol programınız için zaman uyumsuz uyumlu bir "ana döngü".

Eğer zaman uyumsuz CTP ile bir makine varsa, kullanabilirsiniz GeneralThreadAffineContextgelen Belgelerim \ Microsoft Visual Studio Async CTP \ Numuneler (C # Test) Birim Testi \ AsyncTestUtilities . Alternatif olarak, kullanabilirsiniz AsyncContextdan benim Nito.AsyncEx Nuget paketinde .

İşte bir örnek AsyncContext; GeneralThreadAffineContextneredeyse aynı kullanıma sahiptir:

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

Alternatif olarak, zaman uyumsuz çalışmanız tamamlanana kadar ana Konsol iş parçacığını engelleyebilirsiniz:

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

Kullanımı GetAwaiter().GetResult(); bu, veya AggregateExceptionkullanırsanız gerçekleşen sargıyı önler .Wait()Result

Güncelleme, 2017/11/30: Visual Studio 2017 Güncelleme 3 (15.3) itibariyle dil artık destekler async Main- sürece döner olarak Taskveya Task<T>. Şimdi bunu yapabilirsiniz:

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

Anlambilim GetAwaiter().GetResult(), ana iş parçacığını engelleme stiliyle aynı görünmektedir . Bununla birlikte, C # 7.1 için henüz bir dil spesifikasyonu yoktur, bu yüzden bu sadece bir varsayımdır.

Bunu bu basit yapı ile çözebilirsiniz:

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

Bu, ThreadPool'a yaptığınız her şeyi istediğiniz yere koyacaktır (böylece başlattığınız / beklediğiniz diğer Görevler, yapmamaları gereken bir Konuya yeniden katılmaya çalışmaz) ve Konsol uygulamasını kapatmadan önce her şeyin bitmesini bekleyin. Özel döngülere veya dışarıdaki kütüphanelere gerek yoktur.

Düzenleme: Yakalanmamış İstisnalar için Andrew çözümünü dahil edin.

Bunu, harici kütüphanelere ihtiyaç duymadan, aşağıdakileri yaparak da yapabilirsiniz:

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'de uygun bir async Main yapabileceksiniz . Yöntem için uygun imzalar aşağıdakilere Maingenişletildi:

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

Örneğin;

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

Derleme zamanında, zaman uyumsuz giriş noktası yöntemi çağrıya çevrilir GetAwaitor().GetResult().

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

DÜZENLE:

C # 7.1 dil özelliklerini etkinleştirmek için, projeyi sağ tıklayıp "Özellikler" i tıklamanız ve "Oluştur" sekmesine gitmeniz gerekir. Orada, alttaki gelişmiş düğmeyi tıklayın:

Dil sürümü açılır menüsünden "7.1" (veya daha yüksek bir değer) seçin:

Varsayılan, konsol uygulamalarında zaman uyumsuz ana işlevi desteklemeyen (bu yazı yazıldığı sırada) C # 7.0'ı değerlendiren "en son ana sürüm" dür.

Diğer tüm cevapların göz ardı ettiği önemli bir özelliği ekleyeceğim: iptal.

TPL'deki en önemli şeylerden biri iptal desteğidir ve konsol uygulamalarında yerleşik bir iptal yöntemi vardır (CTRL + C). Onları birbirine bağlamak çok basit. Tüm zaman uyumsuz konsol uygulamalarımı şu şekilde yapılandırıyorum:

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 (2017 güncelleme 3'e karşı) asenkron ana sistemi tanıtıyor

Yazabilirsin:

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

Daha fazla bilgi için C # 7 Serisi, Bölüm 2: Async Main

Güncelleme:

Bir derleme hatası alabilirsiniz:

Program, bir giriş noktasına uygun statik bir 'Ana' yöntem içermiyor

Bu hata, vs2017.3'ün varsayılan olarak c # 7.1 değil c # 7.0 olarak yapılandırılmasından kaynaklanır.

C # 7.1 özelliklerini ayarlamak için projenizin ayarını açıkça değiştirmeniz gerekir.

C # 7.1'i iki yöntemle ayarlayabilirsiniz:

Yöntem 1: Proje ayarları penceresini kullanma:

• Projenizin ayarlarını açın
• Oluştur sekmesini seçin
• Gelişmiş düğmesini tıklayın
• Aşağıdaki şekilde gösterildiği gibi istediğiniz sürümü seçin:

Yöntem2: .csproj özelliği PropertyGroup'u el ile değiştirme

Bu mülkü ekle:

    <LangVersion>7.1</LangVersion>

misal:

    <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 veya üstünü kullanıyorsanız, nawfal'ın cevabına gidin ve Ana yönteminizin dönüş türünü Taskveya olarak değiştirin Task<int>. Eğer değilseniz:

• Var bir async Task MainAsync Johan gibi söyledi .
• Çağrısını .GetAwaiter().GetResult()yatan durum yakalamak için do0g dediğim gibi .
• Cory'nin dediği gibi destek iptali .
• Bir saniye CTRL+Csüreci derhal sonlandırmalıdır. (Teşekkürler binki !)
• Tanıtıcı OperationCancelledException- uygun bir hata kodu döndürün.

Son kod şöyle görünür:

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

Henüz bu kadar ihtiyaç duymadım, ancak Hızlı testler için konsol uygulamasını kullandığımda ve async gerektirdiğimde bunu şu şekilde çözdüm:

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

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

Main'den eşzamansız olarak arama görevi için şunu kullanın:

1. .NET 4.5 için Task.Run ()

2. .NET 4.0 için Task.Factory.StartNew () (Eşzamansız ve anahtar kelimeleri beklemek için Microsoft.Bcl.Async kitaplığı gerekebilir)

Ayrıntılar: http://blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

Main'de GetList çağrısını şu şekilde değiştirmeyi deneyin:

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

C 5. CTP tanıtıldığında, kesinlikle olabilir ile Main işaretlemekasync ... genellikle bunu yapmak için iyi bir fikir olmamasına rağmen. Bunun VS 2013'ün piyasaya sürülmesiyle bir hata haline geldiğine inanıyorum.

Başka bir ön plan iş parçacığı Mainbaşlatmadıysanız, arka plan çalışması başlatılmış olsa bile programınız tamamlandığında çıkacaktır .

Gerçekten ne yapmaya çalışıyorsun? GetList()Yöntemin şu anda gerçekten zaman uyumsuz olması gerekmediğini unutmayın - gerçek bir sebep olmadan ekstra bir katman ekliyor. Mantıksal olarak eşdeğerdir (ancak daha karmaşıktır):

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

C # - Yeni sürüm C # 7.1 zaman uyumsuz konsol uygulaması oluşturmanıza olanak sağlar. Projede C # 7.1'i etkinleştirmek için VS'nizi en az 15.3'e yükseltmeniz ve C # sürümünü C# 7.1veya olarak değiştirmeniz gerekir.C# latest minor version . Bunu yapmak için Proje özellikleri -> Derleme -> Gelişmiş -> Dil sürümü'ne gidin.

Bundan sonra, aşağıdaki kod çalışacaktır:

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

MSDN'de, Task.Run Yöntemi (Eylem) belgeleri, bir yöntemin eşzamansız olarak nasıl çalıştırılacağını gösteren bu örneği sağlar 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

Örneği izleyen bu ifadeye dikkat edin:

Örnekler, zaman uyumsuz görevin ana uygulama iş parçacığından farklı bir iş parçacığında yürütüldüğünü gösterir.

Bu nedenle, bunun yerine görevin ana uygulama iş parçacığında çalışmasını istiyorsanız, @StephenCleary tarafından verilen cevaba bakın . .

Ve görevin çalıştığı konu ile ilgili olarak, Stephen'ın cevabı hakkındaki yorumuna da dikkat edin :

Sen edebilir bir basit kullanabilir Waitveya Resultve hiçbir şey yanlış bununla var. Ancak, iki önemli fark olduğunu unutmayın: 1) tüm asyncdevamlar ana iş parçacığı yerine iş parçacığı havuzunda çalışır ve 2) tüm istisnalar bir AggregateException.

(Bkz İstisna Yönetimi (Görev) Kitaplığı Paralel bir başa ele istisna dahil etmek nasıl AggregateException.)

Son olarak, MSDN'de Task.Delay Yöntemi (TimeSpan) belgelerinden , bu örnek, bir değer döndüren zaman uyumsuz bir görevin nasıl çalıştırılacağını gösterir:

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

Yerine geçme Not delegateiçin Task.Run, bunun yerine böyle bir lambda fonksiyonu geçirebilirsiniz:

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

Arama yığınının aşağısında, geçerli iş parçacığını yeniden birleştirmeye çalışan (bir Beklemede sıkışmış) bir işlevi çağırdığınızda donmayı önlemek için aşağıdakileri yapmanız gerekir:

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

(oyuncu kadrosu yalnızca belirsizliği çözmek için gereklidir)

Benim durumumda, ana yöntemimden zaman uyumsuz olarak çalıştırmak istediğim işlerin bir listesi vardı, bunu bir süredir üretimde kullanıyor ve iyi çalışıyor.

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