Bagaimana saya menjalankan metode Tugas asinkron <T> secara sinkron?

Saya belajar tentang async / menunggu, dan mengalami situasi di mana saya perlu memanggil metode async secara serempak. Bagaimana saya bisa melakukan itu?

Metode Async:

public async Task<Customers> GetCustomers()
{
    return await Service.GetCustomersAsync();
}

Penggunaan normal:

public async void GetCustomers()
{
    customerList = await GetCustomers();
}

Saya sudah mencoba menggunakan yang berikut ini:

Task<Customer> task = GetCustomers();
task.Wait()

Task<Customer> task = GetCustomers();
task.RunSynchronously();

Task<Customer> task = GetCustomers();
while(task.Status != TaskStatus.RanToCompletion)

Saya juga mencoba saran dari sini , tetapi tidak berfungsi ketika operator dalam keadaan ditangguhkan.

public static void WaitWithPumping(this Task task) 
{
        if (task == null) throw new ArgumentNullException(“task”);
        var nestedFrame = new DispatcherFrame();
        task.ContinueWith(_ => nestedFrame.Continue = false);
        Dispatcher.PushFrame(nestedFrame);
        task.Wait();
}

Berikut adalah pengecualian dan susun jejak dari panggilan RunSynchronously:

System.InvalidOperationException

Pesan : RunSynchronously tidak dapat dipanggil pada tugas yang tidak terikat ke delegasi.

InnerException : null

Sumber : mscorlib

StackTrace :

          at System.Threading.Tasks.Task.InternalRunSynchronously(TaskScheduler scheduler)
   at System.Threading.Tasks.Task.RunSynchronously()
   at MyApplication.CustomControls.Controls.MyCustomControl.CreateAvailablePanelList() in C:\Documents and Settings\...\MyApplication.CustomControls\Controls\MyCustomControl.xaml.cs:line 638
   at MyApplication.CustomControls.Controls.MyCustomControl.get_AvailablePanels() in C:\Documents and Settings\...\MyApplication.CustomControls\Controls\MyCustomControl.xaml.cs:line 233
   at MyApplication.CustomControls.Controls.MyCustomControl.<CreateOpenPanelList>b__36(DesktopPanel panel) in C:\Documents and Settings\...\MyApplication.CustomControls\Controls\MyCustomControl.xaml.cs:line 597
   at System.Collections.Generic.List`1.ForEach(Action`1 action)
   at MyApplication.CustomControls.Controls.MyCustomControl.<CreateOpenPanelList>d__3b.MoveNext() in C:\Documents and Settings\...\MyApplication.CustomControls\Controls\MyCustomControl.xaml.cs:line 625
   at System.Runtime.CompilerServices.TaskAwaiter.<>c__DisplayClass7.<TrySetContinuationForAwait>b__1(Object state)
   at System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
   at MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(Object source, Delegate method, Object args, Int32 numArgs, Delegate catchHandler)
   at System.Windows.Threading.DispatcherOperation.InvokeImpl()
   at System.Windows.Threading.DispatcherOperation.InvokeInSecurityContext(Object state)
   at System.Threading.ExecutionContext.runTryCode(Object userData)
   at System.Runtime.CompilerServices.RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(TryCode code, CleanupCode backoutCode, Object userData)
   at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Windows.Threading.DispatcherOperation.Invoke()
   at System.Windows.Threading.Dispatcher.ProcessQueue()
   at System.Windows.Threading.Dispatcher.WndProcHook(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
   at MS.Win32.HwndWrapper.WndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam, Boolean& handled)
   at MS.Win32.HwndSubclass.DispatcherCallbackOperation(Object o)
   at System.Windows.Threading.ExceptionWrapper.InternalRealCall(Delegate callback, Object args, Int32 numArgs)
   at MS.Internal.Threading.ExceptionFilterHelper.TryCatchWhen(Object source, Delegate method, Object args, Int32 numArgs, Delegate catchHandler)
   at System.Windows.Threading.Dispatcher.InvokeImpl(DispatcherPriority priority, TimeSpan timeout, Delegate method, Object args, Int32 numArgs)
   at MS.Win32.HwndSubclass.SubclassWndProc(IntPtr hwnd, Int32 msg, IntPtr wParam, IntPtr lParam)
   at MS.Win32.UnsafeNativeMethods.DispatchMessage(MSG& msg)
   at System.Windows.Threading.Dispatcher.PushFrameImpl(DispatcherFrame frame)
   at System.Windows.Threading.Dispatcher.PushFrame(DispatcherFrame frame)
   at System.Windows.Threading.Dispatcher.Run()
   at System.Windows.Application.RunDispatcher(Object ignore)
   at System.Windows.Application.RunInternal(Window window)
   at System.Windows.Application.Run(Window window)
   at System.Windows.Application.Run()
   at MyApplication.App.Main() in C:\Documents and Settings\...\MyApplication\obj\Debug\App.g.cs:line 50
   at System.AppDomain._nExecuteAssembly(RuntimeAssembly assembly, String[] args)
   at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
   at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
   at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean ignoreSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
   at System.Threading.ThreadHelper.ThreadStart()

