Bagaimana cara memanggil metode asinkron dari metode sinkron dalam C #?

Saya memiliki public async void Foo()metode yang ingin saya panggil dari metode sinkron. Sejauh ini semua yang saya lihat dari dokumentasi MSDN adalah memanggil metode async melalui metode async, tetapi seluruh program saya tidak dibangun dengan metode async.

Apakah ini mungkin?

Berikut adalah salah satu contoh memanggil metode ini dari metode asinkron: http://msdn.microsoft.com/en-us/library/hh300224(v=vs.110).aspx

Sekarang saya sedang mencari cara memanggil metode async ini dari metode sinkronisasi.

Pemrograman asinkron tidak "tumbuh" melalui basis kode. Ini telah dibandingkan dengan virus zombie . Solusi terbaik adalah membiarkannya tumbuh, tetapi terkadang itu tidak mungkin.

Saya telah menulis beberapa jenis di pustaka Nito.AsyncEx saya untuk berurusan dengan basis kode asinkron parsial. Tidak ada solusi yang berfungsi di setiap situasi.

Solusi A

Jika Anda memiliki metode asinkron sederhana yang tidak perlu disinkronkan kembali ke konteksnya, maka Anda dapat menggunakan Task.WaitAndUnwrapException:

var task = MyAsyncMethod();
var result = task.WaitAndUnwrapException();

Anda tidak ingin menggunakan Task.Waitatau Task.Resultkarena mereka memasukkan pengecualian AggregateException.

Solusi ini hanya sesuai jika MyAsyncMethodtidak disinkronkan kembali ke konteksnya. Dengan kata lain, setiap awaitdi MyAsyncMethodharus berakhir dengan ConfigureAwait(false). Ini berarti tidak dapat memperbarui elemen UI apa pun atau mengakses konteks permintaan ASP.NET.

Solusi B

Jika MyAsyncMethodmemang perlu disinkronkan kembali ke konteksnya, maka Anda mungkin dapat menggunakan AsyncContext.RunTaskuntuk memberikan konteks bersarang:

var result = AsyncContext.RunTask(MyAsyncMethod).Result;

* Pembaruan 4/14/2014: Dalam versi perpustakaan yang lebih baru, API adalah sebagai berikut:

var result = AsyncContext.Run(MyAsyncMethod);

(Tidak apa-apa untuk digunakan Task.Resultdalam contoh ini karena RunTaskakan menyebarkan Taskpengecualian).

Alasan Anda mungkin perlu AsyncContext.RunTaskbukannya Task.WaitAndUnwrapExceptionkarena kebuntuan yang agak halus yang terjadi pada WinForms / WPF / SL / ASP.NET:

1. Metode sinkron memanggil metode async, memperoleh a Task.
2. Metode sinkron melakukan pemblokiran menunggu di Internet Task.
3. The asyncMetode menggunakan awaittanpa ConfigureAwait.
4. Tidak Taskdapat menyelesaikan dalam situasi ini karena hanya selesai ketika asyncmetode selesai; yang asyncmetode dapat tidak lengkap karena mencoba untuk menjadwalkan kelanjutan kepada SynchronizationContext, dan WinForms / WPF / SL / ASP.NET tidak akan mengizinkan kelanjutan untuk menjalankan karena metode sinkron sudah berjalan dalam konteks itu.

Ini adalah salah satu alasan mengapa sebaiknya menggunakan sebanyak mungkin metode ConfigureAwait(false)dalam setiap asyncmetode.

Solusi C

AsyncContext.RunTasktidak akan berfungsi di setiap skenario. Misalnya, jika asyncmetode menunggu sesuatu yang memerlukan acara UI untuk menyelesaikan, maka Anda akan menemui jalan buntu bahkan dengan konteks bersarang. Jika demikian, Anda bisa memulai asyncmetode di kumpulan utas:

var task = Task.Run(async () => await MyAsyncMethod());
var result = task.WaitAndUnwrapException();

Namun, solusi ini membutuhkan MyAsyncMethodyang akan bekerja dalam konteks thread pool. Jadi itu tidak dapat memperbarui elemen UI atau mengakses konteks permintaan ASP.NET. Dan dalam hal ini, Anda mungkin juga menambahkan ConfigureAwait(false)untuk nya awaitpernyataan, dan menggunakan solusi A.

Pembaruan, 2019-05-01: "Praktik terburuk" saat ini ada di artikel MSDN di sini .

Menambahkan solusi yang akhirnya menyelesaikan masalah saya, semoga menghemat waktu seseorang.

Pertama baca beberapa artikel dari Stephen Cleary :

• Async dan Tunggu
• Jangan Blokir pada Kode Async

