Bỏ qua cảnh báo của CS4014: Vì cuộc gọi này không được chờ đợi, nên việc thực hiện phương thức hiện tại vẫn tiếp tục

Đây không phải là bản sao của "Cách gọi phương thức async một cách an toàn trong C # mà không phải chờ đợi" .

Làm thế nào để tôi tuyệt đối ngăn chặn cảnh báo sau đây?

cảnh báo CS4014: Vì cuộc gọi này không được chờ đợi, nên việc thực hiện phương thức hiện tại tiếp tục trước khi cuộc gọi được hoàn thành. Cân nhắc áp dụng toán tử 'await' cho kết quả của cuộc gọi.

Một ví dụ đơn giản:

static async Task WorkAsync()
{
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

static async Task StartWorkAsync()
{
    WorkAsync(); // I want fire-and-forget 

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Những gì tôi đã thử và không thích:

static async Task StartWorkAsync()
{
    #pragma warning disable 4014
    WorkAsync(); // I want fire-and-forget here
    #pragma warning restore 4014
    // ...
}

static async Task StartWorkAsync()
{
    var ignoreMe = WorkAsync(); // I want fire-and-forget here
    // ...
}

Đã cập nhật , vì câu trả lời được chấp nhận ban đầu đã được chỉnh sửa, tôi đã thay đổi câu trả lời được chấp nhận thành câu trả lời bằng cách sử dụng loại bỏ C # 7.0 , vì tôi không nghĩ ContinueWithlà phù hợp ở đây. Bất cứ khi nào tôi cần ghi lại các trường hợp ngoại lệ cho các hoạt động quên và quên, tôi sử dụng một phương pháp phức tạp hơn được đề xuất bởi Stephen Cleary tại đây .

Với C # 7, giờ đây bạn có thể sử dụng loại bỏ :

_ = WorkAsync();

Bạn có thể tạo một phương thức mở rộng sẽ ngăn cảnh báo. Phương thức mở rộng có thể trống hoặc bạn có thể thêm xử lý ngoại lệ với .ContinueWith()đó.

static class TaskExtensions
{
    public static void Forget(this Task task)
    {
        task.ContinueWith(
            t => { WriteLog(t.Exception); },
            TaskContinuationOptions.OnlyOnFaulted);
    }
}

public async Task StartWorkAsync()
{
    this.WorkAsync().Forget();
}

Tuy nhiên, ASP.NET tính số lượng tác vụ đang chạy, do đó, nó sẽ không hoạt động với Forget()phần mở rộng đơn giản như được liệt kê ở trên và thay vào đó có thể thất bại với ngoại lệ:

Một mô-đun hoặc trình xử lý không đồng bộ hoàn thành trong khi một hoạt động không đồng bộ vẫn đang chờ xử lý.

Với .NET 4.5.2, nó có thể được giải quyết bằng cách sử dụng HostingEnvironment.QueueBackgroundWorkItem:

public static Task HandleFault(this Task task, CancellationToken cancelToken)
{
    return task.ContinueWith(
        t => { WriteLog(t.Exception); },
        cancelToken,
        TaskContinuationOptions.OnlyOnFaulted,
        TaskScheduler.Default);
}

public async Task StartWorkAsync()
{
    System.Web.Hosting.HostingEnvironment.QueueBackgroundWorkItem(
        cancelToken => this.WorkAsync().HandleFault(cancelToken));
}

Bạn có thể trang trí phương thức với thuộc tính sau:

[System.Diagnostics.CodeAnalysis.SuppressMessage("Await.Warning", "CS4014:Await.Warning")]
static async Task StartWorkAsync()
{
    WorkAsync();
    // ...
}

Về cơ bản, bạn đang nói với trình biên dịch rằng bạn biết những gì bạn đang làm và nó không cần phải lo lắng về sai lầm có thể xảy ra.

Phần quan trọng của mã này là tham số thứ hai. Phần "CS4014:" là phần ngăn chặn cảnh báo. Bạn có thể viết bất cứ điều gì bạn muốn trên phần còn lại.

Hai cách của tôi để đối phó với điều này.

Lưu nó vào một biến loại bỏ (C # 7)

Thí dụ

_ = Task.Run(() => DoMyStuff()).ConfigureAwait(false);

Kể từ khi giới thiệu loại bỏ trong C # 7, bây giờ tôi cho rằng điều này tốt hơn là áp dụng cảnh báo. Bởi vì nó không chỉ thay thế cảnh báo, mà còn làm cho ý định cháy và quên rõ ràng.

Hơn nữa, trình biên dịch sẽ có thể tối ưu hóa nó đi trong chế độ phát hành.

Chỉ cần đàn áp nó

#pragma warning disable 4014
...
#pragma warning restore 4014

là một giải pháp đủ tốt để "đốt và quên".

Lý do tại sao cảnh báo này tồn tại là vì trong nhiều trường hợp, bạn không có ý định sử dụng một phương thức trả về nhiệm vụ mà không chờ đợi nó. Ức chế cảnh báo khi bạn có ý định bắn và quên có ý nghĩa.

Nếu bạn gặp khó khăn khi nhớ cách đánh vần #pragma warning disable 4014, chỉ cần để Visual Studio thêm nó cho bạn. Nhấn Ctrl +. để mở "Thao tác nhanh" và sau đó "Bỏ qua CS2014"

Tất cả trong tất cả

Thật ngu ngốc khi tạo ra một phương thức cần thêm một vài tích tắc để thực hiện, chỉ với mục đích triệt tiêu cảnh báo.

Một cách dễ dàng để dừng cảnh báo là chỉ cần gán Nhiệm vụ khi gọi nó:

Task fireAndForget = WorkAsync(); // No warning now

Và trong bài viết gốc của bạn, bạn sẽ làm:

static async Task StartWorkAsync()
{
    // Fire and forget
    var fireAndForget = WorkAsync(); // Tell the compiler you know it's a task that's being returned 

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Lý do cảnh báo là WorkAsync đang trả lại một Taskthứ không bao giờ được đọc hoặc chờ đợi. Bạn có thể đặt loại trả về WorkAsync thành voidvà cảnh báo sẽ biến mất.

Thông thường một phương thức trả về một Taskkhi người gọi cần biết trạng thái của công nhân. Trong trường hợp quên và quên, khoảng trống sẽ được trả về để giống với việc người gọi độc lập với phương thức được gọi.

static async void WorkAsync()
{
    await Task.Delay(1000);
    Console.WriteLine("Done!");
}

static async Task StartWorkAsync()
{
    WorkAsync(); // no warning since return type is void

    // more unrelated async/await stuff here, e.g.:
    // ...
    await Task.Delay(2000); 
}

Tại sao không bọc nó bên trong một phương thức async trả về void? Một chút dài nhưng tất cả các biến được sử dụng.

static async Task StartWorkAsync()
{   
     async void WorkAndForgetAsync() => await WorkAsync();
     WorkAndForgetAsync(); // no warning
}

Tôi tìm thấy phương pháp này một cách tình cờ ngày hôm nay. Bạn có thể xác định một ủy nhiệm và gán phương thức async cho đại biểu trước.

    delegate Task IntermediateHandler();



    static async Task AsyncOperation()
    {
        await Task.Yield();
    }

và gọi nó như vậy

(new IntermediateHandler(AsyncOperation))();

...

Tôi nghĩ thật thú vị khi trình biên dịch sẽ không đưa ra cảnh báo chính xác tương tự khi sử dụng đại biểu.