Подавление «предупреждение CS4014: поскольку этот вызов не ожидается, выполнение текущего метода продолжается ...»

Это не дубликат «Как безопасно вызвать асинхронный метод в C # без ожидания» .

Как мне приятно подавить следующее предупреждение?

предупреждение CS4014: поскольку этот вызов не ожидается, выполнение текущего метода продолжается до завершения вызова. Попробуйте применить оператор 'await' к результату вызова.

Простой пример:

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когда вызывающая сторона должна знать статус работника. В случае «забывай и забывай», void должен быть возвращен, чтобы напоминать, что вызывающая сторона независима от вызываемого метода.

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

Почему бы не обернуть его внутри асинхронного метода, который возвращает void? Немного длинный, но все переменные используются.

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

...

Я подумал, что интересно, что компилятор не будет выдавать точно такое же предупреждение при использовании делегата.