public void SchedulePeriodic()
        {
            var evt = new ManualResetEvent(false);

            var id = Thread.CurrentThread.ManagedThreadId;

            var disp = DispatcherHelpers.EnsureDispatcher();
            var sch  = new DispatcherScheduler(disp);

            var d = new SingleAssignmentDisposable();

            d.Disposable = sch.SchedulePeriodic(1, TimeSpan.FromSeconds(0.1), n =>
            {
                Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);

                if (n == 3)
                {
                    d.Dispose();

                    sch.Schedule(TimeSpan.FromSeconds(0.2), () =>
                    {
                        Assert.AreNotEqual(id, Thread.CurrentThread.ManagedThreadId);
                        evt.Set();
                    });
                }

                if (n > 3)
                {
                    Assert.Fail();
                }

                return(n + 1);
            });

            evt.WaitOne();
            disp.InvokeShutdown();
        }
예제 #2
0
        public void ScheduleError()
        {
            var ex = new Exception();

            var id   = Thread.CurrentThread.ManagedThreadId;
            var disp = DispatcherHelpers.EnsureDispatcher();
            var evt  = new ManualResetEvent(false);

            Exception thrownEx = null;

            disp.UnhandledException += (o, e) =>
            {
                thrownEx = e.Exception;
                evt.Set();
                e.Handled = true;
            };
            var sch = new DispatcherScheduler(disp);

            sch.Schedule(() => { throw ex; });
            evt.WaitOne();
            disp.InvokeShutdown();

            Assert.Same(ex, thrownEx);
        }
예제 #3
0
        public void Dispatcher()
        {
            var disp = DispatcherHelpers.EnsureDispatcher();

            Assert.Same(disp.Dispatcher, new DispatcherScheduler(disp).Dispatcher);
        }