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();
             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 < )
             {
                 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 = ;
                         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是没有等待执行完就接着往下走了，然后会根据线程的调用优先级开始执行。

代码