ฉันจะใช้วิธีการทำงานของ async <T> แบบซิงโครนัสได้อย่างไร

ฉันเรียนรู้เกี่ยวกับ async / คอยและพบกับสถานการณ์ที่ฉันต้องเรียกวิธีการ async พร้อมกัน ฉันจะทำสิ่งนั้นได้อย่างไร

วิธีการซิงค์:

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

การใช้งานปกติ:

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

ฉันได้ลองใช้สิ่งต่อไปนี้:

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

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

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

ฉันลองใช้คำแนะนำจากที่นี่แต่มันไม่ทำงานเมื่อโปรแกรมเลือกจ่ายงานอยู่ในสถานะถูกระงับ

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

นี่คือข้อยกเว้นและการติดตามสแต็กจากการโทรRunSynchronously:

System.InvalidOperationException

ข้อความ : RunSynchronously อาจไม่ถูกเรียกบนภารกิจที่ไม่ได้ผูกไว้กับผู้รับมอบสิทธิ์

InnerException : null

ที่มา : 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()

นี่เป็นวิธีแก้ปัญหาที่ฉันพบว่าใช้งานได้กับทุกกรณี (รวมถึงโปรแกรมเลือกจ่ายงานที่ถูกระงับ) ไม่ใช่รหัสของฉันและฉันยังคงทำงานเพื่อทำความเข้าใจ แต่ก็ใช้งานได้

มันสามารถเรียกได้ว่าใช้:

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

รหัสมาจากที่นี่

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

ได้รับคำแนะนำคำตอบนี้มีอายุสามปี ฉันเขียนมันขึ้นอยู่กับประสบการณ์ที่มีสุทธิ 4.0 และน้อยมากกับ 4.5 async-awaitโดยเฉพาะอย่างยิ่งกับ โดยทั่วไปการพูดมันเป็นวิธีการแก้ปัญหาที่ดี แต่บางครั้งก็อาจแบ่งสิ่งต่าง ๆ ได้ โปรดอ่านการอภิปรายในความคิดเห็น

.Net 4.5

เพียงใช้สิ่งนี้:

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

โปรดดู: TaskAwaiter , Task.Result , Task.RunSynchronously

.Net 4.0

ใช้สิ่งนี้:

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

x.AsyncWaitHandle.WaitOne();

... หรือสิ่งนี้:

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

แปลกใจที่ไม่มีใครพูดถึงเรื่องนี้:

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

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

ไม่สวยเท่าวิธีอื่น ๆ ที่นี่ แต่มีประโยชน์ดังต่อไปนี้:

• มันไม่กลืนข้อยกเว้น (เช่นWait)
• มันจะไม่ห่อข้อยกเว้นใด ๆ ที่ถูกโยนในAggregateException(เช่นResult)
• ทำงานได้ทั้งTaskและTask<T>( ลองด้วยตัวเอง! )

นอกจากนี้เนื่องจากGetAwaiterถูกพิมพ์ด้วยเป็ดสิ่งนี้ควรทำงานกับวัตถุใด ๆ ที่ส่งคืนจากเมธอด async (เหมือนConfiguredAwaitableหรือYieldAwaitable) ไม่ใช่แค่งาน

แก้ไข:โปรดทราบว่าเป็นไปได้สำหรับวิธีการนี้ (หรือใช้.Result) ในการหยุดชะงักเว้นแต่ว่าคุณจะต้องเพิ่ม.ConfigureAwait(false)ทุกครั้งที่คุณรอสำหรับวิธีการซิงค์ทั้งหมดที่สามารถเข้าถึงได้BlahAsync()(ไม่ใช่แค่การโทรโดยตรง) คำอธิบาย

// 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.

หากคุณขี้เกียจเกินกว่าที่จะเพิ่มได้.ConfigureAwait(false)ทุกที่และคุณไม่สนใจเกี่ยวกับประสิทธิภาพที่คุณสามารถทำได้

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

