Gọi phương thức async một cách đồng bộ

Tôi có một asyncphương pháp:

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

Tôi cần gọi phương thức này từ một phương thức đồng bộ.

Làm thế nào tôi có thể làm điều này mà không phải sao chép GenerateCodeAsyncphương thức để nó hoạt động đồng bộ?

Cập nhật

Tuy nhiên, không có giải pháp hợp lý được tìm thấy.

Tuy nhiên, tôi thấy rằng HttpClientđã thực hiện mô hình này

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

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

Bạn có thể truy cập thuộc Resulttính của tác vụ, điều này sẽ khiến luồng của bạn bị chặn cho đến khi có kết quả:

string code = GenerateCodeAsync().Result;

Lưu ý: Trong một số trường hợp, điều này có thể dẫn đến bế tắc: Cuộc gọi của bạn để Resultchặn luồng chính, do đó ngăn phần còn lại của mã async thực thi. Bạn có các tùy chọn sau để đảm bảo rằng điều này không xảy ra:

• Thêm vào .ConfigureAwait(false)phương thức thư viện của bạn hoặc

• thực hiện rõ ràng phương thức async của bạn trong một chuỗi nhóm luồng và chờ cho nó kết thúc:

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

Điều này không có nghĩa là bạn chỉ nên thêm .ConfigureAwait(false)vào một cách vô thức sau tất cả các cuộc gọi không đồng bộ của bạn! Để biết phân tích chi tiết về lý do và thời điểm bạn nên sử dụng .ConfigureAwait(false), hãy xem bài đăng trên blog sau:

• .NET Blog: ConfigureAwait FAQ

Bạn sẽ nhận được Waititer ( GetAwaiter()) và kết thúc chờ đợi để hoàn thành nhiệm vụ không đồng bộ ( GetResult()).

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

Bạn sẽ có thể hoàn thành việc này bằng cách sử dụng các đại biểu, biểu thức 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" ;
    }

Tôi cần gọi phương thức này từ một phương thức đồng bộ.

Điều đó có thể với GenerateCodeAsync().Resulthoặc GenerateCodeAsync().Wait(), như câu trả lời khác cho thấy. Điều này sẽ chặn luồng hiện tại cho đến khi GenerateCodeAsynchoàn thành.

Tuy nhiên, câu hỏi của bạn được gắn thẻ asp.netvà bạn cũng để lại bình luận:

Tôi đã hy vọng cho một giải pháp đơn giản hơn, nghĩ rằng asp.net xử lý việc này dễ dàng hơn nhiều so với việc viết quá nhiều dòng mã

Quan điểm của tôi là, bạn không nên chặn phương thức không đồng bộ trong ASP.NET. Điều này sẽ làm giảm khả năng mở rộng của ứng dụng web của bạn và có thể tạo ra sự bế tắc (khi phần awaittiếp theo bên trong GenerateCodeAsyncđược đăng lên AspNetSynchronizationContext). Sử dụngTask.Run(...).Result để giảm tải một cái gì đó cho một chuỗi pool và sau đó chặn sẽ làm tổn hại đến khả năng mở rộng hơn nữa, vì nó phải chịu thêm +1 luồng để xử lý một yêu cầu HTTP đã cho.

ASP.NET có hỗ trợ tích hợp cho các phương thức không đồng bộ, thông qua các bộ điều khiển không đồng bộ (trong ASP.NET MVC và Web API) hoặc trực tiếp thông qua AsyncManagervà PageAsyncTasktrong ASP.NET cổ điển. Bạn nên sử dụng nó. Để biết thêm chi tiết, kiểm tra câu trả lời này .

Microsoft Identity có các phương thức mở rộng gọi các phương thức async một cách đồng bộ. Ví dụ: có phương thức GenerateUserIdentityAsync () và bằng CreatIdentity () bằng nhau

Nếu bạn nhìn vào UserManagerExtensions.CreateIdentity () thì nó trông như thế này:

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

Bây giờ hãy xem AsyncHelper.RunSync làm gì

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

Vì vậy, đây là trình bao bọc của bạn cho phương thức async. Và vui lòng không đọc dữ liệu từ Kết quả - nó có khả năng sẽ chặn mã của bạn trong ASP.

Có một cách khác - đó là nghi ngờ đối với tôi, nhưng bạn cũng có thể xem xét nó

  Result r = null;

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

Để ngăn chặn bế tắc, tôi luôn cố gắng sử dụng Task.Run() khi tôi phải gọi một phương thức async một cách đồng bộ mà @Heinzi đề cập.

Tuy nhiên, phương thức phải được sửa đổi nếu phương thức async sử dụng tham số. Ví dụ Task.Run(GenerateCodeAsync("test")).Resultđưa ra lỗi:

Đối số 1: không thể chuyển đổi từ ' System.Threading.Tasks.Task<string>' sang 'System.Action'

Điều này có thể được gọi như thế này thay vào đó:

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

Hầu hết các câu trả lời trên chủ đề này là phức tạp hoặc sẽ dẫn đến bế tắc.

Phương pháp sau rất đơn giản và nó sẽ tránh được bế tắc vì chúng tôi đang chờ nhiệm vụ hoàn thành và chỉ sau đó mới nhận được kết quả của nó-

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

Hơn nữa, đây là một tài liệu tham khảo cho bài viết MSDN nói về chính xác điều tương tự- https://bloss.msdn.microsoft.com/jpsanders/2017/08/28/asp-net-do-not-use-task-result- trong bối cảnh chính /

Tôi thích một cách tiếp cận không chặn:

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

Vâng, tôi đang sử dụng phương pháp này:

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

        return task.Result;
    }

Một cách khác có thể là nếu bạn muốn đợi cho đến khi nhiệm vụ kết thúc:

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

BIÊN TẬP:

Tác vụ có phương thức Wait, Task.Wait (), chờ "lời hứa" giải quyết và sau đó tiếp tục, do đó hiển thị đồng bộ. thí dụ:

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

String mySyncMethod() {

    return MyAsyncMethod().Wait();
}

Nếu bạn có một phương thức async được gọi là " RefreshList " thì bạn có thể gọi phương thức async đó từ một phương thức không đồng bộ như bên dưới.

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