Dari "dua praktik terbaik" di "Jangan Blokir pada Kode Async", yang pertama tidak bekerja untuk saya dan yang kedua tidak berlaku (pada dasarnya jika saya bisa menggunakan await, saya lakukan!).

Jadi di sini adalah solusi saya: bungkus panggilan di dalam Task.Run<>(async () => await FunctionAsync());dan mudah-mudahan tidak ada jalan buntu lagi.

Ini kode saya:

public class LogReader
{
    ILogger _logger;

    public LogReader(ILogger logger)
    {
        _logger = logger;
    }

    public LogEntity GetLog()
    {
        Task<LogEntity> task = Task.Run<LogEntity>(async () => await GetLogAsync());
        return task.Result;
    }

    public async Task<LogEntity> GetLogAsync()
    {
        var result = await _logger.GetAsync();
        // more code here...
        return result as LogEntity;
    }
}

Microsoft membangun kelas AsyncHelper (internal) untuk menjalankan Async sebagai Sinkronisasi. Sumbernya terlihat seperti:

internal static class AsyncHelper
{
    private static readonly TaskFactory _myTaskFactory = new 
      TaskFactory(CancellationToken.None, 
                  TaskCreationOptions.None, 
                  TaskContinuationOptions.None, 
                  TaskScheduler.Default);

    public static TResult RunSync<TResult>(Func<Task<TResult>> func)
    {
        return AsyncHelper._myTaskFactory
          .StartNew<Task<TResult>>(func)
          .Unwrap<TResult>()
          .GetAwaiter()
          .GetResult();
    }

    public static void RunSync(Func<Task> func)
    {
        AsyncHelper._myTaskFactory
          .StartNew<Task>(func)
          .Unwrap()
          .GetAwaiter()
          .GetResult();
    }
}

Kelas dasar Microsoft.AspNet.Identity hanya memiliki metode Async dan untuk memanggil mereka sebagai Sinkronisasi ada kelas dengan metode ekstensi yang terlihat seperti (contoh penggunaan):

public static TUser FindById<TUser, TKey>(this UserManager<TUser, TKey> manager, TKey userId) where TUser : class, IUser<TKey> where TKey : IEquatable<TKey>
{
    if (manager == null)
    {
        throw new ArgumentNullException("manager");
    }
    return AsyncHelper.RunSync<TUser>(() => manager.FindByIdAsync(userId));
}

public static bool IsInRole<TUser, TKey>(this UserManager<TUser, TKey> manager, TKey userId, string role) where TUser : class, IUser<TKey> where TKey : IEquatable<TKey>
{
    if (manager == null)
    {
        throw new ArgumentNullException("manager");
    }
    return AsyncHelper.RunSync<bool>(() => manager.IsInRoleAsync(userId, role));
}

Bagi mereka yang peduli tentang ketentuan kode lisensi, berikut ini tautan ke kode yang sangat mirip (hanya menambahkan dukungan untuk kultur di utas) yang memiliki komentar untuk menunjukkan bahwa itu adalah MIT yang dilisensikan oleh Microsoft. https://github.com/aspnet/AspNetIdentity/blob/master/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs

async Main sekarang merupakan bagian dari C # 7.2 dan dapat diaktifkan dalam pengaturan lanjutan bangunan proyek.

Untuk C # <7.2, cara yang benar adalah:

static void Main(string[] args)
{
   MainAsync().GetAwaiter().GetResult();
}


static async Task MainAsync()
{
   /*await stuff here*/
}

Anda akan melihat ini digunakan dalam banyak dokumentasi Microsoft, misalnya: https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-dotnet-how-to-use- topik-langganan

public async Task<string> StartMyTask()
{
    await Foo()
    // code to execute once foo is done
}

static void Main()
{
     var myTask = StartMyTask(); // call your method which will return control once it hits await
     // now you can continue executing code here
     string result = myTask.Result; // wait for the task to complete to continue
     // use result

}

Anda membaca kata kunci 'tunggu' sebagai "mulai tugas yang sudah berjalan lama ini, lalu kembalikan kontrol ke metode panggilan" Setelah tugas jangka panjang selesai, ia menjalankan kode setelahnya. Kode setelah menunggu mirip dengan apa yang dulu metode CallBack. Perbedaan besar menjadi aliran logis tidak terputus yang membuatnya lebih mudah untuk menulis dan membaca.

Saya tidak 100% yakin, tapi saya percaya teknik yang dijelaskan dalam blog ini harus bekerja dalam banyak keadaan:

Dengan demikian Anda dapat menggunakan task.GetAwaiter().GetResult()jika Anda ingin secara langsung memanggil logika propagasi ini.