มันง่ายกว่ามากในการรันภารกิจบนเธรดพูลแทนที่จะพยายามหลอกให้ตัวกำหนดตารางเวลารันแบบซิงโครนัส ด้วยวิธีนี้คุณสามารถมั่นใจได้ว่ามันจะไม่หยุดชะงัก ประสิทธิภาพได้รับผลกระทบเนื่องจากการสลับบริบท

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; 

ฉันเรียนรู้เกี่ยวกับ async / คอยและพบกับสถานการณ์ที่ฉันต้องเรียกวิธีการ async พร้อมกัน ฉันจะทำสิ่งนั้นได้อย่างไร

คำตอบที่ดีที่สุดคือคุณทำไม่ได้โดยมีรายละเอียดขึ้นอยู่กับว่า "สถานการณ์" คืออะไร

มันเป็นคุณสมบัติทะเยอทะยาน / setter? ในกรณีส่วนใหญ่จะดีกว่าถ้ามีวิธีแบบอะซิงโครนัสมากกว่า "คุณสมบัติแบบอะซิงโครนัส" (สำหรับข้อมูลเพิ่มเติมดูโพสต์บล็อกของฉันเกี่ยวกับคุณสมบัติแบบอะซิงโครนัส )

นี่เป็นแอป MVVM และคุณต้องการผูกข้อมูลแบบอะซิงโครนัสหรือไม่ แล้วใช้สิ่งที่ต้องการของฉันNotifyTaskที่อธิบายไว้ในของฉันบทความ MSDN กับข้อมูลที่ไม่ตรงกันมีผลผูกพัน

มันเป็นตัวสร้างหรือไม่? จากนั้นคุณอาจต้องการพิจารณาวิธีโรงงานแบบอะซิงโครนัส (สำหรับข้อมูลเพิ่มเติมดูโพสต์บล็อกของฉันในตัวสร้างแบบอะซิงโครนัส )

มีคำตอบที่ดีกว่าการซิงค์แบบอะซิงโครนัสเกือบทุกครั้ง

หากเป็นไปไม่ได้สำหรับสถานการณ์ของคุณ (และคุณรู้เรื่องนี้โดยถามคำถามที่นี่เพื่ออธิบายสถานการณ์ ) ดังนั้นฉันขอแนะนำให้ใช้รหัสซิงโครนัส Async ตลอดทางดีที่สุด ซิงค์ทุกวิธีดีที่สุดเป็นอันดับสอง ไม่แนะนำให้ซิงค์กับ over-async

อย่างไรก็ตามมีสถานการณ์เพียงไม่กี่อย่างที่จำเป็นต้องใช้ โดยเฉพาะอย่างยิ่งคุณถูก จำกัด โดยรหัสการโทรเพื่อให้คุณต้องซิงค์ (และไม่มีวิธีคิดหรือจัดโครงสร้างรหัสของคุณใหม่เพื่อให้ไม่ตรงกัน) และคุณต้องเรียกรหัส async อันนี้เป็นอย่างมากสถานการณ์ที่หายากแต่มันก็เกิดขึ้นเป็นครั้งคราว

ในกรณีนี้คุณจะต้องใช้หนึ่งในแฮ็กที่อธิบายไว้ในบทความของฉันเกี่ยวกับการพัฒนาBrownfieldasyncโดยเฉพาะ:

• การปิดกั้น (เช่นGetAwaiter().GetResult()) โปรดทราบว่านี่อาจทำให้เกิดการหยุดชะงัก (ตามที่ฉันอธิบายในบล็อกของฉัน)
• การเรียกใช้โค้ดบนเธรดพูลเธรด (เช่นTask.Run(..).GetAwaiter().GetResult()) โปรดทราบว่านี่จะใช้งานได้หากรหัสอะซิงโครนัสสามารถรันได้บนเธรดพูลเธรด (เช่นไม่ได้ขึ้นอยู่กับบริบท UI หรือ ASP.NET)
• ข้อความที่ซ้อนกันวนซ้ำ โปรดทราบว่านี่จะใช้งานได้หากรหัสอะซิงโครนัสถือว่าเป็นบริบทแบบเธรดเดียวไม่ใช่ประเภทบริบทเฉพาะ (UI และรหัส ASP.NET จำนวนมากคาดหวังบริบทเฉพาะ)

