C# Scheduler.Start方法代码示例

        public void Given_scheduler_with_daily_item()
        {
            var context = new TestSchedulerContext();

            _scheduler = new Scheduler(context);

            var runsoon = new TimeSpan(DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);

            var foo1 = JobFactory.Daily("Foo1", () => { Console.WriteLine("Foo1"); foo1_calls += 1; }, runsoon, description: "Description for Foo1");
            var foo2 = JobFactory.Daily("Foo2", () => Console.WriteLine("Foo2"), runsoon);

            _scheduler.Schedule(foo1);
            _scheduler.Schedule(foo2);

            _scheduler.Start();

            Wait.Until(() => foo1_calls > 0, 30);

            context.MoveToTommorrow();

            Wait.Until(() => foo1_calls > 1, 30);

            context.MoveForwardNDays(2);

            Wait.Until(() => foo1_calls > 2, 50);
        }

 public void ItShouldStartAndStopWithoutExceptions()
 {
     var scheduler = new Scheduler(new FakeLoggerFactory());
     scheduler.Start();
     var stopped = scheduler.Stop().Wait(4000);
     Assert.True(stopped);
 }

 public void PostShouldThrowExceptionAfterStop()
 {
     var scheduler = new Scheduler(new FakeLoggerFactory());
     scheduler.Start();
     scheduler.Stop();
     Assert.Throws<InvalidOperationException>(() => scheduler.Post("testing", () => { }));
 }

        static void Main(string[] args)
        {
            System.Console.WriteLine("Application started -  Esc to quit");

            var sessionFactory = NHibernateFactory.AssembleSessionFactory(DATABASE_FILE);
            ILog consoleLogger = new ConsoleLogger {VerbosityLevel = 2};
            ILog databaseLogger = new Logger(new LogEntryDatabaseRepository(sessionFactory)) {VerbosityLevel = 1};
            ILog log = new CompositeLogger(consoleLogger, databaseLogger);

            var iocContainer = new IocContainerForScheduler();
            iocContainer.BindToConstant(sessionFactory);
            var taskDirectory = new DirectoryInfo(Assembly.GetExecutingAssembly().Location).Parent.FullName;

            var taskScheduler = new Scheduler(iocContainer, taskDirectory, new FileUtilities(), new TimerWithTimestamp(0, 10000), new TimerWithTimestamp(0, 2000), log);
            taskScheduler.Start();

            try
            {
                while (System.Console.ReadKey().Key != ConsoleKey.Escape) { }
            }
            catch (Exception e)
            {
                log.WriteEntry(new LogEntry(e.Source, e.Message, DateTime.Now));
            }
        }

		public void Ctor_TimeSpan_Success()
		{
			Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(0.1));
			BlockingScheduledAction action = new BlockingScheduledAction();
			scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now.AddSeconds(1.0)), action, true, null, null));
			scheduler.Start();
			Assert.IsTrue(scheduler.IsEnabled);

			Stopwatch watch = Stopwatch.StartNew();
			action.Waiter.WaitOne();
			Assert.IsTrue(watch.ElapsedMilliseconds < 2000);
			scheduler.Dispose();
		}

		public void MultipleIterations_Success()
		{
			Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(0.1));
			BlockingScheduledAction action1 = new BlockingScheduledAction(10);
			scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateInterval(DateTimeOffset.Now, TimeSpan.FromMilliseconds(100.0), Weekdays.All), action1, true, null, null));
			BlockingScheduledAction action2 = new BlockingScheduledAction(5);
			scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateInterval(DateTimeOffset.Now, TimeSpan.FromMilliseconds(200.0), Weekdays.All), action2, true, null, null));
			scheduler.Start();

			Stopwatch watch = Stopwatch.StartNew();
			ManualResetEvent.WaitAny(new WaitHandle[] { action1.Waiter, action2.Waiter });
			Assert.IsTrue(watch.ElapsedMilliseconds < 1200);
			scheduler.Dispose();
		}

        public void Given_scheduler_with_some_work()
        {
            var ctx = new TestSchedulerContext();
            _scheduler = new Scheduler(ctx);

            _scheduler.Schedule("Foo1", () => { _foo1WorkDone = true; }, TimeSpan.FromMinutes(10));
            _scheduler.Schedule("Foo2", () => { _foo2WorkDone = true; }, TimeSpan.FromMinutes(10));

            // Lest ensure that all workitems
            // are applicable for schedule
            ctx.MoveToTommorrow();

            _scheduler.Start();

            Wait.Until(() => _scheduler.GatherOveralStats().RunningJobs + _scheduler.GatherOveralStats().ScheduledJobs == 0);
        }

        private static void RunBot()
        {
            try
            {
                var scheduler = new Scheduler();

                var container = CreateCompositionContainer();
                // Add all the sprockets to the sprocket list
                var announcements = container.GetExportedValues<IAnnounce>();

                Console.WriteLine(String.Format("Connecting to {0}...", _serverUrl));
                Bot bot = new Bot(_serverUrl, _botName, _botPassword);

                foreach (var s in container.GetExportedValues<ISprocket>())
                    bot.AddSprocket(s);

                bot.PowerUp();
                JoinRooms(bot);
                var users = bot.GetUsers(bot.Rooms.First());
                var user = bot.GetUserInfo(bot.Rooms.First(), users.First().Name.ToString());

                scheduler.Start(announcements, bot);

                Console.Write("Press enter to quit...");
                Console.ReadLine();

                scheduler.Stop();
                bot.ShutDown();

                _appShouldExit = true;
            }
            catch (Exception e)
            {
                Console.WriteLine("ERROR: " + e.GetBaseException().Message);
            }
        }

 protected override void OnStart(string[] args)
 {
     _scheduler = new Scheduler();
     _scheduler.Start();
 }

        /// <summary>
        /// Application entry point.
        /// </summary>
        /// <param name="args">The execution arguments.</param>
        /// <returns>The application's exit code.</returns>
        public static int Main(string[] args)
        {
            int all = 0, backup = 0, man = 0, schedules = 0, restore = 0;
            string target = null;

            var options = new OptionSet()
            {
                { "a|all", "execute all backup and restore targets in the configuration.", v => { ++all; } },
                { "b|backup", "execute backup targets.", v => { ++backup; } },
                { "r|restore", "execute restore targets.", v => { ++restore; } },
                { "s|schedules", "execute schedules.", v => { ++schedules; } },
                { "t|target=", "the name of the specific backup/restore/schedule to execute.", v => target = v },
                { "m|man", "show this message", v => { ++man; } }
            };

            try
            {
                options.Parse(args);
            }
            catch (OptionException ex)
            {
                ParseError(options, ex);
                return 1;
            }

            if (man > 0)
            {
                Help(options);
                return 0;
            }

            if (all > 0)
            {
                ExecuteBackup(String.Empty);
                ExecuteRestore(String.Empty);
            }
            else if (backup > 0)
            {
                if (!ExecuteBackup(target))
                {
                    return 1;
                }
            }
            else if (restore > 0)
            {
                if (!ExecuteRestore(target))
                {
                    return 1;
                }
            }
            else if (schedules > 0)
            {
                ScheduleConfigurationElementCollection schd = new ScheduleConfigurationElementCollection();

                if (!String.IsNullOrEmpty(target))
                {
                    var schedule = SThreeQLConfiguration.Section.Schedules[target];

                    if (schedule != null)
                    {
                        schd.Add(schedule);
                    }
                    else
                    {
                        WriteError("There is no schedule defined for \"{0}\".", target);
                        return 1;
                    }
                }
                else
                {
                    foreach (var schedule in SThreeQLConfiguration.Section.Schedules)
                    {
                        schd.Add(schedule);
                    }
                }

                Scheduler scheduler = new Scheduler(schd);
                scheduler.BackupComplete += new EventHandler<DatabaseTargetEventArgs>(BackupComplete);
                scheduler.BackupCompressComplete += new EventHandler<DatabaseTargetEventArgs>(BackupCompressComplete);
                scheduler.BackupCompressStart += new EventHandler<DatabaseTargetEventArgs>(BackupCompressStart);
                scheduler.BackupStart += new EventHandler<DatabaseTargetEventArgs>(BackupStart);
                scheduler.BackupTransferComplete += new EventHandler<DatabaseTargetEventArgs>(BackupTransferComplete);
                scheduler.BackupTransferProgress += new EventHandler<DatabaseTargetEventArgs>(BackupTransferProgress);
                scheduler.BackupTransferStart += new EventHandler<DatabaseTargetEventArgs>(BackupTransferStart);
                scheduler.RestoreComplete += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreComplete);
                scheduler.RestoreDecompressComplete += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreDecompressComplete);
                scheduler.RestoreDecompressStart += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreDecompressStart);
                scheduler.RestoreStart += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreStart);
                scheduler.RestoreTransferComplete += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreTransferComplete);
                scheduler.RestoreTransferProgress += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreTransferProgress);
                scheduler.RestoreTransferStart += new EventHandler<RestoreDatabaseTargetEventArgs>(RestoreTransferStart);
                scheduler.ScheduleComplete += new EventHandler<ScheduleEventArgs>(ScheduleComplete);
                scheduler.ScheduleError += new EventHandler<ScheduleEventArgs>(ScheduleError);
                scheduler.ScheduleStart += new EventHandler<ScheduleEventArgs>(ScheduleStart);
                scheduler.Start();
//.........这里部分代码省略.........

		public void TaskStarting_Canceled_Success()
		{
			bool TaskStartingExecuted = false;
			Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(0.1));
			scheduler.TaskStarting += (sender, e) =>
			{
				e.Cancel = true;
				TaskStartingExecuted = true;
			};
			BlockingScheduledAction action1 = new BlockingScheduledAction();
			ScheduledTask<BlockingScheduledAction> task = new ScheduledTask<BlockingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now), action1, true, null, null);
			scheduler.Tasks.Add(task);
			scheduler.Start();

			SpinWait.SpinUntil(() => { return TaskStartingExecuted; });
			scheduler.Stop();

			Assert.IsNull(task.LastEndTime);

			scheduler.Dispose();
		}

		public void TaskStarting_TaskCompleted_Success()
		{
			bool TaskStartingExecuted = false;
			bool TaskCompletedExecuted = false;
			Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(0.1));
			scheduler.TaskCompleted += (sender, e) =>
			{
				TaskCompletedExecuted = true;
			};
			scheduler.TaskStarting += (sender, e) =>
			{
				TaskStartingExecuted = true;
			};
			BlockingScheduledAction action1 = new BlockingScheduledAction();
			scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now), action1, true, null, null));
			scheduler.Start();

			action1.Waiter.WaitOne();
			scheduler.Stop();

			Assert.IsTrue(TaskCompletedExecuted, nameof(TaskCompletedExecuted));
			Assert.IsTrue(TaskStartingExecuted, nameof(TaskStartingExecuted));

			scheduler.Dispose();
		}

		public void Interval_Success()
		{
			Scheduler<BlockingScheduledAction> scheduler = new Scheduler<BlockingScheduledAction>(TimeSpan.FromSeconds(1000.0));
			BlockingScheduledAction action1 = new BlockingScheduledAction(5);
			scheduler.Tasks.Add(new ScheduledTask<BlockingScheduledAction>(Schedule.CreateInterval(DateTimeOffset.Now, TimeSpan.FromMilliseconds(200.0), Weekdays.All), action1, true, null, null));
			scheduler.Start();

			Assert.AreEqual(1000.0, scheduler.Interval.TotalSeconds);
			scheduler.Interval = TimeSpan.FromSeconds(0.1);

			Stopwatch watch = Stopwatch.StartNew();
			action1.Waiter.WaitOne();
			Assert.IsTrue(watch.ElapsedMilliseconds < 1200);
			scheduler.Dispose();
		}

		public void Stop_TimeoutExpired_Error()
		{
			Scheduler<WaitingScheduledAction> scheduler = new Scheduler<WaitingScheduledAction>(TimeSpan.FromSeconds(0.1));
			WaitingScheduledAction action1 = new WaitingScheduledAction();
			scheduler.Tasks.Add(new ScheduledTask<WaitingScheduledAction>(Schedule.CreateOneTime(DateTimeOffset.Now), action1, true, null, null));
			scheduler.Start();

			action1.StartWaiter.WaitOne();
			CustomAssert.ThrowsException<CodedTimeoutException>(() =>
			{
				scheduler.Stop(TimeSpan.FromSeconds(0.5));
			});
			action1.Waiter.Set();
			scheduler.Dispose();
		}

		public void Stop_TimeoutNegative_Error()
		{
			Scheduler<CancellableScheduledAction> scheduler = new Scheduler<CancellableScheduledAction>(TimeSpan.FromSeconds(0.1));
			scheduler.Stop();
			scheduler.Start();

			CustomAssert.ThrowsException<CodedArgumentOutOfRangeException>(() =>
			{
				scheduler.Stop(TimeSpan.FromSeconds(-1.0));
			});
			scheduler.Dispose();
		}