Jaki jest cel „powrotu oczekuj” w C #?

Czy istnieje jakikolwiek scenariusz, w którym pisanie metodę tak:

public async Task<SomeResult> DoSomethingAsync()
{
    // Some synchronous code might or might not be here... //
    return await DoAnotherThingAsync();
}

zamiast tego:

public Task<SomeResult> DoSomethingAsync()
{
    // Some synchronous code might or might not be here... //
    return DoAnotherThingAsync();
}

miałoby sens?

Po co używać return awaitkonstruktora, skoro można bezpośrednio powrócić Task<T>z wewnętrznego DoAnotherThingAsync()wywołania?

Widzę kod return awaitw tak wielu miejscach, myślę, że mogłem coś przeoczyć. Ale o ile rozumiem, nieużywanie słów kluczowych async / czekaj w tym przypadku i bezpośrednie zwrócenie zadania byłoby funkcjonalnie równoważne. Po co dodawać dodatkowy narzut dodatkowej awaitwarstwy?

W jednym przypadku podstępne gdy returnw normalnym sposobem i return awaitw asyncmetodzie zachowują się inaczej: w połączeniu z using(lub, bardziej ogólnie, każdy return awaitw trybloku).

Rozważ te dwie wersje metody:

Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return foo.DoAnotherThingAsync();
    }
}

async Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return await foo.DoAnotherThingAsync();
    }
}

Pierwsza metoda przedmiot jak tylko powróci metodzie, która prawdopodobnie na długo zanim faktycznie kończy. Oznacza to, że pierwsza wersja jest prawdopodobnie wadliwa (ponieważ zostanie usunięta zbyt wcześnie), podczas gdy druga wersja będzie działać poprawnie.Dispose()FooDoAnotherThingAsync()Foo

Jeśli nie potrzebujesz async(tzn. Możesz zwrócić Taskbezpośrednio), nie używaj async.

Jest kilka sytuacji, w których return awaitjest to przydatne, na przykład jeśli masz do wykonania dwie operacje asynchroniczne:

var intermediate = await FirstAsync();
return await SecondAwait(intermediate);

Więcej informacji na temat asyncwydajności można znaleźć w artykule MSDN Stephen Toub i wideo na ten temat.

Aktualizacja: Napisałem post na blogu, który zawiera dużo więcej szczegółów.

Jedynym powodem, dla którego chcesz to zrobić, jest to, że istnieje jakiś inny awaitkod we wcześniejszym kodzie lub jeśli w jakiś sposób manipulujesz wynikiem przed jego zwróceniem. Innym sposobem, w jaki może się to zdarzyć, jest try/catchzmiana sposobu obsługi wyjątków. Jeśli nie robisz nic z tego, masz rację, nie ma powodu, aby dodawać narzut związany z tworzeniem metody async.

Innym przypadkiem, który może wymagać oczekiwania na wynik, jest ten:

async Task<IFoo> GetIFooAsync()
{
    return await GetFooAsync();
}

async Task<Foo> GetFooAsync()
{
    var foo = await CreateFooAsync();
    await foo.InitializeAsync();
    return foo;
}

W tym przypadku, GetIFooAsync() należy poczekać na wynik, GetFooAsyncponieważ typ Tjest różny dla obu metod i Task<Foo>nie można go bezpośrednio przypisać Task<IFoo>. Ale jeśli czekasz na wynik, staje się to,Foo co można bezpośrednio przypisać IFoo. Następnie metoda asynchroniczna po prostu ponownie pakuje wynik wewnątrz Task<IFoo>i od razu.

Uczynienie asynchronicznej prostej metody „thunk” tworzy w pamięci maszynę stanu asynchronicznego, a nie asynchroniczną. Chociaż może to często wskazywać na używanie wersji niesynchronicznej, ponieważ jest bardziej wydajna (co jest prawdą), oznacza to również, że w przypadku zawieszenia nie ma dowodów na to, że ta metoda jest zaangażowana w „stos powrotu / kontynuacji” co czasami utrudnia zrozumienie zawieszenia.

Więc tak, gdy perf nie jest krytyczny (a zwykle nie jest), wyrzucę asynchronię na wszystkie te zwarte metody, dzięki czemu będę mieć maszynę stanu asynchronicznego, która pomoże mi zdiagnozować później, a także, aby upewnić się, że jeśli te metody thunk ewoluują z czasem, z pewnością zwrócą błędne zadania zamiast rzucać.

Jeśli nie użyjesz return, możesz zepsuć ślad stosu podczas debugowania lub gdy jest on drukowany w dziennikach wyjątków.

Po zwróceniu zadania metoda spełniła swój cel i nie znajduje się na stosie wywołań. Podczas używania return awaitpozostawiasz go na stosie połączeń.

Na przykład:

Stos wywołań przy użyciu Oczekiwanie: Oczekiwanie na zadanie od B => B Oczekiwanie na zadanie od C

Stos wywołań, gdy nie jest używany, oczekuje: oczekuje na zadanie z C, które B zwróciło.

To mnie też myli i wydaje mi się, że poprzednie odpowiedzi pomijały twoje aktualne pytanie:

Po co używać komendy return Oczekiwanie na konstrukcję, skoro można bezpośrednio zwrócić zadanie z wewnętrznego wywołania DoAnotherThingAsync ()?

Cóż, czasami tak naprawdę chcesz Task<SomeType>, ale przez większość czasu naprawdę chcesz instancję SomeType, czyli wynik z zadania.

Z Twojego kodu:

async Task<SomeResult> DoSomethingAsync()
{
    using (var foo = new Foo())
    {
        return await foo.DoAnotherThingAsync();
    }
}

Osoba niezaznajomiona ze składnią (na przykład ja) może pomyśleć, że ta metoda powinna zwrócić a Task<SomeResult>, ale ponieważ jest oznaczona async, oznacza to, że jej rzeczywistym typem zwrotu jest SomeResult. Jeśli po prostu użyjesz return foo.DoAnotherThingAsync(), zwrócisz zadanie, którego nie można skompilować. Prawidłowym sposobem jest zwrócenie wyniku zadania, więcreturn await .