ลูปข้อความที่ซ้อนกันเป็นที่อันตรายที่สุดของแฮ็กทั้งหมดเพราะมันทำให้เกิดอีกครั้ง entrancy การเข้ามาใหม่นั้นยากมากที่จะให้เหตุผลและ (IMO) เป็นสาเหตุของข้อบกพร่องของแอปพลิเคชันส่วนใหญ่ใน Windows โดยเฉพาะอย่างยิ่งถ้าคุณอยู่ในเธรด UI และคุณบล็อกคิวงาน (รอให้การทำงานของ async เสร็จสมบูรณ์) CLR จะส่งข้อความถึงคุณจริง ๆ - มันจะจัดการกับข้อความ Win32 บางส่วนจากภายในของคุณ รหัส โอ้และคุณไม่รู้หรอกว่าข้อความอะไร - เมื่อคริสบรูม พูดว่า "มันจะไม่เป็นการดีที่จะรู้ว่าสิ่งที่จะได้รับการสูบฉีด แต่น่าเสียดายที่การปั๊มเป็นศิลปะสีดำซึ่งเกินกว่าความเข้าใจของมนุษย์"แล้วเราก็ไม่มีความหวังที่จะรู้

ดังนั้นเมื่อคุณบล็อกสิ่งนี้ในเธรด UI คุณจะถามถึงปัญหา คำพูด cbrumme อื่นจากบทความเดียวกัน: "ในบางครั้งลูกค้าภายในหรือภายนอก บริษัท ค้นพบว่าเรากำลังปั๊มข้อความในระหว่างการบล็อกการจัดการบน STA [UI thread] นี่เป็นข้อกังวลที่ถูกต้องตามกฎหมายเพราะพวกเขารู้ว่ามันยากมาก เพื่อเขียนโค้ดที่มีความแข็งแกร่งเมื่อเผชิญกับ reentrancy "

ใช่แล้ว. ยากมากที่จะเขียนโค้ดที่มีความแข็งแกร่งเมื่อเผชิญกับความ reentrancy และลูปข้อความซ้อนกันบังคับให้คุณเขียนโค้ดที่มีความแข็งแกร่งเมื่อเผชิญกับการแสดงซ้ำ นี่คือเหตุผลที่คำตอบที่ยอมรับ (และถูกโหวตมากที่สุด) สำหรับคำถามนี้เป็นอันตรายอย่างยิ่งในทางปฏิบัติ

หากคุณไม่มีตัวเลือกอื่น ๆ ทั้งหมด - คุณไม่สามารถออกแบบรหัสของคุณใหม่คุณจะไม่สามารถปรับโครงสร้างให้เป็นแบบอะซิงก์ได้ - คุณจะถูกบังคับให้ซิงค์รหัสที่ไม่สามารถเปลี่ยนได้เพื่อซิงค์คุณไม่สามารถเปลี่ยนรหัสดาวน์สตรีมให้ซิงค์ได้ - คุณไม่สามารถบล็อกได้ - คุณไม่สามารถเรียกใช้รหัส async บนเธรดแยกกัน - จากนั้นคุณควรพิจารณาใช้การอ้างอิงซ้ำ

หากคุณพบว่าตัวเองอยู่ในมุมนี้ผมจะแนะนำให้ใช้สิ่งที่ต้องการDispatcher.PushFrameสำหรับแอป WPF , บ่วงกับApplication.DoEventsปพลิเคชัน WinForm AsyncContext.Runและสำหรับกรณีทั่วไปของตัวเอง

หากฉันกำลังอ่านคำถามของคุณถูกต้อง - รหัสที่ต้องการให้การเรียกแบบซิงโครนัสไปยังวิธีการแบบอะซิงโครนัสกำลังทำงานบนเธรดโปรแกรมเลือกจ่ายงานที่ถูกระงับ และคุณต้องการบล็อกเธรดนั้นพร้อมกันจนกว่าวิธีการ async จะเสร็จสมบูรณ์

วิธีการแบบอะซิงก์ใน C # 5 นั้นขับเคลื่อนโดยการสับอย่างมีประสิทธิภาพเป็นชิ้น ๆ ภายใต้ประทุนและการส่งกลับTaskที่สามารถติดตามความสำเร็จโดยรวมของ shabang ทั้งหมด อย่างไรก็ตามวิธีการที่สับดำเนินการสามารถขึ้นอยู่กับชนิดของนิพจน์ที่ส่งผ่านไปยังawaitผู้ประกอบการ

ส่วนใหญ่เวลาที่คุณจะใช้ในการแสดงออกของพิมพ์await Taskการใช้งานของawaitรูปแบบคือ "สมาร์ท" ในการที่จะเลื่อนไปที่SynchronizationContextซึ่งทำให้เกิดความซึ่งโดยทั่วไปจะทำให้เกิดสิ่งต่อไปนี้:

1. หากด้ายเข้ามา awaitอยู่ใน Dispatcher หรือ WinForms เธรดจะตรวจสอบให้แน่ใจว่า chunks ของเมธอด async เกิดขึ้นเนื่องจากเป็นส่วนหนึ่งของการประมวลผลของคิวข้อความ
2. หากด้ายเข้ามา awaitอยู่บนเธรดพูลเธรดดังนั้นชิ้นส่วนที่เหลือของเมธอด async จะเกิดขึ้นที่ใดก็ได้บนเธรดพูล

นั่นเป็นสาเหตุที่คุณอาจพบปัญหา - การใช้วิธี async พยายามเรียกใช้ส่วนที่เหลือใน Dispatcher - แม้ว่าจะถูกระงับ

.... สำรอง! ....

ฉันต้องถามคำถามทำไมคุณพยายามบล็อกแบบซิงโครนัสด้วยวิธีการแบบซิงโครนัส? การทำเช่นนั้นจะเอาชนะวัตถุประสงค์ที่ว่าทำไมวิธีที่ต้องการให้เรียกแบบอะซิงโครนัส โดยทั่วไปเมื่อคุณเริ่มใช้งานawaitในวิธีเลือกจ่ายงานหรือ UI คุณจะต้องเปลี่ยน async โฟลว์ UI ทั้งหมดของคุณ ตัวอย่างเช่นหาก callstack ของคุณเป็นดังนี้:

1. [Top] WebRequest.GetResponse()
2. YourCode.HelperMethod()
3. YourCode.AnotherMethod()
4. YourCode.EventHandlerMethod()
5. [UI Code].Plumbing()- WPFหรือWinFormsรหัส
6. [วงวนข้อความ] - WPFหรือWinFormsวงวนข้อความ

จากนั้นเมื่อมีการแปลงรหัสให้ใช้ async โดยทั่วไปคุณจะต้องจบด้วย

1. [Top] WebRequest.GetResponseAsync()
2. YourCode.HelperMethodAsync()
3. YourCode.AnotherMethodAsync()
4. YourCode.EventHandlerMethodAsync()
5. [UI Code].Plumbing()- WPFหรือWinFormsรหัส
6. [วงวนข้อความ] - WPFหรือWinFormsวงวนข้อความ

ตอบรับจริง

คลาส AsyncHelpers ด้านบนใช้งานได้จริงเพราะมันทำงานเหมือนวนข้อความที่ซ้อนกัน แต่มันจะติดตั้งกลไกแบบขนานของตัวเองไปยัง Dispatcher แทนที่จะพยายามดำเนินการบน Dispatcher เอง นั่นเป็นวิธีแก้ปัญหาหนึ่งสำหรับปัญหาของคุณ