Berikut adalah solusi yang saya temukan yang berfungsi untuk semua kasus (termasuk dispatcher yang ditangguhkan). Ini bukan kode saya dan saya masih bekerja untuk sepenuhnya memahaminya, tetapi itu berhasil.

Itu bisa disebut menggunakan:

customerList = AsyncHelpers.RunSync<List<Customer>>(() => GetCustomers());

Kode berasal dari sini

public static class AsyncHelpers
{
    /// <summary>
    /// Execute's an async Task<T> method which has a void return value synchronously
    /// </summary>
    /// <param name="task">Task<T> method to execute</param>
    public static void RunSync(Func<Task> task)
    {
        var oldContext = SynchronizationContext.Current;
        var synch = new ExclusiveSynchronizationContext();
        SynchronizationContext.SetSynchronizationContext(synch);
        synch.Post(async _ =>
        {
            try
            {
                await task();
            }
            catch (Exception e)
            {
                synch.InnerException = e;
                throw;
            }
            finally
            {
                synch.EndMessageLoop();
            }
        }, null);
        synch.BeginMessageLoop();

        SynchronizationContext.SetSynchronizationContext(oldContext);
    }

    /// <summary>
    /// Execute's an async Task<T> method which has a T return type synchronously
    /// </summary>
    /// <typeparam name="T">Return Type</typeparam>
    /// <param name="task">Task<T> method to execute</param>
    /// <returns></returns>
    public static T RunSync<T>(Func<Task<T>> task)
    {
        var oldContext = SynchronizationContext.Current;
        var synch = new ExclusiveSynchronizationContext();
        SynchronizationContext.SetSynchronizationContext(synch);
        T ret = default(T);
        synch.Post(async _ =>
        {
            try
            {
                ret = await task();
            }
            catch (Exception e)
            {
                synch.InnerException = e;
                throw;
            }
            finally
            {
                synch.EndMessageLoop();
            }
        }, null);
        synch.BeginMessageLoop();
        SynchronizationContext.SetSynchronizationContext(oldContext);
        return ret;
    }

    private class ExclusiveSynchronizationContext : SynchronizationContext
    {
        private bool done;
        public Exception InnerException { get; set; }
        readonly AutoResetEvent workItemsWaiting = new AutoResetEvent(false);
        readonly Queue<Tuple<SendOrPostCallback, object>> items =
            new Queue<Tuple<SendOrPostCallback, object>>();

        public override void Send(SendOrPostCallback d, object state)
        {
            throw new NotSupportedException("We cannot send to our same thread");
        }

        public override void Post(SendOrPostCallback d, object state)
        {
            lock (items)
            {
                items.Enqueue(Tuple.Create(d, state));
            }
            workItemsWaiting.Set();
        }

        public void EndMessageLoop()
        {
            Post(_ => done = true, null);
        }

        public void BeginMessageLoop()
        {
            while (!done)
            {
                Tuple<SendOrPostCallback, object> task = null;
                lock (items)
                {
                    if (items.Count > 0)
                    {
                        task = items.Dequeue();
                    }
                }
                if (task != null)
                {
                    task.Item1(task.Item2);
                    if (InnerException != null) // the method threw an exeption
                    {
                        throw new AggregateException("AsyncHelpers.Run method threw an exception.", InnerException);
                    }
                }
                else
                {
                    workItemsWaiting.WaitOne();
                }
            }
        }

        public override SynchronizationContext CreateCopy()
        {
            return this;
        }
    }
}

Maklum jawaban ini berumur tiga tahun. Saya menulisnya sebagian besar didasarkan pada pengalaman dengan. Net 4.0, dan sangat sedikit dengan 4,5 terutama dengan async-await. Secara umum itu adalah solusi sederhana yang bagus, tetapi kadang-kadang merusak banyak hal. Silakan baca diskusi di komentar.

.Net 4.5

Gunakan ini saja:

// For Task<T>: will block until the task is completed...
var result = task.Result; 

// For Task (not Task<T>): will block until the task is completed...
task2.RunSynchronously();

Lihat: TaskAwaiter , Task.Result , Task.RunSynchronously

.Net 4.0

Gunakan ini:

var x = (IAsyncResult)task;
task.Start();

x.AsyncWaitHandle.WaitOne();

...atau ini:

task.Start();
task.Wait();

Terkejut tidak ada yang menyebutkan ini:

public Task<int> BlahAsync()
{
    // ...
}

int result = BlahAsync().GetAwaiter().GetResult();

Tidak secantik beberapa metode lain di sini, tetapi memiliki manfaat sebagai berikut:

• itu tidak menelan pengecualian (seperti Wait)
• itu tidak akan membungkus pengecualian apa pun yang dilemparkan ke dalam AggregateException(seperti Result)
• bekerja untuk keduanya Taskdan Task<T>( coba sendiri! )

Juga, karena GetAwaiterdiketik bebek, ini harus bekerja untuk objek apa pun yang dikembalikan dari metode async (suka ConfiguredAwaitableatau YieldAwaitable), bukan hanya Tugas.

sunting: Harap perhatikan bahwa pendekatan ini (atau menggunakan .Result) mungkin menemui jalan buntu, kecuali jika Anda memastikan untuk menambahkan .ConfigureAwait(false)setiap kali Anda menunggu, untuk semua metode async yang mungkin dapat dicapai dari BlahAsync()(bukan hanya yang dipanggil langsung). Penjelasan .

// In BlahAsync() body
await FooAsync(); // BAD!
await FooAsync().ConfigureAwait(false); // Good... but make sure FooAsync() and
                                        // all its descendants use ConfigureAwait(false)
                                        // too. Then you can be sure that
                                        // BlahAsync().GetAwaiter().GetResult()
                                        // won't deadlock.

Jika Anda terlalu malas untuk menambahkan di .ConfigureAwait(false)mana-mana, dan Anda tidak peduli dengan kinerja, Anda juga dapat melakukannya

Task.Run(() => BlahAsync()).GetAwaiter().GetResult()

Jauh lebih mudah untuk menjalankan tugas di kumpulan utas, daripada mencoba menipu penjadwal untuk menjalankannya secara serempak. Dengan begitu Anda dapat yakin bahwa itu tidak akan menemui jalan buntu. Kinerja terpengaruh karena saklar konteks.

Task<MyResult> DoSomethingAsync() { ... }

// Starts the asynchronous task on a thread-pool thread.
// Returns a proxy to the original task.
Task<MyResult> task = Task.Run(() => DoSomethingAsync());

// Will block until the task is completed...
MyResult result = task.Result; 

Saya belajar tentang async / menunggu, dan mengalami situasi di mana saya perlu memanggil metode async secara serempak. Bagaimana saya bisa melakukan itu?

Jawaban terbaik adalah Anda tidak , dengan detail tergantung pada apa "situasi" itu.

Apakah ini pengambil properti? Dalam kebanyakan kasus, lebih baik memiliki metode asinkron daripada "properti asinkron". (Untuk info lebih lanjut, lihat posting blog saya di properti asinkron ).

Apakah ini aplikasi MVVM dan Anda ingin melakukan pengikatan data asinkron? Kemudian gunakan sesuatu seperti saya NotifyTask, seperti yang dijelaskan dalam artikel MSDN saya tentang pengikatan data asinkron .

Apakah itu konstruktor? Maka Anda mungkin ingin mempertimbangkan metode pabrik asinkron. (Untuk info lebih lanjut, lihat posting blog saya di konstruktor asinkron ).

Hampir selalu ada jawaban yang lebih baik daripada melakukan sync-over-async.

Jika tidak mungkin untuk situasi Anda (dan Anda tahu ini dengan mengajukan pertanyaan di sini menggambarkan situasi ), maka saya akan merekomendasikan hanya menggunakan kode sinkron. Async adalah yang terbaik; sinkronisasi semua cara adalah yang terbaik kedua. Sinkronisasi-over-async tidak dianjurkan.

Namun, ada beberapa situasi di mana sinkronisasi-over-async diperlukan. Khususnya, Anda dibatasi oleh kode panggilan sehingga Anda harus disinkronkan (dan sama sekali tidak memiliki cara untuk memikirkan kembali atau menyusun kembali kode Anda untuk memungkinkan sinkronisasi), dan Anda harus memanggil kode async. Ini adalah situasi yang sangat langka, tetapi muncul dari waktu ke waktu.

Dalam hal ini, Anda harus menggunakan salah satu peretasan yang dijelaskan dalam artikel saya tentang pengembangan brownfieldasync , khususnya:

• Pemblokiran (misalnya, GetAwaiter().GetResult()). Perhatikan bahwa ini dapat menyebabkan kebuntuan (seperti yang saya jelaskan di blog saya).
• Menjalankan kode pada utas kumpulan utas (mis., Task.Run(..).GetAwaiter().GetResult()). Perhatikan bahwa ini hanya akan berfungsi jika kode asinkron dapat dijalankan pada utas kumpulan utas (yaitu, tidak bergantung pada konteks UI atau ASP.NET).
• Loop pesan bersarang. Perhatikan bahwa ini hanya akan berfungsi jika kode asinkron hanya mengasumsikan konteks single-threaded, bukan tipe konteks spesifik (banyak kode UI dan ASP.NET mengharapkan konteks tertentu).

Loop pesan bersarang adalah yang paling berbahaya dari semua peretasan, karena hal itu menyebabkan pemanggilan kembali . Re-entrancy sangat sulit untuk dipikirkan, dan (IMO) adalah penyebab sebagian besar bug aplikasi pada Windows. Secara khusus, jika Anda berada di utas UI dan Anda memblokir antrian pekerjaan (menunggu pekerjaan async selesai), maka CLR benar-benar melakukan beberapa pemompaan pesan untuk Anda - itu sebenarnya akan menangani beberapa pesan Win32 dari dalam Anda kode . Oh, dan Anda tidak tahu pesan mana - ketika Chris Brumme berkata, "Bukankah lebih baik mengetahui dengan pasti apa yang akan dipompa? Sayangnya, memompa adalah seni hitam yang berada di luar jangkauan pemahaman fana." , maka kita benar-benar tidak memiliki harapan untuk mengetahui.

Jadi, ketika Anda memblokir seperti ini di utas UI, Anda meminta masalah. Kutipan cbrumme lain dari artikel yang sama: "Dari waktu ke waktu, pelanggan di dalam atau di luar perusahaan menemukan bahwa kami memompa pesan selama pemblokiran berhasil pada STA [utas UI]. Ini adalah kekhawatiran yang sah, karena mereka tahu bahwa itu sangat sulit untuk menulis kode yang kuat dalam menghadapi reentrancy. "

Ya itu. Sangat sulit untuk menulis kode yang kuat dalam menghadapi reentrancy. Dan loop pesan bersarang memaksa Anda untuk menulis kode yang kuat dalam menghadapi reentrancy. Inilah sebabnya mengapa jawaban yang diterima (dan yang paling banyak dipilih) untuk pertanyaan ini sangat berbahaya dalam praktiknya.

Jika Anda benar-benar keluar dari semua opsi lain - Anda tidak dapat mendesain ulang kode Anda, Anda tidak dapat menata ulang menjadi async - Anda dipaksa oleh kode panggilan yang tidak dapat diubah untuk disinkronkan - Anda tidak dapat mengubah kode hilir menjadi sinkronisasi - Anda tidak dapat memblokir - Anda tidak dapat menjalankan kode async pada utas terpisah - saat itu dan baru Anda harus mempertimbangkan merangkul reentrancy.

