public void DispatchEventWithDispatcherQueueExceptionPort() { using (Dispatcher d = new Dispatcher ()) { var dq = new DispatcherQueue ("foo", d); var evt = new AutoResetEvent (false); var port = new Port<Exception> (); dq.UnhandledExceptionPort = port; int portPost = 0; int dispEx = 0; d.UnhandledException += delegate { ++dispEx; }; var rec = Arbiter.Receive (true, port, (e) => { ++portPost; evt.Set(); }); rec.TaskQueue = dq; rec.Execute (); dq.Enqueue (Arbiter.FromHandler (() => { throw new Exception (); })); Assert.IsTrue (evt.WaitOne (2000), "#1"); Assert.AreEqual (1, portPost, "#2"); Assert.AreEqual (0, dispEx, "#3"); dq.Enqueue (Arbiter.FromHandler (() => { throw new Exception (); })); Assert.IsTrue (evt.WaitOne (2000), "#4"); Assert.AreEqual (2, portPost, "#5"); Assert.AreEqual (0, dispEx, "#6"); } }
public static void Activate <T>(this DispatcherQueue TaskQueue, params T[] tasks) where T : ITask { for (int i = 0; i < tasks.Length; i++) { ITask task = tasks[i]; TaskQueue.Enqueue(task); } }
public void Cleanup(ITask winner) { foreach (ReceiverTask current in _concurrentBranches) { current.Cleanup(); } foreach (ReceiverTask current2 in _mutexBranches) { current2.Cleanup(); } lock (_mutexBranches) { CleanupPending(_concurrentBranches); CleanupPending(_mutexBranches); } _dispatcherQueue.Enqueue(winner); }
public static void ExecuteToCompletion(DispatcherQueue dispatcherQueue, ITask task, Port <EmptyValue> donePort) { if (task.ArbiterCleanupHandler != null) { throw new InvalidOperationException(Resource1.TaskAlreadyHasFinalizer); } task.ArbiterCleanupHandler = delegate { donePort.Post(EmptyValue.SharedInstance); }; dispatcherQueue.Enqueue(task); }
public static void Activate(DispatcherQueue dispatcherQueue, params ITask[] arbiter) { if (dispatcherQueue == null) { throw new ArgumentNullException("dispatcherQueue"); } if (arbiter == null) { throw new ArgumentNullException("arbiter"); } for (int i = 0; i < arbiter.Length; i++) { ITask task = arbiter[i]; dispatcherQueue.Enqueue(task); } }
public static ITask ExecuteToCompletion(DispatcherQueue dispatcherQueue, ITask task) { Port <EmptyValue> done = new Port <EmptyValue>(); if (task.ArbiterCleanupHandler != null) { throw new InvalidOperationException(Resource1.TaskAlreadyHasFinalizer); } task.ArbiterCleanupHandler = delegate { done.Post(EmptyValue.SharedInstance); }; dispatcherQueue.Enqueue(task); return(Arbiter.Receive <EmptyValue>(false, done, delegate(EmptyValue e) { })); }
public static void Spawn(this DispatcherQueue TaskQueue, Handler handler) { TaskQueue.Enqueue(new Task(handler)); }
public static void SpawnIterator <T0, T1, T2>(this DispatcherQueue TaskQueue, T0 t0, T1 t1, T2 t2, IteratorHandler <T0, T1, T2> handler) { TaskQueue.Enqueue(new IterativeTask <T0, T1, T2>(t0, t1, t2, handler)); }
public static void SpawnIterator <T0>(this DispatcherQueue TaskQueue, T0 t0, IteratorHandler <T0> handler) { TaskQueue.Enqueue(new IterativeTask <T0>(t0, handler)); }
public static void SpawnIterator(this DispatcherQueue TaskQueue, IteratorHandler handler) { TaskQueue.Enqueue(new IterativeTask(handler)); }
public static void Spawn <T0, T1>(this DispatcherQueue TaskQueue, T0 t0, T1 t1, Handler <T0, T1> handler) { TaskQueue.Enqueue(new Task <T0, T1>(t0, t1, handler)); }
public void PortSetReceiveToBeUsedWithIterators() { iterPort = new PortSet (typeof (string), typeof (char), typeof (int)); iterEvent = new AutoResetEvent (false); iterRes = 0; using (Dispatcher d = new Dispatcher ()) { var disp = new DispatcherQueue ("bla", d); disp.Enqueue (new IterativeTask (this.SimpleTaskIterator)); for (int i = 0; i < 5; ++i) iterPort.PostUnknownType ((i + 1) * 10); Assert.IsTrue (iterEvent.WaitOne (2000), "#1"); Assert.AreEqual (150, iterRes, "#2"); } }
public void UnhandledExceptionPort2() { using (Dispatcher d = new Dispatcher ()) { DispatcherQueue dq = new DispatcherQueue ("foo", d); var evt = new AutoResetEvent (false); int dispEx = 0; d.UnhandledException += delegate { ++dispEx; evt.Set (); }; dq.Enqueue (Arbiter.FromHandler (() => { throw new Exception (); })); Assert.IsTrue (evt.WaitOne (2000), "#1"); Assert.AreEqual (1, dispEx, "#2"); } }
public void StuffAfterDipose() { Dispatcher d = new Dispatcher (); var dq = new DispatcherQueue ("foo", d); d.Dispose (); dq.Dispose (); Assert.IsTrue (dq.IsDisposed, "#1"); try { dq.Enqueue (Arbiter.FromHandler( () => { Console.WriteLine ("ff"); })); Assert.Fail ("#2"); } catch (ObjectDisposedException) {} d = new Dispatcher (1, ThreadPriority.Normal, DispatcherOptions.SuppressDisposeExceptions, "foo"); dq = new DispatcherQueue ("foo", d); d.Dispose (); dq.Dispose (); Assert.IsTrue (dq.IsDisposed, "#3"); Assert.IsFalse (dq.Enqueue (Arbiter.FromHandler( () => {})), "#4"); Assert.AreEqual (0, dq.ScheduledTaskCount, "#5"); }
internal void PostInternal(bool insertAtHead, PortElement <T> node) { bool flag = false; ITask task = null; DispatcherQueue dispatcherQueue = null; lock (Store) { if (insertAtHead) { Store.ElementListAddFirst(node); } else { Store.ElementListAddLast(node); } if (Store.ReceiverCount == 0) { return; } int num = 1; if (Store.ActiveReceiver == null) { num = Store.ReceiverCount; } ReceiverTask receiverTask = Store.ActiveReceiver; int i = 0; while (i < num) { if (num != 1) { receiverTask = Store.GetReceiverAtIndex(i); } task = null; flag = receiverTask.Evaluate(node, ref task); dispatcherQueue = receiverTask.TaskQueue; if (flag) { Store.ElementListRemove(node); if (receiverTask.State != ReceiverTaskState.Persistent) { Store.RemoveReceiver(receiverTask); if (i > 1) { i--; } else { receiverTask = Store.ActiveReceiver; } num = Store.ReceiverCount; break; } break; } else { if (task != null) { dispatcherQueue.Enqueue(task); } i++; } } } if (flag && task != null) { dispatcherQueue.Enqueue(task); } }