C# IScheduler.GetTriggerGroupNames方法代码示例

        /// <summary>
        /// This method unschedules all jobs in a specified scheduler.
        /// </summary>
        /// <param name="qScheduler"></param>
        /// <returns>bool</returns>
        public bool UnscheduleAll(IScheduler qScheduler)
        {
            foreach (var group in qScheduler.GetTriggerGroupNames())
            {
                var groupMatcher = GroupMatcher<JobKey>.GroupContains(group);
                var jobKeys = qScheduler.GetJobKeys(groupMatcher);

                foreach (var triggers in jobKeys.Select(jobKey => qScheduler.GetTriggersOfJob(jobKey)))
                {
                    return qScheduler.UnscheduleJobs(triggers.Select(t => t.Key).ToList());
                }
            }
            return false;
        }

        private static void GetAllJobs(IScheduler scheduler)
        {
            IList<string> jobGroups = scheduler.GetJobGroupNames();
            IList<string> triggerGroups = scheduler.GetTriggerGroupNames();

            foreach (string group in jobGroups)
            {
                var groupMatcher = GroupMatcher<JobKey>.GroupContains(group);
                var jobKeys = scheduler.GetJobKeys(groupMatcher);
                foreach (var jobKey in jobKeys)
                {
                    var detail = scheduler.GetJobDetail(jobKey);
                    var triggers = scheduler.GetTriggersOfJob(jobKey);
                    foreach (ITrigger trigger in triggers)
                    {
                        Console.WriteLine(group);
                        Console.WriteLine(jobKey.Name);
                        Console.WriteLine(detail.Description);
                        Console.WriteLine(trigger.Key.Name);
                        Console.WriteLine(trigger.Key.Group);
                        Console.WriteLine(trigger.GetType().Name);
                        Console.WriteLine(scheduler.GetTriggerState(trigger.Key));
                        DateTimeOffset? nextFireTime = trigger.GetNextFireTimeUtc();
                        if (nextFireTime.HasValue)
                        {
                            Console.WriteLine(nextFireTime.Value.LocalDateTime.ToString());
                        }

                        DateTimeOffset? previousFireTime = trigger.GetPreviousFireTimeUtc();
                        if (previousFireTime.HasValue)
                        {
                            Console.WriteLine(previousFireTime.Value.LocalDateTime.ToString());
                        }
                    }
                }
            }
        }

        private JobGroups GetAllJobs(IScheduler scheduler)
        {
            int countJobs = 0;
            IList<string> jobGroups = scheduler.GetJobGroupNames();
            IList<string> triggerGroups = scheduler.GetTriggerGroupNames();
            List<JobGroup> entidadeJobGroup = new List<JobGroup>();
            foreach (string group in jobGroups)
            {

                var groupMatcher = GroupMatcher<JobKey>.GroupContains(group);
                JobGroup grupoItem = new JobGroup();
                grupoItem.Name = group;
                grupoItem.Jobs = new List<JobDetails>();
                var jobKeys = scheduler.GetJobKeys(groupMatcher);
                foreach (var jobKey in jobKeys)
                {
                    countJobs++;
                    var detail = scheduler.GetJobDetail(jobKey);
                    var triggers = scheduler.GetTriggersOfJob(jobKey);
                    foreach (ITrigger trigger in triggers)
                    {
                        DateTimeOffset? nextFireTime = trigger.GetNextFireTimeUtc();
                        DateTimeOffset? previousFireTime = trigger.GetPreviousFireTimeUtc();
                        DateTimeOffset? startFireTime = trigger.StartTimeUtc;
                        DateTimeOffset? lastFireTime = trigger.FinalFireTimeUtc;

                        //
                        grupoItem.Jobs.Add(new JobDetails()
                        {
                            Grupo = group,
                            FirstFire = (startFireTime.HasValue) ? startFireTime.Value.LocalDateTime.ToString() : "",
                            LastFire = (lastFireTime.HasValue) ? lastFireTime.Value.LocalDateTime.ToString() : "",
                            Type = trigger.GetType().Name,
                            NomeLegivel = service.GetWorkflowSistemaName(jobKey.Name),
                            Name = jobKey.Name,
                            Description = detail.Description,
                            NextFire = (nextFireTime.HasValue) ? nextFireTime.Value.LocalDateTime.ToString() : "",
                            PreviousFire = (previousFireTime.HasValue) ? previousFireTime.Value.LocalDateTime.ToString() : "",
                            State = scheduler.GetTriggerState(trigger.Key).ToString(),
                            TriggerId = trigger.Key.Name
                        });

                    }
                }
                entidadeJobGroup.Add(grupoItem);

            }
            JobGroups entidadeRetorno = new JobGroups();
            entidadeRetorno.Grupos = new List<JobGroup>();
            entidadeRetorno.Grupos = entidadeJobGroup;
            entidadeRetorno.TotalJobs = countJobs;
            return entidadeRetorno;
        }

        private static IList<TriggerGroupData> GetTriggerGroups(IScheduler scheduler)
        {
            var result = new List<TriggerGroupData>();
            if (!scheduler.IsShutdown)
            {
                foreach (var groupName in scheduler.GetTriggerGroupNames())
                {
                    var data = new TriggerGroupData(groupName);
                    data.Init();
                    result.Add(data);
                }
            }

            return result;
        }