Jika Anda menemukan diri Anda di sudut ini, saya akan merekomendasikan menggunakan sesuatu seperti Dispatcher.PushFrameuntuk aplikasi WPF , mengulang dengan Application.DoEventsuntuk aplikasi WinForm, dan untuk kasus umum, saya sendiri AsyncContext.Run.

Jika saya membaca pertanyaan Anda dengan benar - kode yang ingin panggilan sinkron ke metode async dijalankan pada utas dispatcher yang ditangguhkan. Dan Anda ingin benar-benar secara bersamaan memblokir utas itu sampai metode async selesai.

Metode Async di C # 5 didukung oleh secara efektif memotong metode menjadi potongan-potongan di bawah tenda, dan mengembalikan Taskyang dapat melacak penyelesaian keseluruhan shabang keseluruhan. Namun, bagaimana metode cacah mengeksekusi dapat bergantung pada jenis ekspresi yang diteruskan ke awaitoperator.

Sebagian besar waktu, Anda akan menggunakan awaitekspresi tipe Task. Implementasi Task dari awaitpola adalah "pintar" karena tidak sesuai dengan SynchronizationContext, yang pada dasarnya menyebabkan hal berikut terjadi:

1. Jika utas yang masuk awaitberada pada utas loop pesan Dispatcher atau WinForms, itu memastikan bahwa potongan metode async terjadi sebagai bagian dari pemrosesan antrian pesan.
2. Jika utas yang masuk awaitberada pada utas pool ulir, maka potongan yang tersisa dari metode async terjadi di mana saja pada utas pool.

Itu sebabnya Anda mungkin mengalami masalah - implementasi metode async mencoba menjalankan sisanya pada Dispatcher - meskipun ditangguhkan.

.... mendukung! ....

Saya harus mengajukan pertanyaan, mengapa Anda mencoba untuk memblokir metode async secara sinkron? Melakukan hal itu akan mengalahkan tujuan mengapa metode ingin dipanggil secara tidak sinkron. Secara umum, ketika Anda mulai menggunakan awaitmetode Dispatcher atau UI, Anda ingin mengubah seluruh aliran UI Anda sebagai sinkronisasi. Misalnya, jika callstack Anda mirip dengan yang berikut:

1. [Teratas] WebRequest.GetResponse()
2. YourCode.HelperMethod()
3. YourCode.AnotherMethod()
4. YourCode.EventHandlerMethod()
5. [UI Code].Plumbing()- WPFatau WinFormsKode
6. [Message Loop] - WPFatau WinFormsLoop Pesan

Kemudian setelah kode diubah untuk menggunakan async, biasanya Anda akan berakhir dengan

1. [Teratas] WebRequest.GetResponseAsync()
2. YourCode.HelperMethodAsync()
3. YourCode.AnotherMethodAsync()
4. YourCode.EventHandlerMethodAsync()
5. [UI Code].Plumbing()- WPFatau WinFormsKode
6. [Message Loop] - WPFatau WinFormsLoop Pesan

Sebenarnya Menjawab

Kelas AsyncHelpers di atas benar-benar berfungsi karena berperilaku seperti loop pesan bersarang, tetapi menginstal mekanik paralelnya sendiri ke Dispatcher daripada mencoba mengeksekusi pada Dispatcher itu sendiri. Itu satu solusi untuk masalah Anda.

Solusi lain adalah dengan mengeksekusi metode async Anda pada utas threadpool, dan kemudian menunggu sampai selesai. Melakukannya mudah - Anda dapat melakukannya dengan cuplikan berikut:

var customerList = TaskEx.RunEx(GetCustomers).Result;

API terakhir adalah Task.Run (...), tetapi dengan CTP Anda akan membutuhkan akhiran Ex ( penjelasan di sini ).

Ini bekerja dengan baik untuk saya

public static class TaskHelper
{
    public static void RunTaskSynchronously(this Task t)
    {
        var task = Task.Run(async () => await t);
        task.Wait();
    }

    public static T RunTaskSynchronously<T>(this Task<T> t)
    {
        T res = default(T);
        var task = Task.Run(async () => res = await t);
        task.Wait();
        return res;
    }
}

