Llamar al método asíncrono sincrónicamente

Tengo un asyncmetodo:

public async Task<string> GenerateCodeAsync()
{
    string code = await GenerateCodeService.GenerateCodeAsync();
    return code;
}

Necesito llamar a este método desde un método sincrónico.

¿Cómo puedo hacer esto sin tener que duplicar el GenerateCodeAsyncmétodo para que esto funcione sincrónicamente?

Actualizar

Sin embargo, no se encontró una solución razonable.

Sin embargo, veo que HttpClientya implementa este patrón

using (HttpClient client = new HttpClient())
{
    // async
    HttpResponseMessage responseAsync = await client.GetAsync(url);

    // sync
    HttpResponseMessage responseSync = client.GetAsync(url).Result;
}

Puede acceder a la Resultpropiedad de la tarea, lo que hará que su hilo se bloquee hasta que el resultado esté disponible:

string code = GenerateCodeAsync().Result;

Nota: en algunos casos, esto puede llevar a un punto muerto: su llamada para Resultbloquear el hilo principal, evitando así que se ejecute el resto del código asincrónico. Tiene las siguientes opciones para asegurarse de que esto no suceda:

• Agregar .ConfigureAwait(false)a su método de biblioteca o

• Ejecute explícitamente su método asíncrono en un subproceso de grupo de subprocesos y espere a que termine:

  string code = Task.Run(GenerateCodeAsync).Result;

¡Esto no significa que deba agregar sin pensar .ConfigureAwait(false)después de todas sus llamadas asíncronas! Para un análisis detallado de por qué y cuándo debe usar .ConfigureAwait(false), consulte la siguiente publicación de blog:

• Blog .NET: Preguntas frecuentes sobre ConfigureAwait

Debería obtener el camarero ( GetAwaiter()) y finalizar la espera para completar la tarea asincrónica ( GetResult()).

string code = GenerateCodeAsync().GetAwaiter().GetResult();

Debería poder hacer esto usando delegados, expresión lambda

private void button2_Click(object sender, EventArgs e)
    {

        label1.Text = "waiting....";

        Task<string> sCode = Task.Run(async () =>
        {
            string msg =await GenerateCodeAsync();
            return msg;
        });

        label1.Text += sCode.Result;

    }

    private Task<string> GenerateCodeAsync()
    {
        return Task.Run<string>(() => GenerateCode());
    }

    private string GenerateCode()
    {
        Thread.Sleep(2000);
        return "I m back" ;
    }

Necesito llamar a este método desde un método sincrónico.

Es posible con GenerateCodeAsync().Resulto GenerateCodeAsync().Wait(), como sugiere la otra respuesta. Esto bloquearía el hilo actual hasta que se GenerateCodeAsynchaya completado.

Sin embargo, su pregunta está etiquetada con asp.net, y también dejaste el comentario:

Esperaba una solución más simple, pensando que asp.net manejó esto mucho más fácil que escribir tantas líneas de código

Mi punto es que no deberías estar bloqueando un método asincrónico en ASP.NET. Esto reducirá la escalabilidad de su aplicación web y puede crear un punto muerto (cuando se publica una awaitcontinuación en el interior ). El uso para descargar algo en un subproceso de grupo y luego bloquear dañará la escalabilidad aún más, ya que incurre en +1 subproceso adicional para procesar una solicitud HTTP dada.GenerateCodeAsyncAspNetSynchronizationContextTask.Run(...).Result

ASP.NET tiene soporte incorporado para métodos asincrónicos, ya sea a través de controladores asincrónicos (en ASP.NET MVC y API web) o directamente a través AsyncManagery PageAsyncTasken ASP.NET clásico. Deberías usarlo. Para más detalles, verifique esta respuesta .

Microsoft Identity tiene métodos de extensión que llaman a métodos asíncronos sincrónicamente. Por ejemplo, hay un método GenerateUserIdentityAsync () e igual CreateIdentity ()

Si observa UserManagerExtensions.CreateIdentity () se verá así:

 public static ClaimsIdentity CreateIdentity<TUser, TKey>(this UserManager<TUser, TKey> manager, TUser user,
        string authenticationType)
        where TKey : IEquatable<TKey>
        where TUser : class, IUser<TKey>
    {
        if (manager == null)
        {
            throw new ArgumentNullException("manager");
        }
        return AsyncHelper.RunSync(() => manager.CreateIdentityAsync(user, authenticationType));
    }

Ahora veamos qué hace AsyncHelper.RunSync

  public static TResult RunSync<TResult>(Func<Task<TResult>> func)
    {
        var cultureUi = CultureInfo.CurrentUICulture;
        var culture = CultureInfo.CurrentCulture;
        return _myTaskFactory.StartNew(() =>
        {
            Thread.CurrentThread.CurrentCulture = culture;
            Thread.CurrentThread.CurrentUICulture = cultureUi;
            return func();
        }).Unwrap().GetAwaiter().GetResult();
    }

Entonces, este es su contenedor para el método asíncrono. Y, por favor, no lea los datos del Resultado: potencialmente bloqueará su código en ASP.

Hay otra forma, que es sospechosa para mí, pero también puedes considerarla

  Result r = null;

            YourAsyncMethod()
                .ContinueWith(t =>
                {
                    r = t.Result;
                })
                .Wait();

Para evitar puntos muertos siempre trato de usar Task.Run() cuando tengo que llamar a un método asíncrono sincrónicamente que @Heinzi menciona.

Sin embargo, el método tiene que modificarse si el método asíncrono usa parámetros. Por ejemplo Task.Run(GenerateCodeAsync("test")).Resultda el error:

Argumento 1: no se puede convertir de ' System.Threading.Tasks.Task<string>' a 'System.Action'

Esto podría llamarse así:

string code = Task.Run(() => GenerateCodeAsync("test")).Result;

La mayoría de las respuestas en este hilo son complejas o resultarán en un punto muerto.

El siguiente método es simple y evitará un punto muerto porque estamos esperando que termine la tarea y solo entonces obteniendo su resultado:

var task = Task.Run(() => GenerateCodeAsync()); 
task.Wait();
string code = task.Result;

Además, aquí hay una referencia al artículo de MSDN que habla exactamente de lo mismo: https://blogs.msdn.microsoft.com/jpsanders/2017/08/28/asp-net-do-not-use-task-result- en contexto principal /

Prefiero un enfoque sin bloqueo:

            Dim aw1=GenerateCodeAsync().GetAwaiter()
            While Not aw1.IsCompleted
                Application.DoEvents()
            End While

Bueno, estoy usando este enfoque:

    private string RunSync()
    {
        var task = Task.Run(async () => await GenerateCodeService.GenerateCodeAsync());
        if (task.IsFaulted && task.Exception != null)
        {
            throw task.Exception;
        }

        return task.Result;
    }

La otra forma podría ser si desea esperar hasta que finalice la tarea:

var t = GenerateCodeService.GenerateCodeAsync();
Task.WhenAll(t);
string code = t.Result;

EDITAR:

La tarea tiene el método Wait, Task.Wait (), que espera a que se resuelva la "promesa" y luego continúa, lo que la hace sincrónica. ejemplo:

async Task<String> MyAsyncMethod() { ... }

String mySyncMethod() {

    return MyAsyncMethod().Wait();
}

Si tiene un método asincrónico llamado " RefreshList ", puede llamar a ese método asincrónico desde un método no asincrónico como se muestra a continuación.

Task.Run(async () => { await RefreshList(); });