Microsoft.Ccr.Core.DispatcherQueue.Enqueue C# (CSharp) Method

        public virtual bool Enqueue(ITask task)
        {
            if (!CheckDispose ())
                return false;
            var res = true;;
            task.TaskQueue = this;
            if (dispatcher == null) {
                Handler<ITask> x = RunTask;

                ++scheduledItems;
                return x.BeginInvoke (task, null, null) != null;
            } else {
                lock (_lock) {
                    var p = Policy;
                    switch (p) {
                    case TaskExecutionPolicy.ConstrainQueueDepthDiscardTasks:
                        if (queue.Count >= MaximumQueueDepth) {
                            queue.RemoveFirst ();
                            res = false;
                        }
                        break;
                    case TaskExecutionPolicy.ConstrainQueueDepthThrottleExecution:
                        while (!isDisposed && queue.Count >= MaximumQueueDepth) {
                            ++waitingProducers;
                            Monitor.Wait (_lock);
                            --waitingProducers;
                        }
                        if (!CheckDispose ())
                            return false;
                        break;
                    case TaskExecutionPolicy.ConstrainSchedulingRateDiscardTasks:
                        UpdateSchedulingRate ();
                        if (CurrentSchedulingRate > MaximumSchedulingRate) {
                            queue.RemoveFirst ();
                            res = false;
                        }
                        break;
                    case TaskExecutionPolicy.ConstrainSchedulingRateThrottleExecution:
                        UpdateSchedulingRate ();
                        while (!isDisposed && CurrentSchedulingRate > MaximumSchedulingRate) {
                            ++waitingProducers;
                            Monitor.Wait (_lock);
                            --waitingProducers;
                            UpdateSchedulingRate ();
                        }
                        if (!CheckDispose ())
                            return false;
                        break;
                    }

                    ++scheduledItems;
                    queue.AddLast (task);
                }
                if (!suspended)
                    dispatcher.Notify (this);
                return res;
            }
        }

        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");
            }
        }