//.........这里部分代码省略.........
                   Assert.That(triggerFromDb.StartTimeOfDay.Second, Is.EqualTo(3));

                   Assert.That(triggerFromDb.EndTimeOfDay.Hour, Is.EqualTo(2));
                   Assert.That(triggerFromDb.EndTimeOfDay.Minute, Is.EqualTo(3));
                   Assert.That(triggerFromDb.EndTimeOfDay.Second, Is.EqualTo(4));

                   job.RequestsRecovery = (true);
                   CalendarIntervalTriggerImpl intervalTrigger = new CalendarIntervalTriggerImpl(
                       "calint_trig_" + count,
                       schedId,
                       DateTime.UtcNow.AddMilliseconds(300),
                       DateTime.UtcNow.AddMinutes(1),
                       IntervalUnit.Second,
                       8);
                   intervalTrigger.JobKey = job.Key;

                   scheduler.ScheduleJob(intervalTrigger);

                   // bulk operations
                   var info = new Dictionary<IJobDetail, Collection.ISet<ITrigger>>();
                   IJobDetail detail = new JobDetailImpl("job_" + count, schedId, typeof(SimpleRecoveryJob));
                   ITrigger simple = new SimpleTriggerImpl("trig_" + count, schedId, 20, TimeSpan.FromMilliseconds(4500));
                   var triggers = new Collection.HashSet<ITrigger>();
                   triggers.Add(simple);
                   info[detail] = triggers;

                   scheduler.ScheduleJobs(info, true);

                   Assert.IsTrue(scheduler.CheckExists(detail.Key));
                   Assert.IsTrue(scheduler.CheckExists(simple.Key));

                   // QRTZNET-243
                   scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupContains("a").DeepClone());
                   scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupEndsWith("a").DeepClone());
                   scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupStartsWith("a").DeepClone());
                   scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupEquals("a").DeepClone());

                   scheduler.GetTriggerKeys(GroupMatcher<TriggerKey>.GroupContains("a").DeepClone());
                   scheduler.GetTriggerKeys(GroupMatcher<TriggerKey>.GroupEndsWith("a").DeepClone());
                   scheduler.GetTriggerKeys(GroupMatcher<TriggerKey>.GroupStartsWith("a").DeepClone());
                   scheduler.GetTriggerKeys(GroupMatcher<TriggerKey>.GroupEquals("a").DeepClone());

                   scheduler.Start();

                   Thread.Sleep(TimeSpan.FromSeconds(3));

                   scheduler.PauseAll();

                   scheduler.ResumeAll();

                   scheduler.PauseJob(new JobKey("job_1", schedId));

                   scheduler.ResumeJob(new JobKey("job_1", schedId));

                   scheduler.PauseJobs(GroupMatcher<JobKey>.GroupEquals(schedId));

                   Thread.Sleep(TimeSpan.FromSeconds(1));

                   scheduler.ResumeJobs(GroupMatcher<JobKey>.GroupEquals(schedId));

                   scheduler.PauseTrigger(new TriggerKey("trig_2", schedId));
                   scheduler.ResumeTrigger(new TriggerKey("trig_2", schedId));

                   scheduler.PauseTriggers(GroupMatcher<TriggerKey>.GroupEquals(schedId));

                   Assert.AreEqual(1, scheduler.GetPausedTriggerGroups().Count);

                   Thread.Sleep(TimeSpan.FromSeconds(3));
                   scheduler.ResumeTriggers(GroupMatcher<TriggerKey>.GroupEquals(schedId));

                   Assert.IsNotNull(scheduler.GetTrigger(new TriggerKey("trig_2", schedId)));
                   Assert.IsNotNull(scheduler.GetJobDetail(new JobKey("job_1", schedId)));
                   Assert.IsNotNull(scheduler.GetMetaData());
                   Assert.IsNotNull(scheduler.GetCalendar("weeklyCalendar"));

                   Thread.Sleep(TimeSpan.FromSeconds(20));

                   scheduler.Standby();

                   CollectionAssert.IsNotEmpty(scheduler.GetCalendarNames());
                   CollectionAssert.IsNotEmpty(scheduler.GetJobKeys(GroupMatcher<JobKey>.GroupEquals(schedId)));

                   CollectionAssert.IsNotEmpty(scheduler.GetTriggersOfJob(new JobKey("job_2", schedId)));
                   Assert.IsNotNull(scheduler.GetJobDetail(new JobKey("job_2", schedId)));

                   scheduler.DeleteCalendar("cronCalendar");
                   scheduler.DeleteCalendar("holidayCalendar");
                   scheduler.DeleteJob(new JobKey("lonelyJob", "lonelyGroup"));
                   scheduler.DeleteJob(job.Key);

                   scheduler.GetJobGroupNames();
                   scheduler.GetCalendarNames();
                   scheduler.GetTriggerGroupNames();
               }
               }
               finally
               {
               scheduler.Shutdown(false);
               }
        }

        private static void CleanUp(IScheduler inScheduler)
        {
            // unschedule jobs
            IList<string> groups = inScheduler.GetTriggerGroupNames();
            foreach (string group in groups)
            {
                Collection.ISet<TriggerKey> keys = inScheduler.GetTriggerKeys(GroupMatcher<TriggerKey>.GroupEquals(group));
                foreach (TriggerKey key in keys)
                {
                    inScheduler.UnscheduleJob(key);
                }
            }

            // delete jobs
            groups = inScheduler.GetJobGroupNames();
            foreach (string group in groups)
            {
                Collection.ISet<JobKey> jobNames = inScheduler.GetJobKeys(GroupMatcher<JobKey>.GroupEquals(group));
                foreach (JobKey jobKey in jobNames)
                {
                    inScheduler.DeleteJob(jobKey);
                }
            }

            inScheduler.DeleteCalendar("annualCalendar");
            inScheduler.DeleteCalendar("baseCalendar");
            inScheduler.DeleteCalendar("cronCalendar");
            inScheduler.DeleteCalendar("dailyCalendar");
            inScheduler.DeleteCalendar("holidayCalendar");
            inScheduler.DeleteCalendar("monthlyCalendar");
            inScheduler.DeleteCalendar("weeklyCalendar");
        }