Chamando o método assíncrono de forma síncrona

Eu tenho um asyncmétodo:

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

Eu preciso chamar esse método a partir de um método síncrono.

Como fazer isso sem precisar duplicar o GenerateCodeAsyncmétodo para que ele funcione de forma síncrona?

Atualizar

No entanto, nenhuma solução razoável foi encontrada.

No entanto, vejo que HttpClientjá implementa esse padrão

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

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

Você pode acessar a Resultpropriedade da tarefa, que fará com que seu encadeamento seja bloqueado até que o resultado esteja disponível:

string code = GenerateCodeAsync().Result;

Nota: Em alguns casos, isso pode levar a um impasse: Sua chamada para Resultbloquear o encadeamento principal, impedindo a execução do restante do código assíncrono. Você tem as seguintes opções para garantir que isso não aconteça:

• Adicione .ConfigureAwait(false)ao seu método de biblioteca ou

• execute explicitamente seu método assíncrono em um thread do pool de threads e aguarde o término:

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

Isso não significa que você deve adicionar sem pensar .ConfigureAwait(false)depois de todas as chamadas assíncronas! Para uma análise detalhada sobre por que e quando você deve usar .ConfigureAwait(false), consulte a seguinte postagem no blog:

• Blog do .NET: Perguntas frequentes do ConfigureAwait

Você deve obter o waititer ( GetAwaiter()) e encerrar a espera pela conclusão da tarefa assíncrona ( GetResult()).

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

Você deve conseguir fazer isso usando delegados, expressão 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" ;
    }

Eu preciso chamar esse método de um método síncrono.

É possível com GenerateCodeAsync().Resultou GenerateCodeAsync().Wait(), como a outra resposta sugere. Isso bloquearia o encadeamento atual até a GenerateCodeAsyncconclusão.

No entanto, sua pergunta está marcada com asp.nete você também deixou o comentário:

Eu esperava uma solução mais simples, pensando que o asp.net lidava com isso muito mais facilmente do que escrever tantas linhas de código

Meu argumento é que você não deve estar bloqueando um método assíncrono no ASP.NET. Isso reduzirá a escalabilidade do seu aplicativo Web e poderá criar um impasse (quando uma awaitcontinuação interna GenerateCodeAsyncfor postada em AspNetSynchronizationContext). Usar Task.Run(...).Resultpara transferir algo para um encadeamento de pool e, em seguida, bloquear prejudicará ainda mais a escalabilidade, pois incorre em mais um encadeamento para processar uma determinada solicitação HTTP.

O ASP.NET possui suporte interno para métodos assíncronos, por meio de controladores assíncronos (no ASP.NET MVC e na Web API) ou diretamente via AsyncManagere PageAsyncTaskno ASP.NET clássico. Você deveria usá-lo. Para mais detalhes, verifique esta resposta .

O Microsoft Identity possui métodos de extensão que chamam métodos assíncronos de forma síncrona. Por exemplo, existe o método GenerateUserIdentityAsync () e igual CreateIdentity ()

Se você olhar para UserManagerExtensions.CreateIdentity (), será assim:

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

Agora vamos ver o que o AsyncHelper.RunSync faz

  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();
    }

Portanto, este é o seu invólucro para o método assíncrono. E por favor, não leia os dados do Result - ele potencialmente bloqueará seu código no ASP.

Existe outra maneira - que é suspeita para mim, mas você pode considerar isso também

  Result r = null;

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

Para evitar conflitos, sempre tento usar Task.Run()quando preciso chamar um método assíncrono de forma síncrona mencionada pelo @Heinzi.

No entanto, o método precisa ser modificado se o método assíncrono usar parâmetros. Por exemplo, Task.Run(GenerateCodeAsync("test")).Resultdá o erro:

Argumento 1: não é possível converter de ' System.Threading.Tasks.Task<string>' para 'System.Action'

Isso poderia ser chamado assim:

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

A maioria das respostas neste segmento é complexa ou resultará em impasse.

O método a seguir é simples e evitará impasse, pois aguardamos a conclusão da tarefa e só então obtemos o resultado -

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

Além disso, aqui está uma referência ao artigo do MSDN que fala exatamente da mesma coisa - https://blogs.msdn.microsoft.com/jpsanders/2017/08/28/asp-net-do-not-use-task-result- no contexto principal /

Eu prefiro uma abordagem sem bloqueio:

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

Bem, eu estou usando esta abordagem:

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

        return task.Result;
    }

A outra maneira poderia ser se você quiser esperar até que a tarefa seja concluída:

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

EDITAR:

Task possui o método Wait, Task.Wait (), que aguarda a "promessa" resolver e, em seguida, continua, tornando-o síncrono. exemplo:

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

String mySyncMethod() {

    return MyAsyncMethod().Wait();
}

Se você tiver um método assíncrono chamado " RefreshList ", poderá chamar esse método assíncrono a partir de um método não assíncrono, como abaixo.

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