public QuartzService()
 {
     InitializeComponent();
     logger = LogManager.GetLogger(GetType());
     ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
     scheduler = schedulerFactory.GetScheduler();
 }

        /// <summary>
        /// A simpler alternative to the irritatingly useless FileSystemWatcher
        /// </summary>
        /// <param name="file">The file to monitor</param>
        /// <param name="refreshPeriod">The refresh period.</param>
        /// <param name="scheduler">The scheduler.</param>
        /// <returns></returns>
        public static IObservable<FileNotification> WatchFile(this FileInfo file, TimeSpan? refreshPeriod = null,
            IScheduler scheduler = null)
        {
           return Observable.Create<FileNotification>(observer =>
            {
                var refresh = refreshPeriod ?? TimeSpan.FromMilliseconds(250);
                scheduler = scheduler ?? Scheduler.Default;

                FileNotification notification = null;
                return scheduler.ScheduleRecurringAction(refresh, () =>
                {
                    try
                    {
                        notification = notification == null
                            ? new FileNotification(file)
                            : new FileNotification(notification);

                        observer.OnNext(notification);
                    }
                    catch (Exception ex)
                    {
                        notification = new FileNotification(file, ex);
                        observer.OnNext(notification);
                    }
                });

            }).DistinctUntilChanged();
        }

 public RepoWatcher(IGithubBrowser browser, Repo repoToWatch, IScheduler backgroundScheduler)
 {
     _timerDisposal = Observable
         .Interval(_defaultRefreshSpan, backgroundScheduler)
         .SelectMany(_ => browser.GetCommits(repoToWatch))
         .Subscribe(OnCommitsArrived);
 }

 public FaxMessageService(IMessaggisticaService messaggisticaService, IScheduler scheduler, IConfigurationMessageService configurationService, IDaoFactory daoFactory)
 {
     _messaggisticaService = messaggisticaService;
     _scheduler = scheduler;
     _configurationService = configurationService;
     _daoFactory = daoFactory;
 }

 internal TestBlobCache(Action disposer, 
     IScheduler scheduler, 
     IEnumerable<KeyValuePair<string, byte[]>> initialContents)
     : this(scheduler, initialContents)
 {
     inner = Disposable.Create(disposer);
 }

		public NotifyPropertyChangedBase(IScheduler scheduler) {
			if (scheduler != null) {
				this.scheduler = scheduler;
			} else {
				this.scheduler = Scheduler.Immediate;
			}
		}

 public LinkSpiderPipeline(string entityName, IScheduler nextSpiderScheduler, ISpider nextSpider, LinkSpiderPrepareStartUrls prepareStartUrls)
 {
     NextSpiderScheduler = nextSpiderScheduler;
     NextSpider = nextSpider;
     _prepareStartUrls = prepareStartUrls;
     _entityName = entityName;
 }

 internal DefaultKayakSocket(Socket socket, IScheduler scheduler)
 {
     this.id = nextId++;
     this.socket = new SocketWrapper(socket);
     this.scheduler = scheduler;
     state = new KayakSocketState(false);
 }

        static void Main(string[] args)
        {
            try
            {
                Console.Title = "QMail";
                Console.ForegroundColor = ConsoleColor.White;
                ISchedulerFactory sf = new StdSchedulerFactory();
                Scheduler = sf.GetScheduler();
                new TskInspectDetailJobTrigger();
                Scheduler.Start();

                for (var i = 0; i < 10; i++) {
                    Console.WriteLine();
                }

                Console.ForegroundColor = ConsoleColor.Yellow;

                Console.WriteLine("       ---------------------------------------------------");
                Console.WriteLine("       ...................QMail已启动......................");
                Console.WriteLine("       ...................请不要关闭此窗口.................");
                Console.WriteLine("       ---------------------------------------------------");
                for (var i = 0; i < 10; i++)
                {
                    Console.WriteLine();
                }
                Console.ReadLine();
            }
            catch (Exception e) {
                LogUtil.Logger.Error(e.Message);
            }
        }

 public void RemoveScheduler(IScheduler scheduler)
 {
     lock (_listLock)
     {
         _scheduleList.Remove(scheduler);
     }
 }

 public void AddScheduler(IScheduler scheduler)
 {
     lock (_listLock)
     {
         _scheduleList.Add(scheduler);
     }
 }

 static TaskPool()
 {
     _taskpool = new TaskPool();
     ISchedulerFactory sf = new StdSchedulerFactory();
     _ische = sf.GetScheduler();
     _ische.Start();
 }

		public JobScheduler(IScheduler quartzScheduler, Logger logger, ISystemSettings systemSettings)
		{
			this._quartzScheduler = DIHelper.VerifyParameter(quartzScheduler);
			this._logger = DIHelper.VerifyParameter(logger);
			this._systemSettings = DIHelper.VerifyParameter(systemSettings);

		}

        public TaskCoordinator(IScheduler scheduler, Logger logger)
        {
            _logger = logger;
            _scheduler = scheduler;

            _logger.Info("TaskCoordincator started with scheduler: {0}", scheduler.SchedulerInstanceId);
        }

 //public void Echo(string message)
 //{
 //    Console.WriteLine(message);
 //    hubProxy.Invoke("commandSent", string.Empty, message);
 //}
 private static void ConfigureScheduledEvents(IScheduler sched)
 {
     foreach (var trigger in GetTriggers())
     {
         sched.ScheduleJob(JobBuilder.Create<PublishEvent>().Build(), trigger);
     }
 }

		public ThreadWorker (IScheduler sched, ThreadWorker[] others, IProducerConsumerCollection<Task> sharedWorkQueue,
		                     bool createThread, int maxStackSize, ThreadPriority priority, EventWaitHandle handle)
		{
			this.others          = others;

			this.dDeque = new CyclicDeque<Task> ();
			
			this.sharedWorkQueue = sharedWorkQueue;
			this.workerLength    = others.Length;
			this.isLocal         = !createThread;
			this.waitHandle      = handle;
			
			this.childWorkAdder = delegate (Task t) { 
				dDeque.PushBottom (t);
				sched.PulseAll ();
			};
			
			// Find the stealing start index randomly (then the traversal
			// will be done in Round-Robin fashion)
			do {
				this.stealingStart = r.Next(0, workerLength);
			} while (others[stealingStart] == this);
			
			InitializeUnderlyingThread (maxStackSize, priority);
		}

 public void SetUp()
 {
     _collector = Substitute.For<IItemCollector>();
     _scheduler = Substitute.For<IScheduler>();
     _loginModel = Substitute.For<ILoginModel>();
     _uut = new ScheduledShoppingListModel(_collector, _scheduler, _loginModel);
 }

		public ThreadWorker (IScheduler sched, ThreadWorker[] others, IProducerConsumerCollection<Task> sharedWorkQueue,
		                     bool createThread, int maxStackSize, ThreadPriority priority)
		{
			this.others          = others;

//			if (!string.IsNullOrEmpty (Environment.GetEnvironmentVariable ("USE_CYCLIC"))) {
//				Console.WriteLine ("Using cyclic deque");
//				this.dDeque = new CyclicDeque<Task> ();
//			} else {
//				this.dDeque = new DynamicDeque<Task> ();
//			}
			this.dDeque = new CyclicDeque<Task> ();
			
			this.sharedWorkQueue = sharedWorkQueue;
			this.workerLength    = others.Length;
			this.isLocal         = !createThread;
			
			this.childWorkAdder = delegate (Task t) { 
				dDeque.PushBottom (t);
				sched.PulseAll ();
			};
			
			// Find the stealing start index randomly (then the traversal
			// will be done in Round-Robin fashion)
			do {
				this.stealingStart = r.Next(0, workerLength);
			} while (others[stealingStart] == this);
			
			InitializeUnderlyingThread (maxStackSize, priority);
		}

 public NotificationService(
     PhoneApplicationFrame RootFrame,
     [Dispatcher] IScheduler Dispatcher
     ) {
     RootFrame.Navigated += OnFrameNavigated;
     NotificationScheduler = Dispatcher;
 }

 private static void ScheduleJob(IScheduler scheduler)
 {
     const int INTERVAL_IN_SECONDS = 5;
     scheduler.ScheduleJob(
         JobBuilder.Create<YhdArchiveJob>().WithIdentity("YhdArchiveJob").Build(),
         TriggerBuilder.Create().WithIdentity("YhdArchiveTrigger").StartNow().WithSimpleSchedule(x => x.RepeatForever().WithIntervalInSeconds(INTERVAL_IN_SECONDS)).Build());
 }