App.config, Quartz.NET i konfiguracja Unity

Witam,

W jaki sposób mogę z poziomu App.config uzyskać to:

Quartz.ISchedulerFactory schedulerFactory = new Quartz.Impl.StdSchedulerFactory();
Quartz.IScheduler scheduler = schedulerFactory.GetScheduler();
```
Mam już dodane ISchedulerFactory, pozostaje wywołanie schedulerFactory.GetScheduler()
```xml
  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <container>
      <register type="Quartz.ISchedulerFactory, Quartz"
                mapTo="Quartz.Impl.StdSchedulerFactory, Quartz">
        <lifetime type="singleton"/>
      </register>
      <register type="Quartz.IScheduler, Quartz"
                mapTo="?????">
        <lifetime type="singleton"/>
      </register>
    </container>
  </unity>
```
Pozdrawiam,
mr-owl

Nie jestem pewien, czy dobrze zrozumiałem problem.
Raczej Quartz.IScheduler nie powinieneś konfigurować. O to chodzi w fabryce, aby na podstawie przesłanych parametrów (czy w konstruktorze, czy później w metodzie GetScheduler fabryki) otrzymać poprawny obiekt. Jaki sens fabryki zwracającej tylko konkretną, jedną instancję, ignorując parametry?
Edit:
Ok, po chwili zastanowienia, mogę sobie wyobrazić, że może być to w jakiś sposób użyte do testowania, ale doprecyzuj.

Witam,

To trochę nie rozumiem dlaczego w https://github.com/hbiarge/Quartz.Unity/ muszę zarejestrować jeszcze IScheduler ale z poziomu pliku konfiguracyjnego nie mogę tego zrobić. :-( Jak dla mnie to trochę nie jest spójne. Dla MvvmDialogs wystarczyło zarejestrować kilka interfejsów i całość ładnie działa a tutaj schody:

      <register type="MvvmDialogs.DialogTypeLocators.IDialogTypeLocator, MvvmDialogs"
                mapTo="MvvmDialogs.DialogTypeLocators.NamingConventionDialogTypeLocator, MvvmDialogs">
        <lifetime type="singleton" />
      </register>
      <register type="MvvmDialogs.DialogFactories.IDialogFactory, MvvmDialogs"
                mapTo="MvvmDialogs.DialogFactories.ReflectionDialogFactory, MvvmDialogs">
        <lifetime type="singleton" />
      </register>
      <register type="MvvmDialogs.IDialogService, MvvmDialogs"
                mapTo="MvvmDialogs.DialogService, MvvmDialogs">
        <lifetime type="singleton" />
      </register>

Pozdrawiam,

mr-owl

mr-owl napisał(a):

To trochę nie rozumiem dlaczego w https://github.com/hbiarge/Quartz.Unity/ muszę zarejestrować jeszcze IScheduler

Nie musisz, tam jest pokazany konkretny przypadek. Jak dobrze rozumiem, po prostu w ten sposób ktoś korzystając z IScheduler (np. wstrzykniętego przez konstruktor) otrzyma instancję obiektu utworzoną przez metodę GetScheduler, ze wcześniej zarejestrowanej fabryki. Nie znam Unity, więc nie powiem czy w XML da się takie coś osiągnąć - ale może to powód by nie korzystać z konfiguracji XML? :P
Po samym zarejestrowaniu fabryki możesz korzystać w ten sposób:
var scheduler = schedulerFactory.GetScheduler();
i powinieneś dostawać obiekt, albo po prostu nie rejestrować fabryki, tylko konkretny IScheduler (co jest chyba złym pomysłem).

Witam,

Tak dla potomności:
App.config

  <unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
    <container>
      <extensions>
        <add type="Quartz.Unity.QuartzUnityExtension, Quartz.Unity.45" />
      </extensions>
      <register type="Quartz.ISchedulerFactory, Quartz"
                mapTo="Quartz.Impl.StdSchedulerFactory, Quartz">
        <lifetime type="singleton"/>
        <constructor>
          <param name="props"
                 type="System.Collections.Specialized.NameValueCollection"
                 typeConverter="NameValueCollectionTypeConverter, AssemblyName"
                 value="null" />
        </constructor>
      </register>
      <register type="Quartz.IScheduler, Quartz"
                mapTo="DefaultScheduler, AssemblyName">
        <lifetime type="singleton"/>
      </register>
    </container>
  </unity>

DefaultScheduler.cs

using System;
using System.Collections.Generic;

using Quartz;
using Quartz.Impl.Matchers;
using Quartz.Spi;

public sealed class DefaultScheduler : IScheduler
{
    private readonly IScheduler scheduler;

    private DefaultScheduler()
    {
    }

    public DefaultScheduler(ISchedulerFactory schedulerFactory)
    {
        this.scheduler = schedulerFactory.GetScheduler();
    }

    public bool IsJobGroupPaused(string groupName)
    {
        return this.scheduler.IsJobGroupPaused(groupName);
    }

    public bool IsTriggerGroupPaused(string groupName)
    {
        return this.scheduler.IsTriggerGroupPaused(groupName);
    }

    public SchedulerMetaData GetMetaData()
    {
        return this.scheduler.GetMetaData();
    }

    public IList<IJobExecutionContext> GetCurrentlyExecutingJobs()
    {
        return this.scheduler.GetCurrentlyExecutingJobs();
    }

    public IList<string> GetJobGroupNames()
    {
        return this.scheduler.GetJobGroupNames();
    }

    public IList<string> GetTriggerGroupNames()
    {
        return this.scheduler.GetTriggerGroupNames();
    }

    public Quartz.Collection.ISet<string> GetPausedTriggerGroups()
    {
        return this.scheduler.GetPausedTriggerGroups();
    }

    public void Start()
    {
        this.scheduler.Start();
    }

    public void StartDelayed(TimeSpan delay)
    {
        this.scheduler.StartDelayed(delay);
    }

    public void Standby()
    {
        this.scheduler.Standby();
    }

    public void Shutdown()
    {
        this.scheduler.Shutdown();
    }

    public void Shutdown(bool waitForJobsToComplete)
    {
        this.scheduler.Shutdown(waitForJobsToComplete);
    }

    public DateTimeOffset ScheduleJob(IJobDetail jobDetail, ITrigger trigger)
    {
        return this.scheduler.ScheduleJob(jobDetail, trigger);
    }

    public DateTimeOffset ScheduleJob(ITrigger trigger)
    {
        return this.scheduler.ScheduleJob(trigger);
    }

    public void ScheduleJobs(
        IDictionary<IJobDetail, Quartz.Collection.ISet<ITrigger>> triggersAndJobs,
        bool replace)
    {
        this.scheduler.ScheduleJobs(triggersAndJobs, replace);
    }

    public void ScheduleJob(IJobDetail jobDetail, Quartz.Collection.ISet<ITrigger> triggersForJob, bool replace)
    {
        this.scheduler.ScheduleJob(jobDetail, triggersForJob, replace);
    }

    public bool UnscheduleJob(TriggerKey triggerKey)
    {
        return this.scheduler.UnscheduleJob(triggerKey);
    }

    public bool UnscheduleJobs(IList<TriggerKey> triggerKeys)
    {
        return this.scheduler.UnscheduleJobs(triggerKeys);
    }

    public DateTimeOffset? RescheduleJob(TriggerKey triggerKey, ITrigger newTrigger)
    {
        return this.scheduler.RescheduleJob(triggerKey, newTrigger);
    }

    public void AddJob(IJobDetail jobDetail, bool replace)
    {
        this.scheduler.AddJob(jobDetail, replace);
    }

    public void AddJob(IJobDetail jobDetail, bool replace, bool storeNonDurableWhileAwaitingScheduling)
    {
        this.scheduler.AddJob(jobDetail, replace, storeNonDurableWhileAwaitingScheduling);
    }

    public bool DeleteJob(JobKey jobKey)
    {
        return this.scheduler.DeleteJob(jobKey);
    }

    public bool DeleteJobs(IList<JobKey> jobKeys)
    {
        return this.scheduler.DeleteJobs(jobKeys);
    }

    public void TriggerJob(JobKey jobKey)
    {
        this.scheduler.TriggerJob(jobKey);
    }

    public void TriggerJob(JobKey jobKey, JobDataMap data)
    {
        this.scheduler.TriggerJob(jobKey, data);
    }

    public void PauseJob(JobKey jobKey)
    {
        this.scheduler.PauseJob(jobKey);
    }

    public void PauseJobs(GroupMatcher<JobKey> matcher)
    {
        this.scheduler.PauseJobs(matcher);
    }

    public void PauseTrigger(TriggerKey triggerKey)
    {
        this.scheduler.PauseTrigger(triggerKey);
    }

    public void PauseTriggers(GroupMatcher<TriggerKey> matcher)
    {
        this.scheduler.PauseTriggers(matcher);
    }

    public void ResumeJob(JobKey jobKey)
    {
        this.scheduler.ResumeJob(jobKey);
    }

    public void ResumeJobs(GroupMatcher<JobKey> matcher)
    {
        this.scheduler.ResumeJobs(matcher);
    }

    public void ResumeTrigger(TriggerKey triggerKey)
    {
        this.scheduler.ResumeTrigger(triggerKey);
    }

    public void ResumeTriggers(GroupMatcher<TriggerKey> matcher)
    {
        this.scheduler.ResumeTriggers(matcher);
    }

    public void PauseAll()
    {
        this.scheduler.PauseAll();
    }

    public void ResumeAll()
    {
        this.scheduler.ResumeAll();
    }

    public Quartz.Collection.ISet<JobKey> GetJobKeys(GroupMatcher<JobKey> matcher)
    {
        return this.scheduler.GetJobKeys(matcher);
    }

    public IList<ITrigger> GetTriggersOfJob(JobKey jobKey)
    {
        return this.scheduler.GetTriggersOfJob(jobKey);
    }

    public Quartz.Collection.ISet<TriggerKey> GetTriggerKeys(GroupMatcher<TriggerKey> matcher)
    {
        return this.scheduler.GetTriggerKeys(matcher);
    }

    public IJobDetail GetJobDetail(JobKey jobKey)
    {
        return this.scheduler.GetJobDetail(jobKey);
    }

    public ITrigger GetTrigger(TriggerKey triggerKey)
    {
        return this.scheduler.GetTrigger(triggerKey);
    }

    public TriggerState GetTriggerState(TriggerKey triggerKey)
    {
        return this.scheduler.GetTriggerState(triggerKey);
    }

    public void AddCalendar(string calName, ICalendar calendar, bool replace, bool updateTriggers)
    {
        this.scheduler.AddCalendar(calName, calendar, replace, updateTriggers);
    }

    public bool DeleteCalendar(string calName)
    {
        return this.scheduler.DeleteCalendar(calName);
    }

    public ICalendar GetCalendar(string calName)
    {
        return this.scheduler.GetCalendar(calName);
    }

    public IList<string> GetCalendarNames()
    {
        return this.scheduler.GetCalendarNames();
    }

    public bool Interrupt(JobKey jobKey)
    {
        return this.scheduler.Interrupt(jobKey);
    }

    public bool Interrupt(string fireInstanceId)
    {
        return this.scheduler.Interrupt(fireInstanceId);
    }

    public bool CheckExists(JobKey jobKey)
    {
        return this.scheduler.CheckExists(jobKey);
    }

    public bool CheckExists(TriggerKey triggerKey)
    {
        return this.scheduler.CheckExists(triggerKey);
    }

    public void Clear()
    {
        this.scheduler.Clear();
    }

    public string SchedulerName
    {
        get
        {
            return this.scheduler.SchedulerName;
        }
    }

    public string SchedulerInstanceId
    {
        get
        {
            return this.scheduler.SchedulerInstanceId;
        }
    }

    public SchedulerContext Context
    {
        get
        {
            return this.scheduler.Context;
        }
    }

    public bool InStandbyMode
    {
        get
        {
            return this.scheduler.InStandbyMode;
        }
    }

    public bool IsShutdown
    {
        get
        {
            return this.scheduler.IsShutdown;
        }
    }

    public IJobFactory JobFactory
    {
        set
        {
            this.scheduler.JobFactory = value;
        }
    }

    public IListenerManager ListenerManager
    {
        get
        {
            return this.scheduler.ListenerManager;
        }
    }

    public bool IsStarted
    {
        get
        {
            return this.scheduler.IsStarted;
        }
    }
}

NameValueCollectionTypeConverter.cs

using System.ComponentModel;
using System.Collections.Specialized;
using System.Globalization;

public sealed class NameValueCollectionTypeConverter : TypeConverter
{
    public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
    {
        return new NameValueCollection();
    }
}

Mam nadzieję że komuś się to przyda
Pozdrawiam,
mr-owl