เพียงแค่มี VS2012 asyncและพยายามที่จะได้รับการจัดการใน

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

// contrived example (edited in response to Servy's comment)
public static Task<string> PromptForStringAsync(string prompt)
{
    return Task.Factory.StartNew(() => {
        Console.Write(prompt);
        return Console.ReadLine();
    });
}

นี่คือตัวอย่างวิธีการที่เรียกมัน ถ้าPromptForStringAsyncไม่ใช่ async วิธีนี้จะต้องมีการซ้อนการโทรกลับภายในการโทรกลับ ด้วย async ฉันจะเขียนวิธีการของฉันด้วยวิธีที่เป็นธรรมชาตินี้:

public static async Task GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    Console.WriteLine("Welcome {0}.", firstname);

    string lastname = await PromptForStringAsync("Enter your last name: ");
    Console.WriteLine("Name saved as '{0} {1}'.", firstname, lastname);
}

จนถึงตอนนี้ดีมาก ปัญหาคือเมื่อฉันเรียก GetNameAsync:

public static void DoStuff()
{
    GetNameAsync();
    MainWorkOfApplicationIDontWantBlocked();
}

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

Warning 1   Because this call is not awaited, execution of the current method continues before the call is completed. Consider applying the 'await' operator to the result of the call.

ฉันทราบดีว่า "การดำเนินการของวิธีการปัจจุบันยังคงดำเนินต่อไปก่อนที่การโทรจะเสร็จสมบูรณ์" นั่นคือจุดของรหัสอะซิงโครนัสใช่ไหม?

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

public static void DoStuff()
{
    var result = GetNameAsync(); // supress warning
    MainWorkOfApplicationIDontWantBlocked();
}

แต่ตอนนี้ฉันมีรหัสที่ไม่จำเป็น Visual Studio ดูเหมือนจะเข้าใจว่าฉันถูกบังคับให้เขียนโค้ดที่ไม่จำเป็นนี้เนื่องจากมันระงับคำเตือน "ค่าไม่เคยใช้" ปกติ

ฉันยังสามารถกำจัดคำเตือนได้โดยการตัด GetNameAsync ด้วยวิธีการที่ไม่ใช่ async:

    public static Task GetNameWrapper()
    {
        return GetNameAsync();
    }

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

มีบางอย่างเกี่ยวกับการใช้ async ของฉันที่ผิดที่นี่หรือไม่?

หากคุณไม่ต้องการผลลัพธ์จริงๆคุณสามารถเปลี่ยนGetNameAsyncลายเซ็นเพื่อส่งคืนvoid:

public static async void GetNameAsync()
{
    ...
}

พิจารณาเพื่อดูคำตอบสำหรับคำถามที่เกี่ยวข้อง: อะไรคือความแตกต่างระหว่างการคืนค่าโมฆะและการส่งคืนงาน?

อัปเดต

หากคุณต้องการผลลัพธ์คุณสามารถเปลี่ยนGetNameAsyncเพื่อส่งกลับโดยพูดว่าTask<string>:

public static async Task<string> GetNameAsync()
{
    string firstname = await PromptForStringAsync("Enter your first name: ");
    string lastname = await PromptForStringAsync("Enter your last name: ");
    return firstname + lastname;
}

และใช้มันดังนี้:

public static void DoStuff()
{
    Task<string> task = GetNameAsync();

    // Set up a continuation BEFORE MainWorkOfApplicationIDontWantBlocked
    Task anotherTask = task.ContinueWith(r => {
            Console.WriteLine(r.Result);
        });

    MainWorkOfApplicationIDontWantBlocked();

    // OR wait for the result AFTER
    string result = task.Result;
}

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

#pragma warning disable 4014
SomeMethodAsync();
#pragma warning restore 4014

"4014"มาจากหน้านี้ MSDN: คอมไพเลอร์เตือน (ระดับ 1) CS4014

ดูเพิ่มเติมคำเตือน / คำตอบโดย @ ryan-horath นี่https://stackoverflow.com/a/12145047/928483

ข้อยกเว้นที่เกิดขึ้นระหว่างการโทรแบบ async ที่ไม่รอคอยจะหายไป ในการกำจัดคำเตือนนี้คุณควรกำหนดค่าส่งคืนงานของการเรียก async ให้กับตัวแปร สิ่งนี้ทำให้แน่ใจว่าคุณสามารถเข้าถึงข้อยกเว้นใด ๆ ที่เกิดขึ้นซึ่งจะระบุไว้ในค่าส่งคืน

อัปเดตสำหรับ C # 7.0

C # 7.0 เพิ่มคุณสมบัติใหม่ทิ้งตัวแปร: Discards - C # Guideซึ่งสามารถช่วยในเรื่องนี้ได้เช่นกัน

_ = SomeMethodAsync();

ฉันไม่ชอบวิธีแก้ปัญหาที่มอบหมายงานให้กับตัวแปรที่ไม่ได้ใช้หรือเปลี่ยนลายเซ็นวิธีการเพื่อคืนค่าโมฆะ เดิมสร้างโค้ดที่ไม่จำเป็นและไม่ใช้งานง่ายในขณะที่รุ่นหลังอาจไม่สามารถทำได้หากคุณใช้อินเทอร์เฟซหรือมีการใช้งานฟังก์ชันอื่นที่คุณต้องการใช้งานที่ส่งคืน

วิธีแก้ปัญหาของฉันคือการสร้างวิธีการขยายของงานที่เรียกว่า DoNotAwait () ที่ไม่ทำอะไรเลย สิ่งนี้จะไม่เพียง แต่ระงับคำเตือน ReSharper หรืออื่น ๆ เท่านั้น แต่ยังทำให้รหัสเข้าใจได้มากขึ้นและบ่งชี้ให้ผู้ดูแลรักษารหัสของคุณในอนาคตทราบว่าคุณตั้งใจจริงเพื่อไม่ให้มีการรอสาย

