Hay varias formas de ejecutar métodos asíncronos en un contexto sincrónico:
La mejor manera de ejecutar cualquier método asíncrono y esperar a que se complete es usar la palabra clave await de la siguiente manera:
|
|
var t = await AsyncMethod<T>();
|
Lo que se espera aquí es devolver el resultado de la operación de forma inmediata y sincrónica si la operación ya se ha completado o, si no lo ha hecho, programar una continuación para ejecutar el resto de la palabra clave async antes de devolver el control a la persona que llama. Cuando finaliza la operación asíncrona , se ejecutará la finalización programada. Esto es excelente para evitar los interbloqueos y también se puede usar dentro de un bloque try / catch para obtener la excepción generada por el propio método AsyncMethod .
El único inconveniente de usar la palabra clave async es que requiere que el método que contiene se marque como async también. Si no puede hacerlo, solo puede optar por una solución alternativa menos segura para lograr el mismo objetivo como los que se explican a continuación.
La siguiente forma es aun mejor que la anterior:
Si se ve obligado a usar un método que contiene sincronización , puede usar la siguiente clase auxiliar:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
using System;
using System.Threading;
using System.Threading.Tasks;
namespace AC.Components.Util
{
/// <summary>
/// Helper class to run async methods within a sync process.
/// </summary>
public static class AsyncUtil
{
private static readonly TaskFactory _taskFactory = new
TaskFactory(CancellationToken.None,
TaskCreationOptions.None,
TaskContinuationOptions.None,
TaskScheduler.Default);
/// <summary>
/// Executes an async Task method which has a void return value synchronously
/// USAGE: AsyncUtil.RunSync(() => AsyncMethod());
/// </summary>
/// <param name="task">Task method to execute</param>
public static void RunSync(Func<Task> task)
=> _taskFactory
.StartNew(task)
.Unwrap()
.GetAwaiter()
.GetResult();
/// <summary>
/// Executes an async Task<T> method which has a T return type synchronously
/// USAGE: T result = AsyncUtil.RunSync(() => AsyncMethod<T>());
/// </summary>
/// <typeparam name="TResult">Return Type</typeparam>
/// <param name="task">Task<T> method to execute</param>
/// <returns></returns>
public static TResult RunSync<TResult>(Func<Task<TResult>> task)
=> _taskFactory .StartNew(task) .Unwrap() .GetAwaiter() .GetResult();
}
}
|
Entonces puedes usarlo de esa manera:
|
|
var t = AsyncUtil.RunSync<T>(() => AsyncMethod<T>());
|
Esta solución es definitivamente más compleja que la anterior, pero básicamente es la única forma decente de realizar una llamada asíncrona dentro de sincronización . Como podemos ver, la clase auxiliar básicamente crea, configura e inicia una tarea asíncrona sobre la marcha, luego la desenvuelve y espera sincrónicamente su resultado: al igual que el método de espera anterior, este enfoque evitará los interbloqueos y podría usarse dentro de un bloque try / catch para obtener la excepción generada por el propio AsyncMethod .
Enlaces relacionados:
