线程切换

Question

如何在调用异步函数的同一线程中执行回调方法。 调用者线程可能不是 UI 线程...但 UI 不应该挂起..

感谢和问候， 饭菜

Answer 1

没有什么灵丹妙药可以让一个线程在另一个线程上启动委托的执行。目标线程必须专门构造以允许这样做。在 UI 线程的情况下，有一个消息泵来分派和处理消息。此消息泵可用于通过ISynchronizeInvoke 接口执行封送操作。

ISynchronizeInvoke target = someForm; // where someForm is a Form or Control
target.Invoke(
  (Action)(() =>
  {
    MessageBox.Show("I am on the target thread");
  }), null);

在您的情况下，调用异步函数的线程必须具有某种内置的生产者-消费者机制，以便在工作线程指示它执行此操作后，在该线程上异步执行回调。不幸的是，这不是一个容易解决的问题。

这是创建一个可以接受要执行的委托的线程的一种方法。

public class SynchronizeInvokeThread : ISynchronizeInvoke
{
    private Thread m_Thread;
    private BlockingCollection<WorkItem> m_Collection = new BlockingCollection<WorkItem>();

    public SynchronizeInvokeThread()
    {
        m_Thread = new Thread(
            () =>
            {
                SynchronizationContext.SetSynchronizationContext(new MySynchronizationContext(this));
                while (true)
                {
                    WorkItem wi = m_Collection.Take();
                    wi.Complete(wi.Method.DynamicInvoke(wi.Args));
                }
            });
        m_Thread.Start();
    }

    public IAsyncResult BeginInvoke(Delegate method, object[] args)
    {
        var wi = new WorkItem(method, args);
        m_Collection.Add(wi);
        return wi;
    }

    public object EndInvoke(IAsyncResult result)
    {
        var wi = (WorkItem)result;
        wi.AsyncWaitHandle.WaitOne();
        return wi.Result;
    }

    public object Invoke(Delegate method, object[] args)
    {
        var wi = new WorkItem(method, args);
        m_Collection.Add(wi);
        wi.AsyncWaitHandle.WaitOne();
        return wi.Result;
    }

    public bool InvokeRequired
    {
        get { return Thread.CurrentThread != m_Thread; }
    }

    private class MySynchronizationContext : SynchronizationContext
    {
        private ISynchronizeInvoke m_SynchronizingObject;

        public MySynchronizationContext(ISynchronizeInvoke synchronizingObject)
        {
            m_SynchronizingObject = synchronizingObject;
        }

        public override void Post(SendOrPostCallback d, object state)
        {
            m_SynchronizingObject.BeginInvoke(d, new object[] { state });
        }

        public override void Send(SendOrPostCallback d, object state)
        {
            m_SynchronizingObject.Invoke(d, new object[] { state });
        }
    }

    private class WorkItem : IAsyncResult
    {
        private Delegate m_Method;
        private object[] m_Args;
        private object m_Result = null;
        private ManualResetEvent m_Signal = new ManualResetEvent(false);

        public WorkItem(Delegate method, object[] args)
        {
            m_Method = method;
            m_Args = args;
        }

        public void Complete(object result)
        {
            m_Result = result;
            m_Signal.Set();
        }

        public object Result
        {
            get { return m_Result; }
        }

        public Delegate Method
        {
            get { return m_Method; }
        }

        public object[] Args
        {
            get { return m_Args; }
        }

        public object AsyncState
        {
            get { return null; }
        }

        public WaitHandle AsyncWaitHandle
        {
            get { return m_Signal; }
        }

        public bool CompletedSynchronously
        {
            get { return false; }
        }

        public bool IsCompleted
        {
            get { return m_Signal.WaitOne(0); }
        }
    }
}

可以这样使用。

ISynchronizeInvoke target = new SynchronizeInvokeThread(); 
target.Invoke(
  (Action)(() =>
  {
    Console.WriteLine("I am on the target thread");
    SynchronizationContext.Current.Post(
      (state) =>
      {
        Console.WriteLine("I even have a synchronization context!");
      }, null);
  }), null);

更新：

根据下面的评论 BlockingCollection 仅在 .NET 4.0 中可用或作为 Reactive Extensions 下载的一部分。如果这个数据结构对你不可用，那么这个已经很困难的代码就变得更加困难了。

Answer 2

使用 BackgroundWorker。回调将在所属线程上。

如果异步操作需要在回调之后继续运行，您可以使用 WPF System.Windows.Application.Current.Dispatcher.Invoke/BeginInvoke 进行多个回调...或者如果是 WinForms，您可以使用窗体或控件实例本身并调用 Invoke/BeginInvoke。

Answer 3

就像提到的Brian Gideon 一样，您应该使用ISynchronizeInvoke“System.ComponentModel.ISynchronizeInvoke”。在要在另一个线程上编组其线程执行的类上实现它。这里的例子Mediaclass“我实现的一些类正在与Com对象交互，所以它应该在主线程中执行它的方法”；由于它使用System.Threading.SynchronizationContext.Current 的类实现，因此您可以在 WindowsForms 中使用它，但不能在控制台应用程序中使用它，因为 System.Threading.SynchronizationContext.Current 为空。

当您想将此类的执行编组到创建它的线程中时，只需调用其Invoke 方法即可。

public abstract class Media : ISynchronizeInvoke
{
        //....

        private readonly System.Threading.SynchronizationContext _currentContext = System.Threading.SynchronizationContext.Current;

        private readonly System.Threading.Thread _mainThread = System.Threading.Thread.CurrentThread;

        private readonly object _invokeLocker = new object();
        //....


        #region ISynchronizeInvoke Members

        public bool InvokeRequired
        {
            get
            {
                return System.Threading.Thread.CurrentThread.ManagedThreadId != this._mainThread.ManagedThreadId;
            }
        }

        /// <summary>
        /// This method is not supported!
        /// </summary>
        /// <param name="method"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        [Obsolete("This method is not supported!", true)]
        public IAsyncResult BeginInvoke(Delegate method, object[] args)
        {
            throw new NotSupportedException("The method or operation is not implemented.");
        }

        /// <summary>
        /// This method is not supported!
        /// </summary>
        /// <param name="method"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        [Obsolete("This method is not supported!", true)]
        public object EndInvoke(IAsyncResult result)
        {
            throw new NotSupportedException("The method or operation is not implemented.");
        }

        public object Invoke(Delegate method, object[] args)
        {
            if (method == null)
            {
                throw new ArgumentNullException("method");
            }

            lock (_invokeLocker)
            {
                object objectToGet = null;

                SendOrPostCallback invoker = new SendOrPostCallback(
                delegate(object data)
                {
                    objectToGet = method.DynamicInvoke(args);
                });

                _currentContext.Send(new SendOrPostCallback(invoker), method.Target);

                return objectToGet;
            }
        }

        public object Invoke(Delegate method)
        {
            return Invoke(method, null);
        }

        #endregion//ISynchronizeInvoke Members

}