วิธีการขยาย:

public static class TaskExtensions
{
    public static void DoNotAwait(this Task task) { }
}

การใช้งาน:

public static void DoStuff()
{
    GetNameAsync().DoNotAwait();
    MainWorkOfApplicationIDontWantBlocked();
}

แก้ไขเพื่อเพิ่ม: สิ่งนี้คล้ายกับโซลูชันของโจนาธานอัลเลนที่วิธีการขยายจะเริ่มงานหากยังไม่ได้เริ่ม แต่ฉันชอบที่จะมีฟังก์ชั่นวัตถุประสงค์เดียวเพื่อให้เจตนาของผู้โทรชัดเจนอย่างสมบูรณ์

async void ไม่ดี!

1. อะไรคือความแตกต่างระหว่างการคืนค่าว่างเปล่าและการคืนงาน?
2. https://jaylee.org/archive/2012/07/08/c-sharp-async-tips-and-tricks-part-2-async-void.html

สิ่งที่ฉันแนะนำคือให้คุณเรียกใช้อย่างชัดเจนTaskผ่านวิธีการไม่ระบุชื่อ ...

เช่น

public static void DoStuff()
{
    Task.Run(async () => GetNameAsync());
    MainWorkOfApplicationIDontWantBlocked();
}

หรือหากคุณไม่ต้องการให้บล็อกคุณสามารถรอด้วยวิธีการไม่ระบุตัวตน

public static void DoStuff()
{
    Task.Run(async () => await GetNameAsync());
    MainWorkOfApplicationThatWillBeBlocked();
}

อย่างไรก็ตามหากGetNameAsyncวิธีการของคุณต้องโต้ตอบกับ UI หรือแม้แต่สิ่งใดก็ตามที่ผูกกับ UI (WINRT / MVVM ฉันกำลังมองหาคุณ) ก็จะได้รับความสนุกสนานเล็กน้อย =)

คุณจะต้องส่งต่อการอ้างอิงถึงตัวเลือกจ่ายงาน UI เช่นนี้ ...

Task.Run(async () => await GetNameAsync(CoreApplication.MainView.CoreWindow.Dispatcher));

จากนั้นในวิธีการ async ของคุณคุณจะต้องโต้ตอบกับ UI หรือองค์ประกอบที่ถูกผูกไว้ของ UI ที่คิดว่าผู้มอบหมายงาน

dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => {  this.UserName = userName; });

นี่คือสิ่งที่ฉันกำลังทำอยู่:

SomeAyncFunction().RunConcurrently();

ที่RunConcurrentlyกำหนดเป็น ...

 /// <summary> 
 /// Runs the Task in a concurrent thread without waiting for it to complete. This will start the task if it is not already running. 
 /// </summary> 
 /// <param name="task">The task to run.</param> 
 /// <remarks>This is usually used to avoid warning messages about not waiting for the task to complete.</remarks> 
 public static void RunConcurrently(this Task task) 
 { 
     if (task == null) 
         throw new ArgumentNullException("task", "task is null."); 

     if (task.Status == TaskStatus.Created) 
         task.Start(); 
 } 

https://github.com/docevaad/Anchor/blob/master/Tortuga.Anchor/Tortuga.Anchor.source/shared/TaskUtilities.cs

https://www.nuget.org/packages/Tortuga.Anchor/

ตามบทความของ Microsoft เกี่ยวกับคำเตือนนี้คุณสามารถแก้ไขได้โดยเพียงแค่มอบหมายงานที่ส่งคืนให้กับตัวแปร ด้านล่างนี้เป็นการแปลรหัสที่ให้ไว้ในตัวอย่างของ Microsoft:

    // To suppress the warning without awaiting, you can assign the 
    // returned task to a variable. The assignment doesn't change how
    // the program runs. However, the recommended practice is always to
    // await a call to an async method.
    // Replace Call #1 with the following line.
    Task delayTask = CalledMethodAsync(delay);

โปรดทราบว่าการทำเช่นนี้จะทำให้เกิดข้อความ "Local variable is never used" ใน ReSharper

นี่คือวิธีง่ายๆ

public static class TasksExtensions
{
    public static void RunAndForget(this Task task)
    {
    }
}

ความนับถือ

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

หากคุณมีบางสิ่งที่เกิดขึ้นโดยแยกจากโปรแกรมอื่น ๆ ทั้งหมด async คงไม่ใช่แนวทางที่ถูกต้อง เพียงเริ่มเธรดใหม่สำหรับงานนั้น

คุณต้องการเพิกเฉยต่อผลลัพธ์หรือไม่? เช่นเดียวกับการละเว้นข้อยกเว้นที่ไม่คาดคิด?

ถ้าไม่ได้คุณอาจต้องการดูที่คำถามนี้: ไฟไหม้และลืมวิธีการ ,

หากคุณไม่ต้องการเปลี่ยนลายเซ็นวิธีที่จะส่งคืนvoid(เนื่องจากการส่งคืนvoidควรเป็นโมฆะเอ็ดเสมอ) คุณสามารถใช้ C # 7.0+ ทิ้งคุณสมบัติเช่นนี้ซึ่งดีกว่าการกำหนดให้กับตัวแปรเล็กน้อย (และควรลบอื่น ๆ คำเตือนเครื่องมือตรวจสอบแหล่งที่มา):

public static void DoStuff()
{
    _ = GetNameAsync(); // we don't need the return value (suppresses warning)
    MainWorkOfApplicationIDontWantBlocked();
}