Pomijanie „ostrzeżenia CS4014: ponieważ to wywołanie nie jest oczekiwane, wykonywanie bieżącej metody jest kontynuowane…”

To nie jest duplikat „Jak bezpiecznie wywołać metodę asynchroniczną w języku C # bez oczekiwania” .

Jak ładnie ukryć poniższe ostrzeżenie?

ostrzeżenie CS4014: Ponieważ to wywołanie nie jest oczekiwane, wykonywanie bieżącej metody jest kontynuowane przed zakończeniem wywołania. Rozważ zastosowanie operatora „await” do wyniku wywołania.

Prosty przykład:

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

Co próbowałem i nie podobało się:

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
    // ...
}

Zaktualizowano , ponieważ pierwotnie zaakceptowana odpowiedź została edytowana, zmieniłem zaakceptowaną odpowiedź na tę, która używa odrzuconych C # 7.0 , ponieważ uważam, że nie ContinueWithjest tu odpowiednia. Ilekroć muszę rejestrować wyjątki dla operacji „wystrzel i zapomnij”, używam bardziej złożonego podejścia zaproponowanego przez Stephena Cleary'ego .

Dzięki C # 7 możesz teraz używać odrzutów :

_ = WorkAsync();

Możesz utworzyć metodę rozszerzenia, która zapobiegnie pojawieniu się ostrzeżenia. Metoda rozszerzenia może być pusta lub można tam dodać obsługę wyjątków .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();
}

Jednak ASP.NET liczy liczbę uruchomionych zadań, więc nie będzie działać z prostym Forget()rozszerzeniem wymienionym powyżej i zamiast tego może się nie powieść z wyjątkiem:

Asynchroniczny moduł lub procedura obsługi została zakończona, gdy operacja asynchroniczna nadal była w toku.

W przypadku .NET 4.5.2 można to rozwiązać za pomocą 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));
}

Możesz ozdobić metodę następującym atrybutem:

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

Zasadniczo mówisz kompilatorowi, że wiesz, co robisz i nie musisz się martwić o możliwy błąd.

Ważną częścią tego kodu jest drugi parametr. Część „CS4014:” pomija ostrzeżenie. W pozostałej części możesz napisać, co chcesz.

Moje dwa sposoby radzenia sobie z tym.

Zapisz go w zmiennej discard (C # 7)

Przykład

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

Od czasu wprowadzenia odrzutów w C # 7, teraz uważam, że jest to lepsze niż wyłączenie ostrzeżenia. Ponieważ nie tylko tłumi ostrzeżenie, ale także sprawia, że ​​zamiar ognia i zapomnienia jest jasny.

Ponadto kompilator będzie mógł go zoptymalizować w trybie wydania.

Po prostu stłum to

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

jest wystarczająco dobrym rozwiązaniem, aby „odpalić i zapomnieć”.

Powodem, dla którego istnieje to ostrzeżenie, jest to, że w wielu przypadkach nie jest Twoim zamiarem użycie metody, która zwraca zadanie bez czekania na to. Powstrzymywanie ostrzeżenia, gdy zamierzasz strzelać i zapomnieć, ma sens.

Jeśli masz problemy z zapamiętaniem pisowni #pragma warning disable 4014, po prostu pozwól programowi Visual Studio dodać to za Ciebie. Naciśnij Ctrl +. aby otworzyć „Szybkie akcje”, a następnie „Pomiń CS2014”

W sumie

Głupotą jest tworzenie metody, której wykonanie wymaga jeszcze kilku tików, tylko w celu zniesienia ostrzeżenia.

Łatwym sposobem na zatrzymanie ostrzeżenia jest po prostu przypisanie zadania podczas jego wywoływania:

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

I tak w swoim oryginalnym poście zrobiłbyś:

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

Przyczyną ostrzeżenia jest to, Taskże WorkAsync zwraca komunikat, który nigdy nie jest odczytywany ani oczekiwany. Możesz ustawić zwracany typ WorkAsync na, voida ostrzeżenie zniknie.

Zazwyczaj metoda zwraca a, Taskgdy wywołujący musi znać status procesu roboczego. W przypadku odpalenia i zapomnienia, void powinien zostać zwrócony, aby przypominał, że wywołujący jest niezależny od wywoływanej metody.

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

Dlaczego nie zawinąć go w metodę asynchroniczną, która zwraca wartość void? Trochę za długie, ale używane są wszystkie zmienne.

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

Dziś znalazłem to podejście przez przypadek. Możesz zdefiniować delegata i najpierw przypisać metodę asynchroniczną do delegata.

    delegate Task IntermediateHandler();



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

i tak to nazwij

(new IntermediateHandler(AsyncOperation))();

...

Pomyślałem, że to interesujące, że kompilator nie dałby dokładnie tego samego ostrzeżenia podczas korzystania z delegata.