C# Dispatcher.BeginInvoke方法代码示例

        public static bool Verify(Dispatcher dispatcher, Stream file)
        {
            if (file.Length == 0)
            {
                dispatcher.BeginInvoke(() =>
                    MessageBox.Show(Resources.EmptyFile,
                        Properties.Resources.DownloadTitle,
                        MessageBoxButton.OK));

                return false;
            }

            if (!DatabaseReader.CheckSignature(file))
            {
                dispatcher.BeginInvoke(() =>
                    MessageBox.Show(Resources.NotKdbx,
                        Properties.Resources.DownloadTitle,
                        MessageBoxButton.OK));

                return false;
            }

            file.Position = 0;
            return true;
        }

        internal void Refresh(Dispatcher dispatcher)
        {
            dispatcher.BeginInvoke((Action)delegate
            {
                //RGB
                unsafe
                {
                    if (rgbSource != null)
                    {
                        ReadLockedWrapperPtr ptr = ResultsDllWrapper.lockFactoryImage(ImageProductType.RGBSourceProduct);
                        rgbSource.Lock();
                        rgbSource.WritePixels(new Int32Rect(0, 0, rgbWidth, rgbHeight), ptr.IntPtr, rgbWidth * rgbHeight * 3, rgbWidth * 3);
                        rgbSource.Unlock();
                        ResultsDllWrapper.releaseReadLockedWrapperPtr(ptr);
                    }
                }

                //Depth
                unsafe
                {
                    if (depthSource != null)
                    {
                        ReadLockedWrapperPtr ptr = ResultsDllWrapper.lockFactoryImage(ImageProductType.DepthSynchronizedProduct);
                        depthSource.Lock();
                        depthSource.WritePixels(new Int32Rect(0, 0, depthWidth, depthHeight), ptr.IntPtr, depthWidth * depthHeight * 2, depthWidth * 2);
                        depthSource.Unlock();
                        ResultsDllWrapper.releaseReadLockedWrapperPtr(ptr);
                    }
                }
            }, null);
        }

 public static void BeginInvoke(Dispatcher dispatcher, Action action)
 {
     if (IsSynchronous)
         action();
     else
         dispatcher.BeginInvoke(action);
 }

 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="url">The url to navigate to when loaded.</param>
 public FacebookWPFBrowser(string url)
 {
     dispatcher = Dispatcher.CurrentDispatcher;
     InitializeComponent();
     _url = url;
     dispatcher.BeginInvoke(new Action(() => this.webBrowser.Navigate(new Uri(_url))));
 }

        public VisualCommentsHelper(Dispatcher disp, ItemContainerGenerator gen, Comment placeholder)
        {
            _gen = gen;
            _placeholder = placeholder;

            disp.BeginInvoke(new Action(DeferredFocusSet),
                             System.Windows.Threading.DispatcherPriority.Background, null);
        }

 public static void ExecuteAsyncUI(Dispatcher dispatcher, Action action, Action callback)
 {
     DispatcherOperation dispatcherOp = dispatcher.BeginInvoke(action, DispatcherPriority.Normal);
     if (null != callback)
     {
         dispatcherOp.Completed += (s, e) => { callback(); };
     }
 }

        public static void DoEvents(Dispatcher disp = null) {
            DispatcherFrame frame = new DispatcherFrame();
            if(disp == null) {
                disp = Dispatcher.CurrentDispatcher;
            }

            disp.BeginInvoke(DispatcherPriority.Background, new DispatcherOperationCallback(ExitFrame), frame);
            Dispatcher.PushFrame(frame);
        }

        public CommentNotificationDeferral(Dispatcher disp, DiscCtx ctx, ItemsControl commentItems)
        {
            _disp = disp;
            _ctx = ctx;
            _commentItems = commentItems;

            _disp.BeginInvoke(new Action(InjectCommentNotifications),
                              System.Windows.Threading.DispatcherPriority.Background);
        }     

 /// <summary>
 /// Rethrows exceptions thrown during task execution in thespecified dispatcher thread.
 /// </summary>
 /// <param name="task">The task.</param>
 /// <param name="dispatcher">The dispatcher.</param>
 /// <returns></returns>
 public static Task WithExceptionThrowingInDispatcher(this Task task, Dispatcher dispatcher)
 {
     return task.ContinueWith(t =>
     {
         dispatcher.BeginInvoke(() =>
         {
             throw t.Exception;
         }, DispatcherPriority.Send);
     }, TaskContinuationOptions.OnlyOnFaulted);
 }

        public CreateTournamentViewModel(Dispatcher dispatcher)
        {
            _dispatcher = dispatcher;
            _xmppHost = ((App)App.Current).XmppHost;
            _gameController = ServiceLocator.Current.GetInstance<GameController>();

            StartTournamentCommand = new RelayCommand(StartTournament);

            TournamentTypeListInternal.Add(new Option<string>("Round Robin", "RoundRobin"));
            _xmppHost.PlayerRegistered += (sender, e) => { _dispatcher.BeginInvoke(() => { RegisteredPlayerListInternal.Add(new Option<Jid>(e.User.Bare, e.User)); UpdateCanStartTournament(); }); };
        }

        public GitHubModel(Dispatcher dispatcher)
        {
            Dispatcher = dispatcher;
            _exceptionAction = ex => Dispatcher.BeginInvoke(() =>
                    MessageBox.Show("Error: " + Enum.GetName(typeof(ErrorType), ex.ErrorType), "", MessageBoxButton.OK)
                );

            _client = new GitHubClient();

            Contexts = new ObservableCollection<Context>();
        }

        public static void OnUiThread(Action action, Dispatcher disp = null,
			DispatcherPriority prio = DispatcherPriority.Background)
        {
            if (disp == null)
            {
                if (Application.Current != null)
                    disp = Application.Current.Dispatcher;
            }

            if (disp != null)
                disp.BeginInvoke(action, prio);
        }

 public BuildItemViewModel(BuildItem item, Dispatcher dispatcher)
 {
     Item = item;
     Item.StatusChanged += (sender, args) => dispatcher.BeginInvoke((Action)(() =>
     {
         NotifyPropertyChanged("Status");
         NotifyPropertyChanged("Error");
         NotifyPropertyChanged("ErrorTitle");
         NotifyPropertyChanged("ErrorMessage");
         NotifyPropertyChanged("ShowError");
     }));
 }

 private void UpdateStats(RoutedEventArgs e)
 {
     var button = e.Source as Button;
     if (button != null)
     {
         _dispatcher = button.Dispatcher;
         var client = BrightstarService.GetClient(Store.Source.ConnectionString);
         _statsUpdateJob = client.UpdateStatistics(Store.Location);
         _dispatcher.BeginInvoke(DispatcherPriority.SystemIdle,
                                 new TransactionViewModel.JobMonitorDelegate(CheckJobStatus));
     }
 }

        public void Download(string file, string saveWhere, Dispatcher dispatch, Action done)
        {
            var shareResp = _client.GetMedia(file);

            using (WebClient webclient = new WebClient())
            {
                webclient.DownloadFileCompleted +=
                    (object sender, AsyncCompletedEventArgs e) =>
                        { dispatch.BeginInvoke(new Action(() => { done(); })); };
                webclient.DownloadFileAsync(new Uri(shareResp.Url), saveWhere);
            }
        }