Namun, ada solusi bagus yang bekerja di (hampir: lihat komentar) setiap situasi: pompa pesan ad-hoc (SynchronizationContext).

Utas panggilan akan diblokir seperti yang diharapkan, sambil tetap memastikan bahwa semua kelanjutan yang dipanggil dari fungsi async tidak menemui jalan buntu karena mereka akan diarahkan ke Ad-hoc SynchronizationContext (pompa pesan) yang berjalan pada utas panggilan.

Kode pembantu pompa pesan ad-hoc:

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Threading
{
    /// <summary>Provides a pump that supports running asynchronous methods on the current thread.</summary>
    public static class AsyncPump
    {
        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static void Run(Action asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(true);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function
                syncCtx.OperationStarted();
                asyncMethod();
                syncCtx.OperationCompleted();

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static void Run(Func<Task> asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function and alert the context to when it completes
                var t = asyncMethod();
                if (t == null) throw new InvalidOperationException("No task provided.");
                t.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                t.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static T Run<T>(Func<Task<T>> asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function and alert the context to when it completes
                var t = asyncMethod();
                if (t == null) throw new InvalidOperationException("No task provided.");
                t.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                return t.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Provides a SynchronizationContext that's single-threaded.</summary>
        private sealed class SingleThreadSynchronizationContext : SynchronizationContext
        {
            /// <summary>The queue of work items.</summary>
            private readonly BlockingCollection<KeyValuePair<SendOrPostCallback, object>> m_queue =
                new BlockingCollection<KeyValuePair<SendOrPostCallback, object>>();
            /// <summary>The processing thread.</summary>
            private readonly Thread m_thread = Thread.CurrentThread;
            /// <summary>The number of outstanding operations.</summary>
            private int m_operationCount = 0;
            /// <summary>Whether to track operations m_operationCount.</summary>
            private readonly bool m_trackOperations;

            /// <summary>Initializes the context.</summary>
            /// <param name="trackOperations">Whether to track operation count.</param>
            internal SingleThreadSynchronizationContext(bool trackOperations)
            {
                m_trackOperations = trackOperations;
            }

            /// <summary>Dispatches an asynchronous message to the synchronization context.</summary>
            /// <param name="d">The System.Threading.SendOrPostCallback delegate to call.</param>
            /// <param name="state">The object passed to the delegate.</param>
            public override void Post(SendOrPostCallback d, object state)
            {
                if (d == null) throw new ArgumentNullException("d");
                m_queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
            }

            /// <summary>Not supported.</summary>
            public override void Send(SendOrPostCallback d, object state)
            {
                throw new NotSupportedException("Synchronously sending is not supported.");
            }

            /// <summary>Runs an loop to process all queued work items.</summary>
            public void RunOnCurrentThread()
            {
                foreach (var workItem in m_queue.GetConsumingEnumerable())
                    workItem.Key(workItem.Value);
            }

            /// <summary>Notifies the context that no more work will arrive.</summary>
            public void Complete() { m_queue.CompleteAdding(); }

            /// <summary>Invoked when an async operation is started.</summary>
            public override void OperationStarted()
            {
                if (m_trackOperations)
                    Interlocked.Increment(ref m_operationCount);
            }

            /// <summary>Invoked when an async operation is completed.</summary>
            public override void OperationCompleted()
            {
                if (m_trackOperations &&
                    Interlocked.Decrement(ref m_operationCount) == 0)
                    Complete();
            }
        }
    }
}

Pemakaian:

AsyncPump.Run(() => FooAsync(...));

Penjelasan lebih rinci tentang pompa async tersedia di sini .

Kepada siapa pun yang memperhatikan pertanyaan ini lagi ...

Jika Anda melihat Microsoft.VisualStudio.Services.WebApiada kelas yang disebut TaskExtensions. Di dalam kelas itu Anda akan melihat metode ekstensi statis Task.SyncResult(), yang seperti benar-benar hanya memblokir utas sampai tugas kembali.

Secara internal itu panggilan task.GetAwaiter().GetResult()yang sangat sederhana, namun itu kelebihan beban untuk bekerja pada asyncmetode apa pun yang kembali Task, Task<T>atau Task<HttpResponseMessage>... gula sintaksis, sayang ... ayah punya gigi manis.

Sepertinya ...GetAwaiter().GetResult()ini adalah cara resmi-MS untuk mengeksekusi kode async dalam konteks pemblokiran. Tampaknya bekerja dengan sangat baik untuk use case saya.

var result = Task.Run(async () => await configManager.GetConfigurationAsync()).ConfigureAwait(false);

OpenIdConnectConfiguration config = result.GetAwaiter().GetResult();

Atau gunakan ini:

var result=result.GetAwaiter().GetResult().AccessToken

Anda dapat memanggil metode asinkron apa pun dari kode sinkron, yaitu, sampai Anda perlu awaitmenggunakannya, dalam hal ini mereka juga harus ditandai async.

Karena banyak orang menyarankan di sini, Anda bisa memanggil Tunggu () atau Hasil pada tugas yang dihasilkan dalam metode sinkron Anda, tetapi kemudian Anda berakhir dengan panggilan pemblokiran dalam metode itu, yang jenisnya mengalahkan tujuan async.

Jika Anda benar-benar tidak dapat membuat metode asyncAnda dan Anda tidak ingin mengunci metode sinkron, maka Anda harus menggunakan metode panggilan balik dengan meneruskannya sebagai parameter ke metode ContinueWith pada tugas.

Saya tahu saya sangat terlambat. Tapi kalau-kalau seseorang seperti saya ingin menyelesaikan ini dengan rapi, cara mudah, dan tanpa tergantung pada perpustakaan lain.

Saya menemukan potongan kode berikut dari Ryan

public static class AsyncHelpers
{
    private static readonly TaskFactory taskFactory = new
        TaskFactory(CancellationToken.None,
            TaskCreationOptions.None,
            TaskContinuationOptions.None,
            TaskScheduler.Default);

    /// <summary>
    /// Executes an async Task method which has a void return value synchronously
    /// USAGE: AsyncUtil.RunSync(() => AsyncMethod());
    /// </summary>
    /// <param name="task">Task method to execute</param>
    public static void RunSync(Func<Task> task)
        => taskFactory
            .StartNew(task)
            .Unwrap()
            .GetAwaiter()
            .GetResult();

    /// <summary>
    /// Executes an async Task<T> method which has a T return type synchronously
    /// USAGE: T result = AsyncUtil.RunSync(() => AsyncMethod<T>());
    /// </summary>
    /// <typeparam name="TResult">Return Type</typeparam>
    /// <param name="task">Task<T> method to execute</param>
    /// <returns></returns>
    public static TResult RunSync<TResult>(Func<Task<TResult>> task)
        => taskFactory
            .StartNew(task)
            .Unwrap()
            .GetAwaiter()
            .GetResult();
}

maka Anda bisa menyebutnya seperti ini

var t = AsyncUtil.RunSync<T>(() => AsyncMethod<T>());

Setelah berjam-jam mencoba metode yang berbeda, dengan keberhasilan yang kurang lebih, inilah yang saya akhiri. Itu tidak berakhir dengan jalan buntu saat mendapatkan hasil dan juga mendapatkan dan melempar pengecualian asli dan bukan yang dibungkus.

private ReturnType RunSync()
{
  var task = Task.Run(async () => await myMethodAsync(agency));
  if (task.IsFaulted && task.Exception != null)
  {
    throw task.Exception;
  }

  return task.Result;
}

Itu bisa dipanggil dari utas baru (BUKAN dari kumpulan utas!):

public static class SomeHelperClass
{ 
       public static T Result<T>(Func<T> func)
        {
            return Task.Factory.StartNew<T>(
                  () => func()
                , TaskCreationOptions.LongRunning
                ).Result;
        }
}
...
content = SomeHelperClass.Result<string>(
  () => response.Content.ReadAsStringAsync().Result
  );

Metode windows async tersebut memiliki metode kecil yang bagus yang disebut AsTask (). Anda bisa menggunakan ini untuk meminta metode mengembalikan dirinya sebagai tugas sehingga Anda bisa memanggil Tunggu () secara manual.

Misalnya, pada aplikasi Windows Phone 8 Silverlight, Anda dapat melakukan hal berikut:

private void DeleteSynchronous(string path)
{
    StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
    Task t = localFolder.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask();
    t.Wait();
}

private void FunctionThatNeedsToBeSynchronous()
{
    // Do some work here
    // ....

    // Delete something in storage synchronously
    DeleteSynchronous("pathGoesHere");

    // Do other work here 
    // .....
}

Semoga ini membantu!

Jika Anda ingin menjalankannya Sync

MethodAsync().RunSynchronously()

   //Example from non UI thread -    
   private void SaveAssetAsDraft()
    {
        SaveAssetDataAsDraft();
    }
    private async Task<bool> SaveAssetDataAsDraft()
    {
       var id = await _assetServiceManager.SavePendingAssetAsDraft();
       return true;   
    }
   //UI Thread - 
   var result = Task.Run(() => SaveAssetDataAsDraft().Result).Result;