วิธีแก้ปัญหาอื่นคือการเรียกใช้เมธอด async ของคุณบนเธรดพูลเธรดแล้วรอจนเสร็จสมบูรณ์ การทำเช่นนี้เป็นเรื่องง่าย - คุณสามารถทำได้ด้วยตัวอย่างต่อไปนี้:

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

API ขั้นสุดท้ายจะเป็น Task.Run (... ) แต่ด้วย CTP คุณจะต้องใช้คำต่อท้าย Ex ( คำอธิบายที่นี่ )

มันทำงานได้ดีสำหรับฉัน

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

วิธีที่ง่ายที่สุดที่ฉันพบว่ารันภารกิจแบบซิงโครนัสและไม่มีการบล็อกเธรด UI คือการใช้ RunSynchronously () เช่น:

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

ในกรณีของฉันฉันมีเหตุการณ์ที่เกิดขึ้นเมื่อมีบางอย่างเกิดขึ้น ฉันไม่รู้ว่ามันจะเกิดขึ้นกี่ครั้ง ดังนั้นฉันใช้รหัสข้างต้นในเหตุการณ์ของฉันดังนั้นเมื่อใดก็ตามที่มันเกิดเพลิงไหม้มันจะสร้างงานขึ้นมา มีการเรียกใช้งานพร้อมกันและใช้งานได้ดีสำหรับฉัน ฉันรู้สึกประหลาดใจมากที่ต้องใช้เวลานานกว่าจะค้นพบสิ่งนี้โดยพิจารณาว่ามันเรียบง่ายเพียงใด โดยปกติคำแนะนำนั้นซับซ้อนและมีข้อผิดพลาดมากกว่า นี่มันเรียบง่ายและสะอาด

ฉันต้องเผชิญกับมันสองสามครั้งส่วนใหญ่ในการทดสอบหน่วยหรือในการพัฒนาบริการ windows ปัจจุบันฉันใช้คุณสมบัตินี้อยู่เสมอ:

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

มันง่ายง่ายและฉันก็ไม่มีปัญหา

ฉันพบรหัสนี้ที่ส่วนประกอบ Microsoft.AspNet.Identity.Core และใช้งานได้

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

ทราบเพียงเล็กน้อย - วิธีการนี้:

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

ทำงานให้กับ WinRT

ให้ฉันอธิบาย:

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

นอกจากนี้วิธีการนี้ใช้ได้กับโซลูชัน Windows Store เท่านั้น!

หมายเหตุ:วิธีนี้จะไม่ปลอดภัยสำหรับเธรดถ้าคุณเรียกวิธีการของคุณภายในวิธีการ async อื่น ๆ (ตามความคิดเห็นของ @Servy)

ในรหัสของคุณรองานแรกที่จะดำเนินการ แต่คุณยังไม่ได้เริ่มมันจึงรออย่างไม่มีกำหนด ลองสิ่งนี้:

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

แก้ไข:

คุณบอกว่าคุณได้รับการยกเว้น โปรดโพสต์รายละเอียดเพิ่มเติมรวมถึงการติดตามสแต็ก
Mono มีกรณีทดสอบดังต่อไปนี้:

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

        Assert.AreEqual (1, val);
}

ตรวจสอบว่ามันเหมาะกับคุณหรือไม่ หากไม่เป็นเช่นนั้นไม่น่าเป็นไปได้มากที่คุณอาจมีโครงสร้างแปลก ๆ ของ Async CTP หากใช้งานได้คุณอาจต้องการตรวจสอบสิ่งที่คอมไพเลอร์สร้างขึ้นและการTaskสร้างอินสแตนซ์แตกต่างจากตัวอย่างนี้อย่างไร

แก้ไข # 2:

