'Warten' funktioniert, aber Task aufrufen. Ergebnis hängt / Deadlocks

Ich habe die folgenden vier Tests und der letzte hängt, wenn ich ihn ausführe. Warum passiert das:

[Test]
public void CheckOnceResultTest()
{
    Assert.IsTrue(CheckStatus().Result);
}

[Test]
public async void CheckOnceAwaitTest()
{
    Assert.IsTrue(await CheckStatus());
}

[Test]
public async void CheckStatusTwiceAwaitTest()
{
    Assert.IsTrue(await CheckStatus());
    Assert.IsTrue(await CheckStatus());
}

[Test]
public async void CheckStatusTwiceResultTest()
{
    Assert.IsTrue(CheckStatus().Result); // This hangs
    Assert.IsTrue(await CheckStatus());
}

private async Task<bool> CheckStatus()
{
    var restClient = new RestClient(@"https://api.test.nordnet.se/next/1");
    Task<IRestResponse<DummyServiceStatus>> restResponse = restClient.ExecuteTaskAsync<DummyServiceStatus>(new RestRequest(Method.GET));
    IRestResponse<DummyServiceStatus> response = await restResponse;
    return response.Data.SystemRunning;
}

Ich benutze diese Erweiterungsmethode für restsharp RestClient :

public static class RestClientExt
{
    public static Task<IRestResponse<T>> ExecuteTaskAsync<T>(this RestClient client, IRestRequest request) where T : new()
    {
        var tcs = new TaskCompletionSource<IRestResponse<T>>();
        RestRequestAsyncHandle asyncHandle = client.ExecuteAsync<T>(request, tcs.SetResult);
        return tcs.Task;
    }
}

public class DummyServiceStatus
{
    public string Message { get; set; }
    public bool ValidVersion { get; set; }
    public bool SystemRunning { get; set; }
    public bool SkipPhrase { get; set; }
    public long Timestamp { get; set; }
}

Warum hängt der letzte Test?

Sie stoßen auf die Standard-Deadlock-Situation, die ich in meinem Blog und in einem MSDN-Artikel beschreibe : Die asyncMethode versucht, ihre Fortsetzung für einen Thread zu planen, der durch den Aufruf von blockiert wird Result.

In diesem Fall SynchronizationContextwird von NUnit async voidTestmethoden ausgeführt. Ich würde async Taskstattdessen versuchen, Testmethoden zu verwenden.

Erfassen eines Werts über eine asynchrone Methode:

var result = Task.Run(() => asyncGetValue()).Result;

Synchrones Aufrufen einer asynchronen Methode

Task.Run( () => asyncMethod()).Wait();

Durch die Verwendung von Task.Run treten keine Deadlock-Probleme auf.

Sie können Deadlocks vermeiden ConfigureAwait(false), die dieser Zeile hinzugefügt werden:

IRestResponse<DummyServiceStatus> response = await restResponse;

=>

IRestResponse<DummyServiceStatus> response = await restResponse.ConfigureAwait(false);

Ich habe diese Fallstricke in meinem Blog-Beitrag Fallstricke von Async / Warten beschrieben

Sie blockieren die Benutzeroberfläche mithilfe der Task.Result-Eigenschaft. In der MSDN-Dokumentation haben sie klar erwähnt, dass

"Die Result- Eigenschaft ist eine blockierende Eigenschaft. Wenn Sie versuchen, vor Abschluss der Aufgabe darauf zuzugreifen, wird der aktuell aktive Thread blockiert, bis die Aufgabe abgeschlossen ist und der Wert verfügbar ist. In den meisten Fällen sollten Sie mit Await auf den Wert zugreifen oder warten, anstatt direkt auf die Unterkunft zuzugreifen. "

Die beste Lösung für dieses Szenario wäre , sowohl das Warten als auch das Asynchronisieren aus den Methoden zu entfernen und nur die Aufgabe zu verwenden, bei der Sie das Ergebnis zurückgeben. Es wird Ihre Ausführungssequenz nicht durcheinander bringen.

Wenn Sie keine Rückrufe erhalten oder das Steuerelement auflegt, müssen Sie nach dem Aufrufen der asynchronen Funktion service / API Context so konfigurieren, dass ein Ergebnis für denselben aufgerufenen Kontext zurückgegeben wird.

Verwenden TestAsync().ConfigureAwait(continueOnCapturedContext: false);

Dieses Problem tritt nur in Webanwendungen auf, nicht jedoch in static void main.