Chiamare il metodo asincrono in modo sincrono

Ho un asyncmetodo:

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

Devo chiamare questo metodo da un metodo sincrono.

Come posso fare questo senza dover duplicare il GenerateCodeAsyncmetodo affinché questo funzioni in modo sincrono?

Aggiornare

Tuttavia non è stata trovata alcuna soluzione ragionevole.

Tuttavia, vedo che HttpClientimplementa già questo modello

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

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

Puoi accedere alla Resultproprietà dell'attività, che causerà il blocco del thread fino a quando il risultato non sarà disponibile:

string code = GenerateCodeAsync().Result;

Nota: in alcuni casi, ciò potrebbe portare a un deadlock: la chiamata per Resultbloccare il thread principale, impedendo così l'esecuzione del resto del codice asincrono. Hai le seguenti opzioni per assicurarti che ciò non accada:

• Aggiungi .ConfigureAwait(false)al tuo metodo di libreria o

• esegui esplicitamente il tuo metodo asincrono in un thread del pool di thread e attendi che finisca:

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

Questo non significa che dovresti semplicemente aggiungere senza pensarci .ConfigureAwait(false)dopo tutte le tue chiamate asincrone! Per un'analisi dettagliata del perché e del momento in cui utilizzare .ConfigureAwait(false), consultare il seguente post di blog:

• Blog di .NET: ConfigureAwait FAQ

Dovresti ottenere il cameriere ( GetAwaiter()) e terminare l'attesa per il completamento dell'attività asincrona ( GetResult()).

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

Dovresti riuscire a farlo usando i delegati, espressione 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" ;
    }

Devo chiamare questo metodo da un metodo sincrono.

È possibile con GenerateCodeAsync().Resulto GenerateCodeAsync().Wait(), come suggerisce l'altra risposta. Ciò bloccherebbe il thread corrente fino al GenerateCodeAsynccompletamento.

Tuttavia, la tua domanda è taggata con asp.nete hai anche lasciato il commento:

Speravo in una soluzione più semplice, pensando che asp.net lo gestisse molto più facilmente che scrivere così tante righe di codice

Il punto è che non dovresti bloccare un metodo asincrono in ASP.NET. Ciò ridurrà la scalabilità della tua app Web e potrebbe creare un deadlock (quando viene pubblicata una awaitcontinuazione all'interno ). L'uso per scaricare qualcosa su un thread del pool e quindi il blocco danneggerà ulteriormente la scalabilità, poiché comporta +1 thread in più per elaborare una determinata richiesta HTTP.GenerateCodeAsyncAspNetSynchronizationContextTask.Run(...).Result

ASP.NET ha il supporto integrato per i metodi asincroni, tramite controller asincroni (in ASP.NET MVC e API Web) o direttamente tramite AsyncManagere PageAsyncTasknel classico ASP.NET. Dovresti usarlo. Per maggiori dettagli, controlla questa risposta .

Microsoft Identity ha metodi di estensione che chiamano i metodi asincroni in modo sincrono. Ad esempio c'è il metodo GenerateUserIdentityAsync () e uguale CreateIdentity ()

Se guardi UserManagerExtensions.CreateIdentity () è simile al seguente:

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

Ora vediamo cosa fa 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();
    }

Quindi, questo è il wrapper per il metodo asincrono. E per favore non leggere i dati dal risultato - potenzialmente bloccherà il tuo codice in ASP.

C'è un altro modo - che è sospetto per me, ma puoi anche considerarlo

  Result r = null;

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

Per evitare deadlock, cerco sempre di usare Task.Run()quando devo chiamare un metodo asincrono in modo sincrono che menziona @Heinzi.

Tuttavia, il metodo deve essere modificato se il metodo asincrono utilizza parametri. Ad esempio Task.Run(GenerateCodeAsync("test")).Resultdà l'errore:

Argomento 1: impossibile convertire da ' System.Threading.Tasks.Task<string>' a 'System.Action'

Questo potrebbe invece essere chiamato così:

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

La maggior parte delle risposte su questo thread sono complesse o causeranno deadlock.

Il seguente metodo è semplice ed eviterà il deadlock perché stiamo aspettando che l'attività finisca e solo allora ottenga il suo risultato-

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

Inoltre, ecco un riferimento all'articolo MSDN che parla esattamente della stessa cosa- https://blogs.msdn.microsoft.com/jpsanders/2017/08/28/asp-net-do-not-use-task-result- in-main-contesto /

Preferisco un approccio non bloccante:

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

Bene sto usando questo approccio:

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

        return task.Result;
    }

L'altro modo potrebbe essere se si desidera attendere fino al termine dell'attività:

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

MODIFICARE:

L'attività ha il metodo Wait, Task.Wait (), che attende che la "promessa" si risolva e poi continua, rendendola così sincrona. esempio:

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

String mySyncMethod() {

    return MyAsyncMethod().Wait();
}

Se hai un metodo asincrono chiamato " RefreshList ", puoi chiamare quel metodo asincrono da un metodo non asincrono come di seguito.

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