¿Cómo declarar una tarea no iniciada que esperará otra tarea?

¡He hecho esta Prueba de Unidad y no entiendo por qué el "esperar Task.Delay ()" no espera!

   [TestMethod]
    public async Task SimpleTest()
    {
        bool isOK = false;
        Task myTask = new Task(async () =>
        {
            Console.WriteLine("Task.BeforeDelay");
            await Task.Delay(1000);
            Console.WriteLine("Task.AfterDelay");
            isOK = true;
            Console.WriteLine("Task.Ended");
        });
        Console.WriteLine("Main.BeforeStart");
        myTask.Start();
        Console.WriteLine("Main.AfterStart");
        await myTask;
        Console.WriteLine("Main.AfterAwait");
        Assert.IsTrue(isOK, "OK");
    }

Aquí está la salida de Prueba de Unidad:

¿Cómo es posible que un "esperar" no espere y el hilo principal continúe?

new Task(async () =>

Una tarea no requiere un Func<Task>, sino un Action. Llamará a su método asincrónico y esperará que termine cuando regrese. Pero no lo hace. Devuelve una tarea. Esa tarea no es esperada por la nueva tarea. Para la nueva tarea, el trabajo se realiza una vez que se devuelve el método.

Debe usar la tarea que ya existe en lugar de envolverla en una nueva tarea:

[TestMethod]
public async Task SimpleTest()
{
    bool isOK = false;

    Func<Task> asyncMethod = async () =>
    {
        Console.WriteLine("Task.BeforeDelay");
        await Task.Delay(1000);
        Console.WriteLine("Task.AfterDelay");
        isOK = true;
        Console.WriteLine("Task.Ended");
    };

    Console.WriteLine("Main.BeforeStart");
    Task myTask = asyncMethod();

    Console.WriteLine("Main.AfterStart");

    await myTask;
    Console.WriteLine("Main.AfterAwait");
    Assert.IsTrue(isOK, "OK");
}

El problema es que está utilizando la Taskclase no genérica , que no está destinada a producir un resultado. Entonces, cuando crea la Taskinstancia pasando un delegado asíncrono:

Task myTask = new Task(async () =>

... el delegado es tratado como async void. Un async voidno es un Task, no se puede esperar, su excepción no se puede manejar, y es una fuente de miles de preguntas hechas por programadores frustrados aquí en StackOverflow y en otros lugares. La solución es usar la Task<TResult>clase genérica , porque desea devolver un resultado, y el resultado es otro Task. Entonces tienes que crear un Task<Task>:

Task<Task> myTask = new Task<Task>(async () =>

Ahora, cuando lo Startexterno Task<Task>se completará casi instantáneamente porque su trabajo es solo crear lo interno Task. Entonces también tendrás que esperar lo interno Task. Así es como se puede hacer:

myTask.Start();
Task myInnerTask = await myTask;
await myInnerTask;

Tienes dos alternativas. Si no necesita una referencia explícita al interior Task, puede esperar Task<Task>dos veces al exterior :

await await myTask;

... o puede usar el método de extensión incorporado Unwrapque combina las tareas externas e internas en una sola:

await myTask.Unwrap();

Este desenvolvimiento ocurre automáticamente cuando usa el Task.Runmétodo mucho más popular que crea tareas activas , por lo Unwrapque no se usa con mucha frecuencia en la actualidad.

En caso de que decida que su delegado asíncrono debe devolver un resultado, por ejemplo a string, entonces debe declarar que la myTaskvariable es de tipo Task<Task<string>>.

Nota: No apruebo el uso de Taskconstructores para crear tareas en frío. Como una práctica generalmente está mal vista, por razones que realmente no conozco, pero probablemente porque se usa tan raramente que tiene el potencial de atrapar a otros usuarios / mantenedores / revisores del código por sorpresa.

Consejo general: tenga cuidado cada vez que proporcione un delegado asíncrono como argumento para un método. Idealmente, este método debería esperar un Func<Task>argumento (lo que significa que entiende a los delegados asíncronos), o al menos un Func<T>argumento (lo que significa que al menos lo generado Taskno será ignorado). En el desafortunado caso de que este método acepte un Action, su delegado será tratado como async void. Esto rara vez es lo que quieres, si es que alguna vez.

 [Fact]
        public async Task SimpleTest()
        {
            bool isOK = false;
            Task myTask = new Task(() =>
            {
                Console.WriteLine("Task.BeforeDelay");
                Task.Delay(3000).Wait();
                Console.WriteLine("Task.AfterDelay");
                isOK = true;
                Console.WriteLine("Task.Ended");
            });
            Console.WriteLine("Main.BeforeStart");
            myTask.Start();
            Console.WriteLine("Main.AfterStart");
            await myTask;
            Console.WriteLine("Main.AfterAwait");
            Assert.True(isOK, "OK");
        }