Cara paling sederhana yang saya temukan untuk menjalankan tugas secara sinkron dan tanpa memblokir utas UI adalah dengan menggunakan RunSynchronously () seperti:

Task t = new Task(() => 
{ 
   //.... YOUR CODE ....
});
t.RunSynchronously();

Dalam kasus saya, saya memiliki peristiwa yang menyala ketika sesuatu terjadi. Saya tidak tahu berapa kali itu akan terjadi. Jadi, saya menggunakan kode di atas dalam acara saya, jadi setiap kali menyala, ia membuat tugas. Tugas dieksekusi secara serempak dan itu bekerja dengan baik untuk saya. Saya hanya terkejut bahwa butuh waktu lama bagi saya untuk mengetahui hal ini mengingat betapa sederhananya itu. Biasanya, rekomendasi jauh lebih kompleks dan rawan kesalahan. Ini sederhana dan bersih.

Saya sudah menghadapinya beberapa kali, kebanyakan dalam pengujian unit atau dalam pengembangan layanan windows. Saat ini saya selalu menggunakan fitur ini:

        var runSync = Task.Factory.StartNew(new Func<Task>(async () =>
        {
            Trace.WriteLine("Task runSync Start");
            await TaskEx.Delay(2000); // Simulates a method that returns a task and
                                      // inside it is possible that there
                                      // async keywords or anothers tasks
            Trace.WriteLine("Task runSync Completed");
        })).Unwrap();
        Trace.WriteLine("Before runSync Wait");
        runSync.Wait();
        Trace.WriteLine("After runSync Waited");

Sederhana, mudah, dan saya tidak punya masalah.

Saya menemukan kode ini di komponen Microsoft.AspNet.Identity.Core, dan berfungsi.

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

// Microsoft.AspNet.Identity.AsyncHelper
public static TResult RunSync<TResult>(Func<Task<TResult>> func)
{
    CultureInfo cultureUi = CultureInfo.CurrentUICulture;
    CultureInfo culture = CultureInfo.CurrentCulture;
    return AsyncHelper._myTaskFactory.StartNew<Task<TResult>>(delegate
    {
        Thread.CurrentThread.CurrentCulture = culture;
        Thread.CurrentThread.CurrentUICulture = cultureUi;
        return func();
    }).Unwrap<TResult>().GetAwaiter().GetResult();
}

Hanya sedikit catatan - pendekatan ini:

Task<Customer> task = GetCustomers();
task.Wait()

bekerja untuk WinRT.

Biarkan saya jelaskan:

private void TestMethod()
{
    Task<Customer> task = GetCustomers(); // call async method as sync and get task as result
    task.Wait(); // wait executing the method
    var customer = task.Result; // get's result.
    Debug.WriteLine(customer.Name); //print customer name
}
public class Customer
{
    public Customer()
    {
        new ManualResetEvent(false).WaitOne(TimeSpan.FromSeconds(5));//wait 5 second (long term operation)
    }
    public string Name { get; set; }
}
private Task<Customer> GetCustomers()
{
    return Task.Run(() => new Customer
    {
        Name = "MyName"
    });
}

Selain itu pendekatan ini hanya berfungsi untuk solusi Windows Store!

Catatan: Cara ini tidak aman untuk thread jika Anda memanggil metode Anda di dalam metode async lainnya (menurut komentar dari @Servy)

Dalam kode Anda, tugas tunggu pertama Anda untuk dieksekusi tetapi Anda belum memulainya sehingga menunggu tanpa batas. Coba ini:

Task<Customer> task = GetCustomers();
task.RunSynchronously();

Edit:

Anda mengatakan bahwa Anda mendapatkan pengecualian. Silakan kirim detail lebih lanjut, termasuk jejak tumpukan.
Mono berisi test case berikut:

[Test]
public void ExecuteSynchronouslyTest ()
{
        var val = 0;
        Task t = new Task (() => { Thread.Sleep (100); val = 1; });
        t.RunSynchronously ();

        Assert.AreEqual (1, val);
}

