Dispatcher中Invoke与BeginInvoke

[同步]Invoke

Application.Current.Dispatcher.Invoke(AutoIncreaseNumber);

[异步]BeginInvoke

Application.Current.Dispatcher.BeginInvoke((Action)AutoIncreaseNumber);

两者都会阻塞UI线程

基于WPF4.5.1示例

Invoke 按钮对应的是InvokeCommand

BeginInvoke按钮对应的是BeginInvokeCommand

可以发现，在执行按钮的命令时，UI线程是会阻塞，计时器并不会走动

public class MainViewModel : ViewModelBase
    {
        public MainViewModel()
        {
            DispatcherTimer timer = new DispatcherTimer();
            timer.Interval = TimeSpan.FromSeconds(1);
            timer.Tick += timer_Tick;
            timer.Start();
        }

        void timer_Tick(object sender, EventArgs e)
        {
            Now = DateTime.Now;
        }

        private DateTime now = DateTime.Now;

        public DateTime Now
        {
            get { return now; }
            set
            {
                now = value;
                RaisePropertyChanged("Now");
            }
        }



        private int number;
        /// <summary>
        /// 数值用于显示
        /// </summary>
        public int Number
        {
            get { return number; }
            set
            {
                number = value;
                RaisePropertyChanged("Number");
            }
        }

        private bool isIncrease;
        /// <summary>
        /// 是否可以自增长
        /// </summary>
        public bool IsIncrease
        {
            get { return isIncrease; }
            set
            {
                isIncrease = value;
                RaisePropertyChanged("IsIncrease");
            }
        }

        /// <summary>
        /// 自动增长
        /// </summary>
        private void AutoIncreaseNumber()
        {
            IsIncrease = !isIncrease;
            while (IsIncrease && Number < 500000)
            {
                Number++;
            }
        }

        #region RelayCommands
        /// <summary>
        /// Invoke命令 
        /// </summary>
        public RelayCommand InvokeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    Application.Current.Dispatcher.Invoke(AutoIncreaseNumber);
                });
            }
        }
        /// <summary>
        /// BeginInvoke命令
        /// </summary>
        public RelayCommand BeginInvokeCommand
        {
            get
            {
                return new RelayCommand(() =>
                {
                    //这里直接使用匿名方法会报错
                    //'Cannot convert lambda expression to type 'System.Delegate' because it is not a delegate type'
                    //使用强制转换的方式
                    Application.Current.Dispatcher.BeginInvoke((Action)AutoIncreaseNumber);
                });
            }
        }
        /// <summary>
        /// 清理数字命令
        /// </summary>
        public RelayCommand ClearCommand
        {
            get
            {
                return new RelayCommand(() =>
                    {
                        Number = 0;
                        IsIncrease = false;
                    });
            }
        }
        #endregion
    }

注：其中阻塞UI线程的原因是把Number的递增放到了Dispather中去执行，如果想要不阻塞，那么需要有一个新的DispatcherTimer的对象去执行这个递增的逻辑，那么就不会阻塞UI线程了。

所以说这里所说的异步并不是相对于UI线程的异步，那么究竟是什么？

Invoke 是同步操作；因此，直到回调返回之后才会将控制权返回给调用对象。

BeginInvoke 是异步操作；因此，调用之后控制权会立即返回给调用对象。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 --- msdn

做一个测试

/// <summary>
    /// DiffInInvokeAndBeginInvoke.xaml 的交互逻辑
    /// </summary>
    public partial class DiffInInvokeAndBeginInvoke : Window
    {
        public DiffInInvokeAndBeginInvoke()
        {
            InitializeComponent();
            this.ltb.ItemsSource = _infos;
            this.Loaded += DiffInInvokeAndBeginInvoke_Loaded;
        }

        private ObservableCollection<string> _infos = new ObservableCollection<string>();

        private void DiffInInvokeAndBeginInvoke_Loaded(object sender, RoutedEventArgs e)
        {
            ExcuteMethod();
            ExcuteMethod_2();
            ExcuteMethod_3();
        }

        private void ExcuteMethod()
        {
            Dispatcher.Invoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.SystemIdle, "1-1: SystemIdle Invoke");
            Dispatcher.Invoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.Send, "1-2: Send Invoke ");
            Dispatcher.BeginInvoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.Normal, "1-3: Normal BeginInvoke");
            Dispatcher.BeginInvoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.Send, "1-4: Send BeginInvoke");
            DispatcherOperation dop = Dispatcher.BeginInvoke(new Action<string>(PrintInformation), "1-5: Defaut BeginInvoke");
        }

        private void ExcuteMethod_2()
        {

            Dispatcher.BeginInvoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.Normal, "2-1: Normal BeginInvoke");
            Dispatcher.Invoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.Send, "2-2: Send Invoke ");
            Dispatcher.BeginInvoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.Send, "2-3: Send BeginInvoke");
        }

        private void ExcuteMethod_3()
        {
            Dispatcher.Invoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.Send, "3-1: Send Invoke ");
            Dispatcher.BeginInvoke(new Action<string>(PrintInformation), System.Windows.Threading.DispatcherPriority.Send, "2-2: Send BeginInvoke");
        }

        private void PrintInformation(string info)
        {
            _infos.Add(info);
        }
    }

结果如下：

从结果及MSDN对于Invoke及BeginInvoke的解释，很容易就理解了。

Invoke一定要执行完了才会执行下去，而BeginInvoke是没有等待执行完就接着往下走了，然后会根据线程的调用优先级开始执行。

代码