'esperar' funciona, pero llama a la tarea. El resultado se bloquea

Tengo las siguientes cuatro pruebas y la última se cuelga cuando la ejecuto. Por qué pasó esto:

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

Utilizo este método de extensión para 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 qué se cuelga la última prueba?

Se encuentra con la situación de bloqueo estándar que describo en mi blog y en un artículo de MSDN : el asyncmétodo está intentando programar su continuación en un hilo que está bloqueado por la llamada a Result.

En este caso, SynchronizationContextNUnit utiliza el suyo para ejecutar async voidmétodos de prueba. Intentaría usar async Taskmétodos de prueba en su lugar.

Adquisición de un valor a través de un método asíncrono:

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

Llamar sincrónicamente un método asíncrono

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

No se producirán problemas de punto muerto debido al uso de Task.Run.

Puede evitar el punto muerto que se agrega ConfigureAwait(false)a esta línea:

IRestResponse<DummyServiceStatus> response = await restResponse;

=>

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

Describí este escollo en la publicación de mi blog Escollos de async / await

Está bloqueando la IU utilizando la propiedad Task.Result. En la documentación de MSDN , han mencionado claramente que,

"La propiedad Resultado es una propiedad de bloqueo. Si intenta acceder a ella antes de que finalice su tarea, el subproceso que está actualmente activo se bloquea hasta que se complete la tarea y el valor esté disponible. En la mayoría de los casos, debe acceder al valor utilizando Esperar o esperar en lugar de acceder a la propiedad directamente ".

La mejor solución para este escenario sería eliminar los modos de espera y asíncrono de los métodos y usar solo la Tarea donde devuelve el resultado. No alterará su secuencia de ejecución.

Si no recibe ninguna devolución de llamada o el control se cuelga, después de llamar a la función asíncrona de servicio / API, debe configurar Context para devolver un resultado en el mismo contexto llamado.

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

Se enfrentará a este problema solo en aplicaciones web, pero no en static void main.