«Wait» fonctionne, mais l'appel de la tâche. Le résultat se bloque / se bloque

J'ai les quatre tests suivants et le dernier se bloque lorsque je l'exécute. Pourquoi cela arrive-t-il:

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

J'utilise cette méthode d'extension pour 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; }
}

Pourquoi le dernier test se bloque-t-il?

Vous vous heurtez à la situation de blocage standard que je décris sur mon blog et dans un article MSDN : la asyncméthode tente de planifier sa poursuite sur un thread bloqué par l'appel à Result.

Dans ce cas, votre SynchronizationContextest celui utilisé par NUnit pour exécuter async voidles méthodes de test. J'essaierais async Taskplutôt d' utiliser des méthodes de test.

Acquérir une valeur via une méthode asynchrone:

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

Appel synchrone d'une méthode asynchrone

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

Aucun problème de blocage ne se produira en raison de l'utilisation de Task.Run.

Vous pouvez éviter un blocage en ajoutant ConfigureAwait(false)à cette ligne:

IRestResponse<DummyServiceStatus> response = await restResponse;

=>

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

J'ai décrit cet écueil dans mon article de blog Pitfalls of async / await

Vous bloquez l'interface utilisateur à l'aide de la propriété Task.Result. Dans la documentation MSDN, ils ont clairement mentionné que,

"La propriété Result est une propriété bloquante. Si vous essayez d'y accéder avant la fin de sa tâche, le thread actuellement actif est bloqué jusqu'à ce que la tâche se termine et que la valeur soit disponible. Dans la plupart des cas, vous devez accéder à la valeur en utilisant Attendre ou attendez au lieu d'accéder directement à la propriété. "

La meilleure solution pour ce scénario serait de supprimer à la fois wait et async des méthodes et d'utiliser uniquement la tâche où vous renvoyez le résultat. Cela ne gâchera pas votre séquence d'exécution.

Si vous n'obtenez aucun rappel ou si le contrôle se bloque, après avoir appelé la fonction asynchrone du service / API, vous devez configurer Context pour renvoyer un résultat sur le même contexte appelé.

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

Vous serez confronté à ce problème uniquement dans les applications Web, mais pas dans static void main.