ไม่สามารถระบุตัวปรับแต่ง 'async' ในวิธีการ 'หลัก' ของแอปคอนโซล

ฉันใหม่สำหรับการเขียนโปรแกรมแบบอะซิงโครนัสกับโมดิ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

ฉันมีบล็อกโพสต์ล่าสุดเกี่ยวกับasync / คอยและโปรแกรมคอนโซลแบบอะซิงโครนัสโดยเฉพาะ นี่คือข้อมูลพื้นหลังบางส่วนจากโพสต์แนะนำ:

หาก "คอย" เห็นว่าการรอคอยยังไม่เสร็จสมบูรณ์ มันบอกให้รอที่จะเรียกใช้ส่วนที่เหลือของวิธีการเมื่อมันเสร็จสมบูรณ์แล้วส่งกลับจากวิธีการ async รอยังจะจับบริบทปัจจุบันเมื่อมันผ่านส่วนที่เหลือของวิธีการที่รอ

ในภายหลังเมื่อเสร็จสิ้นการรอคอยมันจะดำเนินการส่วนที่เหลือของวิธีการ async (ภายในบริบทที่จับ)

นี่คือสาเหตุที่ปัญหานี้เกิดขึ้นในโปรแกรมคอนโซลที่มีasync Main:

จำไว้ว่าจากโพสต์บทนำของเราว่าวิธีการซิงค์จะกลับไปที่ผู้โทรก่อนที่จะเสร็จสมบูรณ์ สิ่งนี้ทำงานได้อย่างสมบูรณ์ในแอปพลิเคชั่น UI (วิธีนี้เพิ่งกลับไปที่ลูปเหตุการณ์ UI) และแอปพลิเคชัน ASP.NET (วิธีการส่งคืนเธรด แต่ยังคงคำขอไว้) มันไม่ได้ผลดีนักสำหรับโปรแกรม Console: หลักกลับไปที่ OS - ดังนั้นโปรแกรมของคุณจึงออก

ทางออกหนึ่งคือการให้บริบทของคุณเอง - "วนรอบหลัก" สำหรับโปรแกรมคอนโซลของคุณที่เข้ากันได้กับ async

ถ้าคุณมีเครื่องที่มี Async CTP คุณสามารถใช้GeneralThreadAffineContextจากMy Documents \ Microsoft Visual Studio Async CTP \ Samples (C # Testing) หน่วยทดสอบ หรือคุณสามารถใช้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 ตรงตามที่คุณต้องการ (เพื่อให้งานอื่น ๆ ที่คุณเริ่ม / รอไม่พยายามเข้าร่วมเธรดที่พวกเขาไม่ควรทำ) และรอจนกระทั่งทุกอย่างเสร็จสิ้นก่อนที่จะปิดแอปคอนโซล ไม่จำเป็นต้องใช้ลูปพิเศษหรือ libs ภายนอก

แก้ไข: รวมโซลูชันของ Andrew สำหรับข้อยกเว้นที่ไม่ได้ตรวจสอบ

คุณสามารถทำได้โดยไม่ต้องใช้ไลบรารีภายนอกด้วยการทำสิ่งต่อไปนี้:

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 คุณจะสามารถทำ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();
}

ที่รวบรวมเวลาวิธีการจุดเข้า async 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 ซึ่งไม่สนับสนุน async main ในแอปคอนโซล

ฉันจะเพิ่มคุณสมบัติที่สำคัญที่คำตอบอื่น ๆ ทั้งหมดมองข้าม: การยกเลิก

สิ่งสำคัญอย่างหนึ่งใน TPL คือการสนับสนุนการยกเลิกและแอปคอนโซลมีวิธีการยกเลิกในตัว (CTRL + C) ง่ายมากที่จะรวมเข้าด้วยกัน นี่คือวิธีที่ฉันจัดโครงสร้างแอปคอนโซล async ทั้งหมดของฉัน:

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) แนะนำหลัก async

คุณสามารถเขียน:

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

