/// <summary> /// Checks whether the current thread is the thread that the dispatcher is associated with. /// </summary> /// <returns>True if it is on the thread that the Dispatcher is associated with; otherwise false.</returns> private bool IsInDispatcherThread() { #if NICENIS_UWP return(TheWindow.Current.Dispatcher.HasThreadAccess); #else return(_dispatcher.CheckAccess()); #endif }
/// <summary> /// Raises the <see cref="TaskComplete"/> event.</summary> /// <param name="sender"> /// The <see cref="Object"/> sending the event.</param> /// <remarks><para> /// <b>OnTaskComplete</b> raises the <see cref="TaskComplete"/> event. Use this method to /// notify any listeners that work on the current task is complete. /// </para><para> /// If <see cref="Dispatcher"/> is valid and <see cref="SysDispatcher.CheckAccess"/> fails, /// <b>OnTaskComplete</b> performs an asynchronous delegate invocation via <see /// cref="SysDispatcher.BeginInvoke"/> and with the current <see cref="Priority"/>. /// </para></remarks> public void OnTaskComplete(object sender) { var handler = TaskComplete; if (handler != null) { if (Dispatcher != null && !Dispatcher.CheckAccess()) { foreach (EventHandler eh in handler.GetInvocationList()) { Dispatcher.BeginInvoke(Priority, eh, sender, EventArgs.Empty); } } else { handler(sender, EventArgs.Empty); } } }
/// <summary> /// Invoke the provided delegate on the underlying actor and wait for completion. /// </summary> /// <param name="action">The action to invoke</param> public static void Invoke(Action action) { if (s_mainThreadDispather == null || s_mainThreadDispather.CheckAccess()) { action.Invoke(); } else { s_mainThreadDispather.Invoke(action); } }
/// <summary> /// Invoke or execute /// </summary> /// <param name="dispatcher">The dispatcher</param> /// <param name="action">Action object</param> public static void InvokeOrExecute(this System.Windows.Threading.Dispatcher dispatcher, Action action) { if (dispatcher.CheckAccess()) { action(); } else { dispatcher.BeginInvoke(DispatcherPriority.Normal, action); } }
public static void AppShutdownDispatcher(Dispatcher theMainDispatcher) { if (theMainDispatcher.CheckAccess()) { theMainDispatcher.InvokeShutdown(); } else { Dispatcher.CurrentDispatcher.Invoke(DispatcherPriority.Send, (Action)(() => { theMainDispatcher.InvokeShutdown(); })); } }
public static void ScrollToEnd(Dispatcher dispatcher, ListBox listBox) { if (dispatcher.CheckAccess()) { SelectLastEntry(listBox); } else { dispatcher.BeginInvoke( DispatcherPriority.Send, new VoidFunctionHandler(SelectLastEntry), listBox); } }
public DispatcherConsumer(Dispatcher dispatcher, TimeSpan minTimeSpan) { _dispatcher = dispatcher; _minTimeSpan = HiResTimer.FromTimeSpan(minTimeSpan); _timer = new Timer(state => { _nextQuantumTime = HiResTimer.Now() + _minTimeSpan; // prepare batch (generate lots of RunOnDispatcher notifications) _runOnDispatcher = new List<Action>(); // TODO: race condition where this is null at X, need to prevent timers colliding? Refresh(); // obtain dispatcher actions List<Action> actions; using (this.Lock()) { actions = _runOnDispatcher; _runOnDispatcher = null; } // execute batch on dispatcher if (actions != null && actions.Count > 0) // X { if (_dispatcher.CheckAccess()) actions.ForEach(); else _dispatcher.Invoke(new Action(() => actions.ForEach()), DispatcherPriority.DataBind); } }); _runOnRefresh.OnNotify = () => { // see if this is too short a time since last quantum? var wait = Math.Max(0, _nextQuantumTime - HiResTimer.Now()); _timer.Change(HiResTimer.ToTimeSpan(wait), TimeSpan.FromMilliseconds(-1)); }; }
public static void RunInDispatcher(Dispatcher dispatcher, DispatcherPriority priority, Action action) { if (action == null) { return; } if (dispatcher.CheckAccess()) { // we are already on thread associated with the dispatcher -> just call action try { action(); } catch (Exception ex) { //Log error here! } } else { // we are on different thread, invoke action on dispatcher's thread dispatcher.BeginInvoke( priority, (Action)( () => { try { action(); } catch (Exception ex) { //Log error here! } }) ); } }
public ContactWatcherSingular(Dispatcher dispatcher, ContactLoader loader, string directory, ContactTypes type, ContactWatcherEventCallback callback) { Assert.IsNotNull(dispatcher); // It's expected that this is created on the same thread as the manager, // so don't need to go through the dispatcher for methods invoked in the constructor. Assert.IsTrue(dispatcher.CheckAccess()); Assert.IsNotNull(loader); Assert.IsFalse(string.IsNullOrEmpty(directory)); Assert.IsNotNull(callback); Assert.IsTrue(Enum.IsDefined(typeof(ContactTypes), type)); Assert.AreNotEqual(ContactTypes.All, type); Assert.AreNotEqual(ContactTypes.None, type); _dispatcher = dispatcher; _rootDirectory = directory; _loader = loader; _notify = callback; _findExtension = "*" + Contact.GetExtensionsFromType(type); // This is why creating this object is expensive: // In order to be able to give accurate change notifications we need to know all the contacts that are present at the beginning. _knownContacts = new Dictionary<string, ContactInfo>(); // _pushedFrames = 0; _frame = new DispatcherFrame { Continue = false }; // Create the timer, but only signal it if we're going to need to reprocess an update. _timer = new Timer(); _timer.Tick += delegate { if (!_stopProcessing) { // Not invoked by the FileSystemWatcher, so don't push a frame here. _dispatcher.Invoke(DispatcherPriority.Background, (ThreadStart)_ReprocessPendingUpdate); } }; _timer.Interval = TimeSpan.FromMilliseconds(_TimerMsDelay); _timer.IsEnabled = false; _PopulateKnownContacts(type); _fileWatch = new FileSystemWatcher(_rootDirectory, _findExtension) { IncludeSubdirectories = true, NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.Attributes, }; // There's some extra indirection required here because the manager requires thread affinity. _fileWatch.Changed += FileSystemWatcher_OnChanged; _fileWatch.Created += FileSystemWatcher_OnCreated; _fileWatch.Deleted += FileSystemWatcher_OnDeleted; _fileWatch.Renamed += FileSystemWatcher_OnRenamed; _fileWatch.EnableRaisingEvents = true; }
private void theTimer_Elapsed(object sender, ElapsedEventArgs e) { double movingStep; if (ext.ActionsList.Count != 0) { CarAction carAction = ext.ActionsList[0]; if (carAction.Duration > 0) { Action action = null; double num = RandomMersene.genrand_real1() * ((RandomMersene.genrand_bool() ? -1.0 : 1.0)); if (carAction.MoveAction == MoveAction.SmartMovement) { action = () => this.theCar.translateRotateCuplu(); carAction.Duration -= this.theTimer.Interval / 1000; } else if (carAction.Direction != Direction.Straight) { movingStep = (double)((carAction.MoveAction == MoveAction.Forward ? 1 : -1)) * ext.MovingStep + num * ext.deviationPercent / 100 * ext.MovingStep; action = () => this.theCar.autoTranslateRotate(movingStep, carAction.Direction); carAction.Duration = carAction.Duration - this.theTimer.Interval / 1000; } else { movingStep = (double)((carAction.MoveAction == MoveAction.Forward ? 1 : -1)) * ext.MovingStep + num * ext.deviationPercent / 100 * ext.MovingStep; action = () => this.theCar.Move(movingStep); carAction.Duration = carAction.Duration - this.theTimer.Interval / 1000; } System.Windows.Threading.Dispatcher dispatcher = base.Dispatcher; if (action != null) { Action action1 = () => { if (action != null) { action(); } this.RefreshShits(); }; if (!dispatcher.CheckAccess()) { try { dispatcher.Invoke(action1); } catch { } } else { action1(); } } } else { ext.ActionsList.Remove(carAction); } } if (tmpRefreshShitsTimes > 0) { Action action1 = () => { this.theCar.autoTranslateRotate(0, Direction.Left); this.RefreshShits(); }; System.Windows.Threading.Dispatcher dispatcher = base.Dispatcher; if (!dispatcher.CheckAccess()) { try { dispatcher.Invoke(action1); } catch { } } else { action1(); } tmpRefreshShitsTimes--; } }
public static void ExecuteOnUIThread(Action action, Dispatcher dispatcher) { if (dispatcher.CheckAccess()) action(); else dispatcher.BeginInvoke(action); }
static void InvokeOnThread(Dispatcher dispatcher, Action action, DispatcherPriority priority = DispatcherPriority.Normal, bool forceAsyncInvoke = true) { if(dispatcher == null) return; if(!forceAsyncInvoke && dispatcher.CheckAccess()) action(); else dispatcher.BeginInvoke(action, priority); }
public WPFBlitPresenter(DirectCanvasFactory directCanvas, int width, int height, Dispatcher dispatcher) : base(directCanvas) { m_width = width; m_height = height; /* Check and see if we are on the UI thread as we may want to support * multi-threaded scenarios */ if (!dispatcher.CheckAccess()) { dispatcher.Invoke((Action)delegate { m_d3dImage = new D3DImage(); }); } else { m_d3dImage = new D3DImage(); } /* Initialize our special layers */ CreateLayer(m_width, m_height); }
private static void ParseIcons( XmlReader reader, Dispatcher dispatcher, IDictionary<string, ImageSource> icons) { while (reader.ReadToFollowing("UUID")) { var id = reader.ReadElementContentAsString(); if (reader.Name != "Data" && !reader.ReadToNextSibling("Data")) { continue; } var data = Convert.FromBase64String( reader.ReadElementContentAsString()); BitmapImage image = null; if (dispatcher.CheckAccess()) { image = new BitmapImage(); image.SetSource(new MemoryStream(data)); } else { var wait = new ManualResetEvent(false); dispatcher.BeginInvoke(() => { image = new BitmapImage(); image.SetSource(new MemoryStream(data)); wait.Set(); }); wait.WaitOne(); } if (!icons.ContainsKey(id)) icons.Add(id, image); } }
/// <summary> /// The fire scanner state changed. /// </summary> /// <param name="dispatcher"> /// The dispatcher. /// </param> /// <param name="e"> /// The e. /// </param> private static void FireScannerStateChanged(Dispatcher dispatcher, NotifyScannerStateChangedEventArgs e) { NotifyScannerStateChangedEventHandler scannerStateChanged; lock (SyncRoot) { if (currentScan != e.Id) { return; } scannerStateChanged = ScannerStateChanged; } if (scannerStateChanged != null) { if (dispatcher.CheckAccess()) { scannerStateChanged(null, e); } else { dispatcher.Invoke(new Action<Dispatcher, NotifyScannerStateChangedEventArgs>(FireScannerStateChanged), DispatcherPriority.Send, dispatcher, e); } } }
private void DispatchWhenRequired( Dispatcher d, Action a ) { if( d.CheckAccess() ) a(); else d.Invoke( a ); }
public void Generate3DModel(Dispatcher dispatcher) { if (!dispatcher.CheckAccess()) { dispatcher.Invoke(() => Generate3DModel(dispatcher)); return ; } if (m_lights.Count == 0) { m_lights.Add(new DirectionalLight(Color.FromRgb(0xFF, 0xFF, 0xFF), new Vector3D(4, 6, -5))); m_lights.Add(new DirectionalLight(Color.FromRgb(0xFF, 0xFF, 0xFF), new Vector3D(-4, -6, 5))); m_lights.Add(new AmbientLight(Color.FromRgb(0x6F, 0x5F, 0x5F))); } m_model3DGroup = new Model3DGroup(); foreach (Light light in m_lights) m_model3DGroup.Children.Add(light); foreach (QbModelPart qbModelPart in m_parts) { qbModelPart.GenerateGeometry(); foreach (GeometryModel3D geometryModel3D in qbModelPart.Geometry) { m_model3DGroup.Children.Add(geometryModel3D); } } //double maxX = m_parts.Max(n => n.Max.X); //double maxY = m_parts.Max(n => n.Max.Y); //double maxZ = m_parts.Max(n => n.Max.Z); //double minX = m_parts.Min(n => n.Min.X); //double minY = m_parts.Min(n => n.Min.Y); //double minZ = m_parts.Min(n => n.Min.Z); //BoundaryBox boundaryBox = new BoundaryBox(new Point3D(minX-0.5, minY-0.5, minZ-0.5), new Point3D(maxX + 0.5, maxY + 0.5, maxZ + 0.5), Colors.Purple); //m_model3DGroup.Children.Add(boundaryBox.GeometryModel3D); //double width = m_parts.Max(n => n.Width); //double height = m_parts.Max(n => n.Height); //double depth = m_parts.Max(n => n.Depth); //boundaryBox = new BoundaryBox(new Point3D(-0.5, -0.5, -0.5), new Point3D(width - 0.5, depth - 0.5, height - 0.5), Colors.Goldenrod); //m_model3DGroup.Children.Add(boundaryBox.GeometryModel3D); double maxX = m_parts.Max(n => n.Max.X) + 1; double maxY = m_parts.Max(n => n.Max.Y) + 1; double minX = m_parts.Min(n => n.Min.X); double minY = m_parts.Min(n => n.Min.Y); m_ground = new Ground((int) minX, (int) maxX, (int) minY, (int) maxY, Scale); foreach (GeometryModel3D geometryModel3D in m_ground.GeometryModel3D) { m_model3DGroup.Children.Add(geometryModel3D); } }
/// <summary> /// Fires off your delegate asyncronously, using the threadpool or a full managed thread if needed. /// </summary> /// <param name="d">A void delegate - can be cast to (Action) from an anonymous delgate.</param> /// <param name="dr">A delegate with a return value of some sort - can be cast to (Func<object>) from an anonymous delgate with a return.</param> /// <param name="state">A user object that can be tracked through the returned result</param> /// <param name="getRetVal">If true, and the method/delgete returns something, it is included in the AsyncRes returned (after the method completes)</param> /// <param name="tryThreadPool">True to use the TP, otherwise just go to a ful lthread - good for long running tasks.</param> /// <param name="rMode">If true, will make sure no other instances are running your method.</param> /// <returns>AsyncRes with all kind of goodies for waiting, result values, etc.</returns> private static AsyncRes Do(Func<object> dr, Action d, bool getRetVal, object state, bool tryThreadPool, ReenteranceMode rMode, bool isAsync, Dispatcher dispatcher) { //get a generic MethodInfo for checks.. MethodInfo mi = ((dr != null) ? dr.Method : d.Method); //make a unique key for output usage string key = string.Format("{0}{1}{2}{3}", ((getRetVal) ? "<-" : ""), mi.DeclaringType, ((mi.IsStatic) ? ":" : "."), mi.Name); //our custom return value, holds our delegate, state, key, etc. AsyncRes res = new AsyncRes(state, ((dr != null) ? (Delegate)dr : (Delegate)d), key, rMode); //Create a delegate wrapper for what we will actually invoke.. Action Action = (Action)delegate { if (!BeforeInvoke(res)) return; //checks for reentrance issues and sets us up try { if (res.IsCompleted) return; if (dr != null) { res.retVal = dr();//use this one if theres a return } else { d();//otherwise the simpler Action } } catch (Exception ex) { //we never want a rogue exception on a random thread, it can't bubble up anywhere System.Diagnostics.Debug.WriteLine("Async Exception:" + ex); } finally { FinishInvoke(res);//this will fire our callback if they used it, and clean up } }; if (dispatcher != null) { res.control = dispatcher; res.result = AsyncAction.ControlInvoked; if (!isAsync) { if (dispatcher.CheckAccess()) { res.completedSynchronously = true; Action(); } else { dispatcher.BeginInvoke(Action); } } else { dispatcher.BeginInvoke(Action); } return res; } //don't catch these errors - if this fails, we shouldn't try a real thread or threadpool! if (tryThreadPool) { //we are going to use the .NET threadpool try { //this is what actually fires this task off.. bool result = ThreadPool.QueueUserWorkItem(delegate { Action(); }); if (result) { res.result = AsyncAction.ThreadPool; //this means success in queueing and running the item return res; } else { //according to docs, this "won't ever happen" - exception instead, but just for kicks. System.Diagnostics.Debug.WriteLine("Failed to queue in threadpool. Method: " + key); } } catch (Exception ex) { System.Diagnostics.Debug.WriteLine("Failed to queue in threadpool: " + ex.Message, "Method: " + key); } } //if we got this far, then something up there failed, or they wanted a dedicated thread Thread t = new Thread((ThreadStart)delegate { Action(); }) { IsBackground = true, Name = ("Async_" + key) }; res.result = AsyncAction.Thread; t.Start(); return res; }