"wait" funziona, ma la chiamata all'attività. Il risultato si blocca / si blocca

Ho i seguenti quattro test e l'ultimo si blocca quando lo eseguo. Perché succede:

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

Uso questo metodo di estensione per 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; }
}

Perché l'ultimo test si blocca?

Ti stai imbattendo nella situazione di deadlock standard che descrivo sul mio blog e in un articolo di MSDN : il asyncmetodo sta tentando di pianificare la sua continuazione su un thread bloccato dalla chiamata a Result.

In questo caso, il tuo SynchronizationContextè quello utilizzato da NUnit per eseguire async voidi metodi di test. async TaskProverei invece a utilizzare metodi di test.

Acquisizione di un valore tramite un metodo asincrono:

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

Chiamata sincrona di un metodo asincrono

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

Non si verificheranno problemi di deadlock a causa dell'utilizzo di Task.Run.

Puoi evitare di aggiungere deadlock ConfigureAwait(false)a questa riga:

IRestResponse<DummyServiceStatus> response = await restResponse;

=>

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

Ho descritto questa trappola nel mio post sul blog Trappole di async / await

Stai bloccando l'interfaccia utente utilizzando la proprietà Task.Result. Nella documentazione MSDN hanno chiaramente menzionato che,

"La proprietà Result è una proprietà di blocco. Se provi ad accedervi prima che la sua attività sia terminata, il thread attualmente attivo è bloccato fino al completamento dell'attività e il valore è disponibile. Nella maggior parte dei casi, dovresti accedere al valore utilizzando Await o attendere invece di accedere direttamente alla proprietà. "

La soluzione migliore per questo scenario sarebbe rimuovere sia await che async dai metodi e utilizzare solo Task in cui stai restituendo il risultato. Non rovinerà la tua sequenza di esecuzione.

Se non ricevi alcun callback o il controllo riattacca, dopo aver chiamato la funzione asincrona servizio / API, devi configurare Context per restituire un risultato sullo stesso contesto chiamato.

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

Dovrai affrontare questo problema solo nelle applicazioni web, ma non in static void main.