Zaman uyumsuz yöntemi senkronize olarak çağırmak

Bir asyncyöntem var:

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

Senkronize bir yöntemden bu yöntemi çağırmak gerekiyor.

GenerateCodeAsyncEşzamanlı olarak çalışması için yöntemi çoğaltmak zorunda kalmadan bunu nasıl yapabilirim ?

Güncelleme

Ancak makul bir çözüm bulunamadı.

Ancak, HttpClientzaten bu kalıbı uyguladığını görüyorum

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

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

ResultGörevin özelliğine erişebilirsiniz; bu, sonuç elde edilinceye kadar iş parçacığınızın engellenmesine neden olur:

string code = GenerateCodeAsync().Result;

Not: Bazı durumlarda bu bir kilitlenmeye neden olabilir: ResultAna iş parçacığını engelleme çağrınız , böylece zaman uyumsuz kodun geri kalanının yürütülmesini engeller. Bunun olmadığından emin olmak için aşağıdaki seçenekleriniz vardır:

• .ConfigureAwait(false)Kütüphane yönteminize ekleyin veya

• zaman uyumsuz yönteminizi bir iş parçacığı havuzu iş parçacığında açıkça yürütün ve bitmesini bekleyin:

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

Bu ,.ConfigureAwait(false) tüm zaman uyumsuz çağrılarınızdan sonra dikkatsizce eklemeniz gerektiği anlamına gelmez ! Neden ve ne zaman kullanmanız gerektiğiyle ilgili ayrıntılı bir analiz .ConfigureAwait(false)için aşağıdaki blog yayınına bakın:

• .NET Blog: ConfigureAwait SSS

Awaiter ( GetAwaiter()) yöntemini almalı ve eşzamansız görevin ( GetResult()) tamamlanmasını beklemelisiniz .

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

Delegeler, lambda ifadesi kullanarak bunu yapabilmelisiniz

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

Bu yöntemi eşzamanlı bir yöntemden çağırmak gerekir.

Diğer cevabın önerdiği gibi GenerateCodeAsync().Resultveya ile mümkündür GenerateCodeAsync().Wait(). Bu işlem geçerli iş parçacığını engelleyene kadarGenerateCodeAsync tamamlanıncaya .

Ancak, sorunuz etiketlendi asp.netve ayrıca yorumu da bıraktınız:

Asp.net'in bu kadar çok kod satırı yazmaktan çok daha kolay işlediğini düşünerek daha basit bir çözüm umuyordum

Demek istediğim , ASP.NET'te eşzamansız bir yöntemi engellememelisiniz . Bu, web uygulamanızın ölçeklenebilirliğini azaltır ve bir kilitlenme (await içeride devam GenerateCodeAsyncgönderildiğinde AspNetSynchronizationContext). Kullanılması Task.Run(...).Resultverilen bir HTTP isteği işlemek için 1 daha parçacığı doğurur bir havuz iplik ve sonra bloğa boşaltma şey, daha ölçeklenebilirlik bile zarar verir.

ASP.NET üzerinden doğrudan asenkron kontrolörleri aracılığıyla (Web API ASP.NET MVC ve) ya asenkron yöntemleri için yerleşik destek veya etmiştir AsyncManagerve PageAsyncTaskklasik ASP.NET içinde. Kullanmalısın. Daha fazla ayrıntı için bu cevabı kontrol edin .

Microsoft Identity, zaman uyumsuz yöntemleri eşzamanlı olarak çağıran uzantı yöntemleri vardır. Örneğin GenerateUserIdentityAsync () yöntemi ve eşit CreateIdentity () vardır

UserManagerExtensions.CreateIdentity () öğesine bakarsanız şöyle görünür:

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

Şimdi AsyncHelper.RunSync'in ne yaptığını görelim

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

Yani, bu zaman uyumsuz yöntem için sarıcı. Ve lütfen Sonuçtan veri okumayın - ASP'deki kodunuzu engeller.

Başka bir yol var - bu benim için şüpheli, ama sen de düşünebilirsin

  Result r = null;

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

Kilitlenmeleri önlemek için her zaman kullanmaya çalışıyorum Task.Run() , @Heinzi'den bahsettiği zaman zaman uyumsuz bir yöntemi çağırmak denerim.

Ancak, zaman uyumsuzluk yöntemi parametreler kullanıyorsa yöntemin değiştirilmesi gerekir. Örneğin Task.Run(GenerateCodeAsync("test")).Resulthatayı verir:

Bağımsız değişken 1: " System.Threading.Tasks.Task<string>" den "Sistem'e" dönüştürülemiyor

Bunun yerine şöyle denilebilir:

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

Bu konudaki cevapların çoğu ya karmaşıktır ya da kilitlenme ile sonuçlanır.

Aşağıdaki yöntem basittir ve kilitlenmeyi önleyecektir, çünkü görevin bitmesini ve ancak sonucunu almayı bekliyoruz.

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

Ayrıca, tam olarak aynı şeyden bahseden MSDN makalesine bir referans - https://blogs.msdn.microsoft.com/jpsanders/2017/08/28/asp-net-do-not-use-task-result- in ana bağlamda /

Engellemeyen bir yaklaşımı tercih ederim:

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

Bu yaklaşımı kullanıyorum:

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

        return task.Result;
    }

Diğer yol, görev bitene kadar beklemek istiyorsanız olabilir:

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

DÜZENLE:

Görevin "vaat" in çözülmesini ve ardından devam etmesini bekleyerek eşzamanlı hale getiren Bekleme yöntemi olan Task.Wait () vardır. misal:

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

String mySyncMethod() {

    return MyAsyncMethod().Wait();
}

" RefreshList " adında bir async yönteminiz varsa, bu async yöntemini aşağıdaki gibi asenkron olmayan bir yöntemden çağırabilirsiniz.

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