public TaskContext Execute(ITask task, object associatedData = null) { var context = new TaskContext(task, associatedData); _dispatcher.BeginInvoke(() => { _all.Add(task); _contexts.Add(context); UpdateBusy(); }); task.Execute(context).ContinueWith((p, d) => { _dispatcher.BeginInvoke(() => { _all.Remove(task); _contexts.Remove(context); UpdateBusy(); }); }).Failed((p, d) => { }); return(context); }
private void OnFrameCompleted() { #if TIMING GameBoy._swBeginInvoke.Start(); _dispatcher.BeginInvoke(new Action(UpdateFromGameboy), null); GameBoy._swBeginInvoke.Stop(); #else _dispatcher.BeginInvoke(new Action(UpdateFromGameboy), null); #endif }
/// <summary> /// Called when [track progress]. /// </summary> /// <param name="trackProgressEvent">The track progress event.</param> private void OnTrackProgress(TrackProgressEvent trackProgressEvent) { dispatcher.BeginInvoke(new Action <TrackProgressEvent>(a => { var pos = TimeSpan.FromMilliseconds(a.Position); CurrentPositionString = GetTimeString(pos); if (hasSought) { return; } currentPosition = a.Position; // Don't set CurrentPosition directly as it will seek as well RaisePropertyChanged(() => CurrentPosition); }), trackProgressEvent); }
private void Run() { try { Thread.Sleep(_delay); if (Application.Current == null) { return; } lock (_dispatcherOperationLock) _dispatcherOperation = _dispatcher.BeginInvoke(_action); } catch (ThreadAbortException ex) { Exception = ex; } catch (ThreadInterruptedException ex) { Exception = ex; } catch (Exception ex) { Exception = ex; } finally { lock (this) { IsCompleted = true; if (_asyncWaitHandle != null) { ((ManualResetEvent)_asyncWaitHandle).Set(); } } } }
private void SafeNotify(Action method, bool post) { try { // Fire the event on the UI thread if (post) { if (Dispatcher.CheckAccess()) { method(); } else { Dispatcher.BeginInvoke(method); } } // Fire event on a ThreadPool thread else { ThreadPool.QueueUserWorkItem(o => method(), null); } } catch (Exception ex) { // If there's an exception write it to the Output window Debug.WriteLine(ex.ToString()); } }
private void UpdatePlugins() { try { _updatePluginsCommand.CanBeExecuted = false; var repositories = _applicationSettings.AutoUpdate.PluginRepositories; var numUpdatedPlugins = _pluginUpdater.UpdatePluginsAsync(repositories); numUpdatedPlugins.ContinueWith(task => _dispatcher.BeginInvoke(() => OnPluginsUpdated(task))); } catch (Exception) { _updatePluginsCommand.CanBeExecuted = true; throw; } }
protected void RaiseCollectionReset() { var copy = CollectionChanged; if (copy != null) { if (!dispatcher.IsUIThread) { dispatcher.BeginInvoke(RaiseCollectionReset); } else { copy(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset)); } } }
private void ScanSnapshotsFolder() { var searchPattern = string.Format("*.{0}", Constants.SnapshotExtension); try { // Blocking the timer task is on purpose so we don't perform more scans than we actually can var files = _analysisStorage.EnumerateSnapshots().AwaitResult().ToList(); _dispatcher.BeginInvoke(() => Synchronise(files)); } catch (IOException e) { if (!_loggedIoException) { Log.WarnFormat("Unable to enumerate snapshots: {0}", e.Message); _loggedIoException = true; } else { Log.DebugFormat("Unable to enumerate snapshots: {0}", e.Message); } } catch (Exception e) { Log.ErrorFormat("Caught unexpected exception: {0}", e); } }
private void ProcessMessage(ESP esp, IDispatcher dispatcher) { if (!FoundEsps.Any(e => e.Ip.Equals(esp.Ip))) { dispatcher.BeginInvoke(() => FoundEsps.Add(esp)); } }
public override void OnInvoke(MethodInterceptionArgs args) { IDispatcherObject threadAffined = args.Instance as IDispatcherObject; IDispatcher dispatcher = threadAffined.Dispatcher; if (dispatcher == null) { throw new InvalidOperationException("Cannot dispatch method: synchronization context is null"); } if (this.isAsync) { dispatcher.BeginInvoke(new WorkItem(args, true)); } else if (dispatcher.CheckAccess()) { args.Proceed(); } else { WorkItemWithExceptionInterceptor workItem = new WorkItemWithExceptionInterceptor(args); dispatcher.Invoke(workItem); if (workItem.HasError) { throw new AggregateException("Exception has been thrown by the target of an invocation", workItem.Exception); } } }
private void OnInstallationFinished(Task task) { _dispatcher.BeginInvoke(() => { string result; if (task.IsFaulted) { result = "failed"; HasFailed = true; ErrorMessage = FormatErrorMessage(task.Exception); } else { _success = true; result = "succeeded"; } _installationTask = null; InstallationResult = result; IsInstalling = false; IsPostInstallation = true; _launchCommand.RaiseCanExecuteChanged(); }); }
public void ShowError(Exception exception, IErrorContainer errorContainer) { if (exception == null) { return; } ErrorContainer errorGrid = (ErrorContainer)errorContainer; if (!_dispatcher.CheckAccess()) { _dispatcher.BeginInvoke(() => ShowError(exception, errorGrid)); return; } ErrorNotification errorNotification = new ErrorNotification(); errorGrid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto }); errorNotification.SetValue(Grid.RowProperty, errorGrid.RowDefinitions.Count - 1); errorGrid.Children.Add(errorNotification); errorGrid.UpdateLayout(); // Force OnApplyTemplate for ErrorNotification errorNotification.Show(exception); }
// private NotifyCollectionChangedEventArgs eLast; // this is connected to the DispatherTimer private void TimerCallback(object state) { lock (_lock) { // trottlteNotification = false; // Fire the event on the UI thread if (Dispatcher.CheckAccess()) { #if TEST logger.Debug("direct notification"); #endif base.OnCollectionChanged(new System.Collections.Specialized.NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction.Reset)); } else { #if TEST logger.Debug("dispatcher notification"); #endif // base. Dispatcher.BeginInvoke(() => base.OnCollectionChanged(new System.Collections.Specialized.NotifyCollectionChangedEventArgs(System.Collections.Specialized.NotifyCollectionChangedAction.Reset))); } if (this.onCountChange != null) { this.onCountChange(); } } }
private async void Update() { IsUpdating = true; Percent = 0; if (FileName != null) { var taskServer = httpsServer.Start(FileName, (percent) => dispatcher.BeginInvoke(() => Percent = percent)); if (Rebuild) { System.Diagnostics.ProcessStartInfo info = new System.Diagnostics.ProcessStartInfo() { UseShellExecute = true, WorkingDirectory = Path.GetDirectoryName(FileName)?.Replace("build", "") }; info.FileName = @"C:\Users\BorisMakovecki\.espressif\tools\idf-exe\1.0.1\idf.py.exe"; info.Arguments = "build"; System.Diagnostics.Process p = new System.Diagnostics.Process(); p.StartInfo = info; p.Start(); //p.WaitForExit(); //string output = p.StandardOutput.ReadToEnd(); } messageService.StartOTAUpdate(Path.GetFileName(FileName), httpsServer.Port, esp, $"http://192.168.1.2:{httpsServer.Port}/");//{System.Net.Dns.GetHostName()} await taskServer; Cancel(); } }
private void OnFrameCompleted() { if (Update) { _dispatcher.BeginInvoke(new Action(CopyFromDomain), null); } }
public virtual void Publish <TEvent>(TEvent message, bool asynchronously) where TEvent : Event { var typeOfEvent = typeof(TEvent); Action action = () => { lock (listenerLock) { if (!listeners.ContainsKey(typeOfEvent)) { return; } foreach (var listener in listeners[typeOfEvent]) { var typedReference = (IListenTo <TEvent>)listener; typedReference.Handle(message); } } }; if (asynchronously) { dispatcher.BeginInvoke(action); } else { action(); } }
/// <summary> /// Called when [track changed]. /// </summary> /// <param name="trackChangedEvent">The track changed event.</param> private void OnTrackChanged(TrackChangedEvent trackChangedEvent) { dispatcher.BeginInvoke(new Action(() => { if (null != playingFile) { playingFile.IsPlaying = false; } SelectedFile = Files.Find(x => x.File == trackChangedEvent.File); playingFile = SelectedFile; if (null == playingFile) { return; } playingFile.IsPlaying = true; })); }
private void OnFrameCompleted() { if (Update) { _dispatcher.BeginInvoke(new Action(CopyFromDomain), null); _currentFrame = (_currentFrame + 1) % _numberOfFramesPerImage; } }
protected TimerBase(string name, int timeout, IDispatcher dispatcher) { Dispatcher = dispatcher; Name = name; TimeOut = timeout; timer = new Timer(state => Dispatcher.BeginInvoke(DoTick), this, Timeout.Infinite, Timeout.Infinite); }
protected virtual void OnCurrentProfileChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs) { _dispatcher?.BeginInvoke(() => { CurrentProfileChanged?.Invoke(this, EventArgs.Empty); RaisePropertyChanged(nameof(CurrentProfile)); }); }
private bool ProgressSearchCallback(float progress) { _dispatcher.BeginInvoke(() => { Progress = (int)progress; }); return(false); }
/// <summary>Raises the <see cref="ObservableCollection<FileView>.CollectionChanged"/> event.</summary> /// <param name="e">The <see cref="System.Collections.Specialized.NotifyCollectionChangedEventArgs"/> instance containing the event data.</param> protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) { if (!_dispatcher.CheckAccess()) { _dispatcher.BeginInvoke(() => OnCollectionChanged(e)); return; } base.OnCollectionChanged(e); }
public void RaisePropertyChanged([CallerMemberName] String propertyName = null) { if (Dispatcher == null) { return; } Dispatcher.BeginInvoke(() => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName))); }
/// <summary> /// Execute an action on the UI thread. /// </summary> /// <param name="action"></param> public static void Execute(Action action) { if (_dispatcher.CheckAccess()) { action(); } else { _dispatcher.BeginInvoke(action); } }
/// <summary> /// Called when [shutdown]. /// </summary> /// <param name="shutdownEvent">The shutdown event.</param> private void OnShutdown(ShutdownEvent shutdownEvent) { dispatcher.BeginInvoke(new Action(() => { var wins = windows.Values.ToArray(); foreach (var window in wins) { window.Close(); } })); }
public static void EasyBeginInvoke(this IDispatcher dispatcher, Delegate method, object arg) { if (dispatcher.CheckAccess()) { method.Method.Invoke(method.Target, new [] { arg }); } else { dispatcher.BeginInvoke(method, arg); } }
private void OnSetTopic(HelpTopic helpTopic) { try { _dispatcher.BeginInvoke(() => this.SetValue(HelpProvider.HelpTopicProperty, helpTopic)); } catch (Exception e) { Console.WriteLine(e); throw; } }
private void UpdateJobProfileFromCurrentProperties(object obj) { _dispatcher.BeginInvoke(() => { var settings = _settingsProvider.Settings?.Copy(); Profiles = settings?.ConversionProfiles; if (Profiles != null) { SelectedProfile = Profiles.First(profile => profile.Name == _selectedProfileProvider.SelectedProfile.Name); } }); }
public Task NavigateBack() { if (!viewModels.TryPop(out var oldViewModel)) { throw new Exception(); } if (!viewModels.TryPeek(out var newViewModel)) { throw new Exception(); } var task = NavigateIntenal(newViewModel); return(task.ContinueWith(t => { if (oldViewModel is IDisposable disposable) { dispatcher.BeginInvoke(() => disposable.Dispose()); } })); }
public static void BeginInvokeOrDo(this IDispatcher dispatcher, Action action) { Contract.Requires(action != null, "action"); if (dispatcher != null && dispatcher.InvokeRequired) { dispatcher.BeginInvoke(action); } else { action(); } }
public IEnumerable <AccountOverview> GetAccountsOverview() { var accounts = new ObservableCollection <AccountOverview>(); _proxy.Invoke <IEnumerable <AccountOverview> >("GetAccountsOverview").ContinueWith(t => { foreach (var accountOverview in t.Result) { _dispatcher.BeginInvoke(() => accounts.Add(accountOverview)); } }); return(accounts); }
public AccountsOverview(IDispatcher dispatcher) { _dispatcher = dispatcher; _accountBalanceChangedCallbacks = new List<AccountBalanceChanged>(); var hubConnection = new HubConnection("http://localhost:9044/"); hubConnection.TraceLevel = TraceLevels.All; hubConnection.TraceWriter = new DebugTextWriter(); _proxy = hubConnection.CreateHubProxy("OverviewHub"); _proxy.On("accountBalanceChanged", (string accountNumber, decimal amount) => { _dispatcher.BeginInvoke(() => { foreach (var callback in _accountBalanceChangedCallbacks) { callback(accountNumber, amount); } }); }); hubConnection.Start(new LongPollingTransport()).Wait(); }