Asynchrone Methode synchron aufrufen

Ich habe eine asyncMethode:

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

Ich muss diese Methode von einer synchronen Methode aus aufrufen.

Wie kann ich dies tun, ohne die GenerateCodeAsyncMethode duplizieren zu müssen, damit dies synchron funktioniert?

Aktualisieren

Es wurde jedoch keine vernünftige Lösung gefunden.

Ich sehe jedoch, dass HttpClientdieses Muster bereits implementiert ist

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

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

Sie können auf die ResultEigenschaft der Aufgabe zugreifen , wodurch Ihr Thread blockiert wird, bis das Ergebnis verfügbar ist:

string code = GenerateCodeAsync().Result;

Hinweis: In einigen Fällen kann dies zu einem Deadlock führen: Ihr Aufruf zum ResultBlockieren des Hauptthreads verhindert, dass der Rest des asynchronen Codes ausgeführt wird. Sie haben folgende Möglichkeiten, um sicherzustellen, dass dies nicht geschieht:

• Fügen Sie .ConfigureAwait(false)Ihrer Bibliotheksmethode oder hinzu

• Führen Sie Ihre asynchrone Methode explizit in einem Thread-Pool-Thread aus und warten Sie, bis sie abgeschlossen ist:

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

Dies bedeutet nicht , dass Sie .ConfigureAwait(false)nach all Ihren asynchronen Aufrufen nur sinnlos hinzufügen sollten ! Eine detaillierte Analyse, warum und wann Sie verwenden sollten .ConfigureAwait(false), finden Sie im folgenden Blog-Beitrag:

• .NET Blog: ConfigureAwait FAQ

Sie sollten den awaiter ( GetAwaiter()) erhalten und das Warten auf den Abschluss der asynchronen Task ( GetResult()) beenden .

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

Sie sollten in der Lage sein, dies mit Delegaten, Lambda-Ausdruck, zu erledigen

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

Ich muss diese Methode von einer synchronen Methode aus aufrufen.

Es ist möglich mit GenerateCodeAsync().Resultoder GenerateCodeAsync().Wait(), wie die andere Antwort nahelegt. Dies würde den aktuellen Thread blockieren, bis er GenerateCodeAsyncabgeschlossen ist.

Ihre Frage ist jedoch mit markiert asp.netund du hast auch den Kommentar hinterlassen:

Ich hatte auf eine einfachere Lösung gehofft und dachte, dass asp.net dies viel einfacher handhabt als so viele Codezeilen zu schreiben

Mein Punkt ist, dass Sie eine asynchrone Methode in ASP.NET nicht blockieren sollten . Dies verringert die Skalierbarkeit Ihrer Web-App und kann zu einem Deadlock führen (wenn eine awaitFortsetzung im Innern von GenerateCodeAsyncveröffentlicht wird AspNetSynchronizationContext). Wenn Sie Task.Run(...).Resultetwas in einen Pool-Thread auslagern und dann blockieren, wird die Skalierbarkeit noch mehr beeinträchtigt, da +1 mehr Thread für die Verarbeitung einer bestimmten HTTP-Anforderung erforderlich ist.

ASP.NET bietet integrierte Unterstützung für asynchrone Methoden, entweder über asynchrone Controller (in ASP.NET MVC und Web API) oder direkt über AsyncManagerund PageAsyncTaskin klassischem ASP.NET. Du solltest es benutzen. Weitere Informationen finden Sie in dieser Antwort .

Microsoft Identity verfügt über Erweiterungsmethoden, die asynchrone Methoden synchron aufrufen. Zum Beispiel gibt es die GenerateUserIdentityAsync () -Methode und die gleiche CreateIdentity ()

Wenn Sie sich UserManagerExtensions.CreateIdentity () ansehen, sieht es folgendermaßen aus:

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

Nun wollen wir sehen, was AsyncHelper.RunSync macht

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

Dies ist also Ihr Wrapper für die asynchrone Methode. Und bitte lesen Sie keine Daten aus dem Ergebnis - es wird möglicherweise Ihren Code in ASP blockieren.

Es gibt einen anderen Weg - der für mich verdächtig ist, aber Sie können ihn auch in Betracht ziehen

  Result r = null;

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

Um Deadlocks zu vermeiden, versuche ich immer, diese zu verwenden, Task.Run()wenn ich eine von @Heinzi erwähnte asynchrone Methode synchron aufrufen muss.

Die Methode muss jedoch geändert werden, wenn die asynchrone Methode Parameter verwendet. Zum Beispiel Task.Run(GenerateCodeAsync("test")).Resultgibt der Fehler:

Argument 1: Konvertierung von ' System.Threading.Tasks.Task<string>' nach 'System.Action' nicht möglich

Dies könnte stattdessen so genannt werden:

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

Die meisten Antworten in diesem Thread sind entweder komplex oder führen zu einem Deadlock.

Die folgende Methode ist einfach und vermeidet Deadlocks, da wir darauf warten, dass die Aufgabe abgeschlossen ist und erst dann das Ergebnis erhält.

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

Darüber hinaus finden Sie hier einen Verweis auf einen MSDN-Artikel, der genau dasselbe behandelt: https://blogs.msdn.microsoft.com/jpsanders/2017/08/28/asp-net-do-not-use-task-result- im Hauptkontext /

Ich bevorzuge einen nicht blockierenden Ansatz:

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

Nun, ich benutze diesen Ansatz:

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

        return task.Result;
    }

Der andere Weg könnte sein, wenn Sie warten möchten, bis die Aufgabe abgeschlossen ist:

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

BEARBEITEN:

Task verfügt über die Wait-Methode Task.Wait (), die darauf wartet, dass das "Versprechen" aufgelöst wird, und dann fortfährt, wodurch es synchronisiert wird. Beispiel:

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

String mySyncMethod() {

    return MyAsyncMethod().Wait();
}

Wenn Sie eine asynchrone Methode namens " RefreshList " haben, können Sie diese asynchrone Methode von einer nicht asynchronen Methode wie unten aufrufen.

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