Periksa apakah ini cocok untuk Anda. Jika tidak, meskipun sangat tidak mungkin, Anda mungkin memiliki CTP Async build yang aneh. Jika berhasil, Anda mungkin ingin memeriksa apa yang sebenarnya dihasilkan oleh kompiler dan bagaimana Taskinstantiasi berbeda dari sampel ini.

Edit # 2:

Aku memeriksa dengan reflektor bahwa pengecualian Anda dijelaskan terjadi ketika m_actionadalah null. Ini agak aneh, tapi saya bukan ahli CTP Async. Seperti yang saya katakan, Anda harus mendekompilasi kode Anda dan melihat bagaimana sebenarnya Tasksedang dipakai bagaimana pun m_actionitu null.

PS Apa masalahnya dengan downvotes sesekali? Peduli menguraikan?

Diuji dalam .Net 4.6. Itu juga dapat menghindari kebuntuan.

Untuk metode async kembali Task.

Task DoSomeWork();
Task.Run(async () => await DoSomeWork()).Wait();

Untuk metode async kembali Task<T>

Task<T> GetSomeValue();
var result = Task.Run(() => GetSomeValue()).Result;

Edit :

Jika pemanggil berjalan di utas kumpulan utas (atau penelepon juga dalam tugas), itu mungkin masih menyebabkan kebuntuan dalam beberapa situasi.

gunakan snip kode di bawah ini

Task.WaitAll(Task.Run(async () => await service.myAsyncMethod()));

Mengapa tidak membuat panggilan seperti:

Service.GetCustomers();

itu bukan async.

Jawaban ini dirancang untuk siapa saja yang menggunakan WPF untuk .NET 4.5.

Jika Anda mencoba mengeksekusi Task.Run()di utas GUI, maka task.Wait()akan hang tanpa batas, jika Anda tidak memiliki asynckata kunci dalam definisi fungsi Anda.

Metode ekstensi ini memecahkan masalah dengan memeriksa untuk melihat apakah kita berada di utas GUI, dan jika demikian, menjalankan tugas pada utas pengirim WPF.

Kelas ini dapat bertindak sebagai perekat antara dunia async / await dan dunia non-async / await, dalam situasi di mana ia tidak dapat dihindari, seperti properti MVVM atau dependensi pada API lain yang tidak menggunakan async / tunggu.

/// <summary>
///     Intent: runs an async/await task synchronously. Designed for use with WPF.
///     Normally, under WPF, if task.Wait() is executed on the GUI thread without async
///     in the function signature, it will hang with a threading deadlock, this class 
///     solves that problem.
/// </summary>
public static class TaskHelper
{
    public static void MyRunTaskSynchronously(this Task task)
    {
        if (MyIfWpfDispatcherThread)
        {
            var result = Dispatcher.CurrentDispatcher.InvokeAsync(async () => { await task; });
            result.Wait();
            if (result.Status != DispatcherOperationStatus.Completed)
            {
                throw new Exception("Error E99213. Task did not run to completion.");
            }
        }
        else
        {
            task.Wait();
            if (task.Status != TaskStatus.RanToCompletion)
            {
                throw new Exception("Error E33213. Task did not run to completion.");
            }
        }
    }

    public static T MyRunTaskSynchronously<T>(this Task<T> task)
    {       
        if (MyIfWpfDispatcherThread)
        {
            T res = default(T);
            var result = Dispatcher.CurrentDispatcher.InvokeAsync(async () => { res = await task; });
            result.Wait();
            if (result.Status != DispatcherOperationStatus.Completed)
            {
                throw new Exception("Error E89213. Task did not run to completion.");
            }
            return res;
        }
        else
        {
            T res = default(T);
            var result = Task.Run(async () => res = await task);
            result.Wait();
            if (result.Status != TaskStatus.RanToCompletion)
            {
                throw new Exception("Error E12823. Task did not run to completion.");
            }
            return res;
        }
    }

    /// <summary>
    ///     If the task is running on the WPF dispatcher thread.
    /// </summary>
    public static bool MyIfWpfDispatcherThread
    {
        get
        {
            return Application.Current.Dispatcher.CheckAccess();
        }
    }
}

Cukup menelepon .Result;atau .Wait()merupakan risiko untuk kebuntuan seperti yang banyak dikatakan dalam komentar. Karena sebagian besar dari kita suka oneliners Anda dapat menggunakannya untuk.Net 4.5<