สำหรับรายละเอียดเพิ่มเติมC # 7 Series ส่วนที่ 2: หลัก Async

ปรับปรุง:

คุณอาจได้รับข้อผิดพลาดในการรวบรวม:

โปรแกรมไม่มีวิธีการ 'คงที่' ที่เหมาะสมสำหรับจุดเข้าใช้งาน

ข้อผิดพลาดนี้เกิดจากการที่ vs2017.3 มีการกำหนดค่าตามค่าเริ่มต้นเป็น c # 7.0 ไม่ใช่ c # 7.1

คุณควรแก้ไขการตั้งค่าโครงการของคุณอย่างชัดเจนเพื่อตั้งค่าคุณสมบัติ c # 7.1

คุณสามารถตั้งค่า c # 7.1 ได้สองวิธี:

วิธีที่ 1: การใช้หน้าต่างการตั้งค่าโครงการ:

• เปิดการตั้งค่าของโครงการของคุณ
• เลือกแท็บสร้าง
• คลิกปุ่มขั้นสูง
• เลือกรุ่นที่คุณต้องการตามที่แสดงในรูปต่อไปนี้:

วิธีที่ 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 ของและเพียงแค่เปลี่ยนประเภทการกลับมาของหลักวิธีการของคุณไปหรือTask Task<int>หากคุณไม่ได้:

• มีเหมือนโจฮานกล่าวว่าasync Task MainAsync
• เรียกมัน.GetAwaiter().GetResult()เพื่อจับข้อยกเว้นพื้นฐานเช่น do0g กล่าวกล่าวว่า
• ยกเลิกการสนับสนุนเช่นคอรีกล่าวว่า
• วินาทีCTRL+Cควรยุติกระบวนการทันที (ขอบคุณbinki !)
• จัดการ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.
}

ยังไม่ต้องการสิ่งนี้มาก แต่เมื่อฉันใช้แอปพลิเคชันคอนโซลสำหรับการทดสอบอย่างรวดเร็วและจำเป็นต้องใช้ async ฉันเพิ่งแก้ไขได้ดังนี้:

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 สำหรับ async และรอคำหลัก)

รายละเอียด: http://blogs.msdn.com/b/pfxteam/archive/2011/10/24/10229468.aspx

ในหน้าหลักลองเปลี่ยนการโทรไปยัง GetList เป็น:

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

เมื่อเปิดตัว C # 5 CTP คุณสามารถทำเครื่องหมาย Main ได้อย่างแน่นอนasync ... แม้ว่าโดยทั่วไปจะไม่แนะนำให้ทำเช่นนั้น ฉันเชื่อว่าสิ่งนี้มีการเปลี่ยนแปลงโดยการเปิดตัว VS 2013 เพื่อเป็นข้อผิดพลาด

หากคุณไม่ได้เริ่มต้นเธรดเบื้องหน้าอื่น ๆโปรแกรมของคุณจะออกเมื่อ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)
    {
         (...)
    }

บน MSDN เอกสารสำหรับวิธีการ Task.Runแสดงตัวอย่างนี้ซึ่งแสดงวิธีการเรียกใช้เมธอดแบบอะซิงโครนัสจาก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 @StephenCleary

และเกี่ยวกับหัวข้อที่งานดำเนินอยู่ให้สังเกตความคิดเห็นของสตีเฟ่นในคำตอบของเขาด้วย:

คุณสามารถใช้แบบง่าย ๆWaitหรือResultและก็ไม่มีอะไรผิดปกติ แต่ทราบว่ามีสองแตกต่างที่สำคัญ: 1) ทุกasyncตรันบนสระว่ายน้ำด้ายมากกว่าหัวข้อหลักและ 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คุณสามารถส่งผ่านฟังก์ชัน lambda ดังนี้:

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

(นักแสดงจำเป็นต้องแก้ไขความกำกวมเท่านั้น)

ในกรณีของฉันฉันมีรายการของงานที่ฉันต้องการเรียกใช้ใน 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 ...
}