ฉันจะตรวจสอบกับสะท้อนว่าข้อยกเว้นที่คุณอธิบายเกิดขึ้นเมื่อเป็นm_action nullนี่เป็นเรื่องแปลก แต่ฉันไม่เชี่ยวชาญใน Async CTP ที่ผมกล่าวว่าคุณควรแยกรหัสของคุณและดูวิธีการว่าTaskจะถูก instantiated ใดวิธีมาของมันคือm_actionnull

PS การจัดการกับ downvotes เป็นครั้งคราวคืออะไร? สนใจที่จะทำอย่างละเอียด?

ทดสอบใน. Net 4.6 นอกจากนี้ยังสามารถหลีกเลี่ยงการหยุดชะงัก

สำหรับวิธีการ async Taskกลับ

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

สำหรับวิธีการส่งกลับ async Task<T>

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

แก้ไข :

หากผู้เรียกใช้ในเธรดพูลเธรด (หรือผู้เรียกยังอยู่ในภารกิจด้วย) ผู้เรียกนั้นยังอาจทำให้เกิดการหยุดชะงักในบางสถานการณ์

ใช้ snip โค้ดด้านล่าง

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

ทำไมไม่สร้างการโทรเช่น:

Service.GetCustomers();

นั่นไม่ใช่ async

คำตอบนี้ถูกออกแบบมาสำหรับทุกคนที่ใช้ WPF สำหรับ. NET 4.5

หากคุณพยายามเรียกใช้งานTask.Run()บนเธรด GUI ดังนั้นtask.Wait()จะไม่มีการหยุดทำงานหากคุณไม่มีasyncคำหลักในนิยามฟังก์ชันของคุณ

วิธีการขยายนี้แก้ไขปัญหาโดยการตรวจสอบเพื่อดูว่าเราอยู่ในเธรด GUI และถ้าใช่ให้เรียกใช้งานบนเธรด WPF โปรแกรมเลือกจ่ายงาน

คลาสนี้สามารถทำหน้าที่เป็นตัวเชื่อมระหว่างโลกของ async / await และโลกที่ไม่ใช่ async / await ในสถานการณ์ที่ไม่สามารถหลีกเลี่ยงได้เช่นคุณสมบัติ MVVM หรือการพึ่งพา API อื่น ๆ ที่ไม่ได้ใช้ async / await

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

เพียงแค่เรียก.Result;หรือ.Wait()มีความเสี่ยงสำหรับการหยุดชะงักตามที่หลายคนได้กล่าวไว้ในความคิดเห็น เนื่องจากพวกเราส่วนใหญ่ชอบ oneliners คุณสามารถใช้สิ่งเหล่านี้เพื่อ.Net 4.5<

การรับค่าผ่านเมธอด async:

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

เรียกวิธี async แบบซิงโครนัส

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

Task.Runไม่มีปัญหาการหยุดชะงักจะเกิดขึ้นเนื่องจากการใช้งานของ

ที่มา:

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

ฉันคิดว่าวิธีการช่วยเหลือต่อไปนี้สามารถแก้ไขปัญหาได้เช่นกัน

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

สามารถใช้วิธีต่อไปนี้:

InvokeAsyncFuncSynchronously(Service.GetCustomersAsync);

มันใช้งานได้สำหรับฉัน

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

ฉันได้พบว่า SpinWait ใช้งานได้ดีสำหรับเรื่องนี้

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;

วิธีการข้างต้นไม่จำเป็นต้องใช้. Result หรือ. Wait () นอกจากนี้ยังช่วยให้คุณระบุการหมดเวลาเพื่อที่คุณจะได้ไม่ติดขัดตลอดไปในกรณีที่งานไม่เสร็จสมบูรณ์

ใน wp8:

ห่อมัน:

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

เรียกมันว่า:

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

หรือคุณสามารถไปกับ:

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

สำหรับการคอมไพล์ให้แน่ใจว่าคุณอ้างอิงชุดประกอบส่วนขยาย:

System.Net.Http.Formatting

ลองรหัสต่อไปนี้ใช้งานได้สำหรับฉัน:

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