Appel de la méthode asynchrone de manière synchrone

J'ai une asyncméthode:

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

J'ai besoin d'appeler cette méthode à partir d'une méthode synchrone.

Comment puis-je faire cela sans avoir à dupliquer la GenerateCodeAsyncméthode pour que cela fonctionne de manière synchrone?

Mettre à jour

Pourtant, aucune solution raisonnable n'a été trouvée.

Cependant, je vois que HttpClientdéjà met en œuvre ce modèle

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

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

Vous pouvez accéder à la Resultpropriété de la tâche, ce qui entraînera le blocage de votre thread jusqu'à ce que le résultat soit disponible:

string code = GenerateCodeAsync().Result;

Remarque: Dans certains cas, cela peut entraîner un blocage: votre appel à Resultbloque le thread principal, empêchant ainsi l'exécution du reste du code asynchrone. Vous disposez des options suivantes pour vous assurer que cela ne se produit pas:

• Ajoutez .ConfigureAwait(false)à votre méthode de bibliothèque ou

• exécutez explicitement votre méthode async dans un thread de pool de threads et attendez qu'elle se termine:

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

Cela ne signifie pas que vous devez simplement ajouter sans réfléchir .ConfigureAwait(false)après tous vos appels asynchrones! Pour une analyse détaillée sur pourquoi et quand vous devez utiliser .ConfigureAwait(false), consultez l'article de blog suivant:

• Blog .NET: FAQ ConfigureAwait

Vous devez obtenir le waiter ( GetAwaiter()) et mettre fin à l'attente de la fin de la tâche asynchrone ( GetResult()).

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

Vous devriez pouvoir faire cela en utilisant des délégués, expression 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" ;
    }

J'ai besoin d'appeler cette méthode à partir d'une méthode synchrone.

C'est possible avec GenerateCodeAsync().Resultou GenerateCodeAsync().Wait(), comme le suggère l'autre réponse. Cela bloquerait le thread actuel jusqu'à ce qu'il GenerateCodeAsyncsoit terminé.

Cependant, votre question est étiquetée avec asp.net, et vous avez également laissé le commentaire:

J'espérais une solution plus simple, pensant que asp.net a géré cela beaucoup plus facilement que d'écrire autant de lignes de code

Mon point est, vous ne devriez pas bloquer sur une méthode asynchrone dans ASP.NET. Cela réduira l'évolutivité de votre application Web et peut créer un blocage (lorsqu'une awaitsuite à l'intérieur GenerateCodeAsyncest publiée AspNetSynchronizationContext). Utiliser Task.Run(...).Resultpour décharger quelque chose sur un thread de pool puis bloquer bloquera encore plus l'évolutivité, car cela engendre +1 thread supplémentaire pour traiter une requête HTTP donnée.

ASP.NET prend en charge les méthodes asynchrones, soit via des contrôleurs asynchrones (dans ASP.NET MVC et API Web), soit directement via AsyncManageret PageAsyncTaskdans ASP.NET classique. Vous devez l'utiliser. Pour plus de détails, consultez cette réponse .

Microsoft Identity possède des méthodes d'extension qui appellent les méthodes asynchrones de manière synchrone. Par exemple, il existe une méthode GenerateUserIdentityAsync () et un égal CreateIdentity ()

Si vous regardez UserManagerExtensions.CreateIdentity (), cela ressemble à ceci:

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

Voyons maintenant ce que fait 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();
    }

C'est donc votre wrapper pour la méthode asynchrone. Et s'il vous plaît, ne lisez pas les données de Result - cela bloquera potentiellement votre code dans ASP.

Il y a une autre façon - ce qui est suspect pour moi, mais vous pouvez aussi l'envisager

  Result r = null;

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

Pour éviter les blocages, j'essaie toujours d'utiliser Task.Run() lorsque je dois appeler une méthode asynchrone de manière synchrone mentionnée par @Heinzi.

Cependant, la méthode doit être modifiée si la méthode asynchrone utilise des paramètres. Par exemple, Task.Run(GenerateCodeAsync("test")).Resultdonne l'erreur:

Argument 1: impossible de convertir de ' System.Threading.Tasks.Task<string>' en 'System.Action'

Cela pourrait être appelé comme ceci à la place:

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

La plupart des réponses sur ce sujet sont soit complexes, soit entraîner un blocage.

La méthode suivante est simple et elle évitera un blocage car nous attendons que la tâche se termine et que nous obtenions ensuite son résultat.

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

En outre, voici une référence à un article MSDN qui parle exactement de la même chose - https://blogs.msdn.microsoft.com/jpsanders/2017/08/28/asp-net-do-not-use-task-result- dans-contexte-principal /

Je préfère une approche non bloquante:

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

Eh bien, j'utilise cette approche:

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

        return task.Result;
    }

L'autre façon pourrait être si vous voulez attendre la fin de la tâche:

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

ÉDITER:

La tâche a la méthode Wait, Task.Wait (), qui attend que la "promesse" soit résolue puis continue, la rendant ainsi synchrone. exemple:

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

String mySyncMethod() {

    return MyAsyncMethod().Wait();
}

Si vous avez une méthode asynchrone appelée " RefreshList ", vous pouvez appeler cette méthode asynchrone à partir d'une méthode non asynchrone comme ci-dessous.

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