Придушення "попередження CS4014: Оскільки цього дзвінка не чекають, виконання поточного методу продовжується ..."

Це не дублікат "Як безпечно викликати метод асинхронізації в C # без очікування" .

Як мені красиво придушити наступне попередження?

попередження CS4014: Оскільки цього дзвінка не чекають, виконання поточного методу продовжується до завершення виклику. Подумайте про застосування оператора "в очікуванні" до результату дзвінка.

Простий приклад:

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

Що я спробував і що не сподобалось:

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 # 7.0 , оскільки не думаю ContinueWith, що тут доречно. Кожного разу, коли мені потрібно реєструвати винятки для операцій із забудовою, то тут я використовую більш детальний підхід, запропонований Стівеном Клірі .

З C # 7 тепер ви можете використовувати викиди :

_ = WorkAsync();

Ви можете створити метод розширення, який запобіжить попередження. Метод розширення може бути порожнім або ви можете додати .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();
}

Однак ASP.NET підраховує кількість запущених завдань, тому він не працюватиме з простим Forget()розширенням, як зазначено вище, і натомість може вийти з ладу за винятком:

Асинхронний модуль або обробник завершено, поки асинхронна операція ще не завершена.

За допомогою .NET 4.5.2 це можна вирішити за допомогою 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));
}

Можна прикрасити метод наступним атрибутом:

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

В основному ви говорите компілятору, що ви знаєте, що робите, і не потрібно турбуватися про можливу помилку.

Важливою частиною цього коду є другий параметр. Частина "CS4014:" - це те, що пригнічує попередження. На решті можна написати що завгодно.

Мій два способи впоратися з цим.

Збережіть її у змінній змінній (C # 7)

Приклад

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

З моменту введення скидів у C # 7, я вважаю це кращим, ніж придушення попередження. Тому що він не тільки пригнічує попередження, але й дає зрозуміти намір пожежі та забути.

Більше того, компілятор зможе оптимізувати його у режимі випуску.

Просто придуши це

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

є досить приємним рішенням "стріляти і забути".

Причина, чому існує таке попередження, полягає в тому, що в багатьох випадках ви не маєте наміру використовувати метод, який повертає завдання, не чекаючи його. Придушення попередження, коли ви дійсно маєте намір стріляти і забути, має сенс.

Якщо у вас виникли проблеми з запам'ятовуванням написання #pragma warning disable 4014, просто дозвольте Visual Studio додати його для вас. Натисніть Ctrl +. відкрити "Швидкі дії", а потім "Придушити CS2014"

Загалом

Дурно створити метод, який потребує виконання ще декількох кліщів, лише з метою придушення попередження.

Простий спосіб зупинки попередження - це просто призначити завдання під час виклику:

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

І так у своєму початковому дописі ви зробите:

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

Причиною попередження є те, що WorkAsync повертає інформацію, Taskяку ніколи не читають і не чекають. Ви можете встановити тип повернення WorkAsync на, voidі попередження зніметься .

Зазвичай метод повертає a, Taskколи абонент повинен знати статус працівника. У випадку пожежі та забуття, недійсність повинна повернутися так, щоб нагадувати, що абонент не залежить від викликаного методу.

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

Чому б не загорнути його всередину методу асинхронізації, який повертає порожнечу? Трохи тривалий, але використовуються всі змінні.

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

Я знайшов такий підхід сьогодні випадково. Ви можете визначити делегата та призначити спочатку делегат метод асинхронізації.

    delegate Task IntermediateHandler();



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

і називати це так

(new IntermediateHandler(AsyncOperation))();

...

Я подумав, що цікаво, що компілятор не видасть таке саме попередження при використанні делегата.