Memperoleh nilai melalui metode async:

var result = Task.Run(() => asyncGetValue()).Result;

Sinkron memanggil metode async

Task.Run(() => asyncMethod()).Wait();

Tidak ada masalah jalan buntu yang akan terjadi karena penggunaan Task.Run.

Sumber:

https://stackoverflow.com/a/32429753/3850405

Saya pikir metode pembantu berikut ini juga bisa menyelesaikan masalah.

private TResult InvokeAsyncFuncSynchronously<TResult>(Func< Task<TResult>> func)
    {
        TResult result = default(TResult);
        var autoResetEvent = new AutoResetEvent(false);

        Task.Run(async () =>
        {
            try
            {
                result = await func();
            }
            catch (Exception exc)
            {
                mErrorLogger.LogError(exc.ToString());
            }
            finally
            {
                autoResetEvent.Set();
            }
        });
        autoResetEvent.WaitOne();

        return result;
    }

Dapat digunakan dengan cara berikut:

InvokeAsyncFuncSynchronously(Service.GetCustomersAsync);

Ini bekerja untuk saya

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

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

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

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

    class SomeClass
    {
        public async Task<object> LoginAsync(object loginInfo)
        {
            return await Task.FromResult(0);
        }
        public object Login(object loginInfo)
        {
            return AsyncHelper.RunSync(() => LoginAsync(loginInfo));
            //return this.LoginAsync(loginInfo).Result.Content;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            var someClass = new SomeClass();

            Console.WriteLine(someClass.Login(1));
            Console.ReadLine();
        }
    }
}

Saya telah menemukan bahwa SpinWait bekerja dengan sangat baik untuk ini.

var task = Task.Run(()=>DoSomethingAsyncronous());

if(!SpinWait.SpinUntil(()=>task.IsComplete, TimeSpan.FromSeconds(30)))
{//Task didn't complete within 30 seconds, fail...
   return false;
}

return true;

Pendekatan di atas tidak perlu menggunakan .Result atau. Tunggu (). Ini juga memungkinkan Anda menentukan batas waktu agar Anda tidak terjebak selamanya jika tugas tidak pernah selesai.

Pada wp8:

Bungkus itu:

Task GetCustomersSynchronously()
{
    Task t = new Task(async () =>
    {
        myCustomers = await GetCustomers();
    }
    t.RunSynchronously();
}

Sebut saja:

GetCustomersSynchronously();

    private int GetSync()
    {
        try
        {
            ManualResetEvent mre = new ManualResetEvent(false);
            int result = null;

            Parallel.Invoke(async () =>
            {
                result = await SomeCalcAsync(5+5);
                mre.Set();
            });

            mre.WaitOne();
            return result;
        }
        catch (Exception)
        {
            return null;
        }
    }

Atau Anda bisa pergi dengan:

customerList = Task.Run<List<Customer>>(() => { return GetCustomers(); }).Result;

Agar ini dikompilasi, pastikan Anda merujuk perakitan ekstensi:

System.Net.Http.Formatting

Coba kode berikut ini berfungsi untuk saya:

public async void TaskSearchOnTaskList (SearchModel searchModel)
{
    try
    {
        List<EventsTasksModel> taskSearchList = await Task.Run(
            () => MakeasyncSearchRequest(searchModel),
            cancelTaskSearchToken.Token);

        if (cancelTaskSearchToken.IsCancellationRequested
                || string.IsNullOrEmpty(rid_agendaview_search_eventsbox.Text))
        {
            return;
        }

        if (taskSearchList == null || taskSearchList[0].result == Constants.ZERO)
        {
            RunOnUiThread(() => {
                textViewNoMembers.Visibility = ViewStates.Visible;                  
                taskListView.Visibility = ViewStates.Gone;
            });

            taskSearchRecureList = null;

            return;
        }
        else
        {
            taskSearchRecureList = TaskFooterServiceLayer
                                       .GetRecurringEvent(taskSearchList);

            this.SetOnAdapter(taskSearchRecureList);
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine("ActivityTaskFooter -> TaskSearchOnTaskList:" + ex.Message);
    }
}