'wait' funciona, mas chama a tarefa. Resultado trava / deadlocks

Eu tenho os quatro testes a seguir e o último trava quando eu o executo. Por que isso acontece:

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

Eu uso esse método de extensão para o 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; }
}

Por que o último teste travou?

Você está enfrentando a situação padrão de conflito que eu descrevo no meu blog e em um artigo do MSDN : o asyncmétodo está tentando agendar sua continuação em um segmento que está sendo bloqueado pela chamada para Result.

Nesse caso, SynchronizationContexté o seu usado pelo NUnit para executar async voidmétodos de teste. Eu tentaria usar async Taskmétodos de teste.

Adquirindo um valor por meio de um método assíncrono:

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

Chamar um método assíncrono de forma síncrona

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

Nenhum problema de conflito ocorrerá devido ao uso do Task.Run.

Você pode evitar o impasse adicionando ConfigureAwait(false)a esta linha:

IRestResponse<DummyServiceStatus> response = await restResponse;

=>

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

Eu descrevi essa armadilha no meu blog Pitfalls of async / waitit

Você está bloqueando a interface do usuário usando a propriedade Task.Result. Na documentação do MSDN, eles mencionaram claramente que,

"A propriedade Result é uma propriedade de bloqueio. Se você tentar acessá-la antes que sua tarefa seja concluída, o encadeamento atualmente ativo será bloqueado até que a tarefa seja concluída e o valor esteja disponível. Na maioria dos casos, você deve acessar o valor usando Aguardar ou aguarde em vez de acessar a propriedade diretamente ".

A melhor solução para esse cenário seria remover os modos de espera e assíncrona e usar apenas a Tarefa em que você está retornando o resultado. Não vai estragar sua sequência de execução.

Se você não receber retornos de chamada ou o controle desligar, depois de chamar a função de serviço / API assíncrona, será necessário configurar o Contexto para retornar um resultado no mesmo contexto chamado.

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

Você enfrentará esse problema apenas em aplicativos da Web, mas não em static void main.