17

我正在尝试让 Quartz.net (2.1.2) 与 IoC 容器 (autofac) 一起使用，因为我有需要在计划作业中使用的服务。我在这个主题上找到了类似的帖子，但我似乎无法找到一个带有 autofac 特定注册示例的帖子。

以下帖子涉及我遇到的相同问题：

如何使用 Quartz.net 2.0 安排任务？

但是，我认为我缺少的部分是当答案说“并且不要忘记在 IoC 容器中注册作业”时。我不确定如何准确地做到这一点，因为到目前为止我所尝试的一切都没有奏效。

在以下示例中，“HelloJob”将运行，但每当我尝试将 releaseService 注入“ReleaseJob”时，它都会拒绝运行。

更新： 我在 DependencyRegistration.cs 部分中标记了我认为问题所在的代码。

更新2： 一些与我需要做的事情相关的相关链接可能会有所帮助（我已经完成了所有这些但仍然无法弄清楚如何使用autofac）：

如何以 PRO 方式使用 Quartz.NET？ - http://blog.goyello.com/2009/09/21/how-to-use-quartz-net-in-pro-way/

Autofac 和 Quartz.NET - http://blog.humann.info/post/2013/01/30/Autofac-and-QuartzNET.aspx

使用 Quartz.NET 和 Simple Injector 进行构造函数注入 -使用 Quartz.NET 和 Simple Injector进行构造函数注入

ASP.Net MVC 3、Ninject 和 Quartz.Net - 如何？ - ASP.Net MVC 3、Ninject 和 Quartz.Net - 如何？

以下是相关代码：

全球.asax

    protected void Application_Start()
    {
        AreaRegistration.RegisterAllAreas();

        RegisterGlobalFilters(GlobalFilters.Filters);
        RegisterRoutes(RouteTable.Routes);

        var dependencyRegistration = new DependencyRegistration();
        dependencyRegistration.Register();

        ModelValidatorProviders.Providers.Clear();
        ModelValidatorProviders.Providers.Add(new FluentValidationModelValidatorProvider(new ValidatorFactory()));

        DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;
    }

依赖注册.cs

public class DependencyRegistration
{
    public void Register()
    {
        var builder = new ContainerBuilder();

        builder.RegisterControllers(Assembly.GetExecutingAssembly());
        builder.RegisterAssemblyModules(Assembly.GetExecutingAssembly());

        // Validation
        builder.RegisterType<ValidatorFactory>()
            .As<IValidatorFactory>()
            .InstancePerHttpRequest();

        AssemblyScanner findValidatorsInAssembly = AssemblyScanner.FindValidatorsInAssembly(Assembly.GetExecutingAssembly());
        foreach (AssemblyScanner.AssemblyScanResult item in findValidatorsInAssembly)
        {
            builder.RegisterType(item.ValidatorType)
                .As(item.InterfaceType)
                .InstancePerHttpRequest();
        }

        // Schedule
        builder.Register(x => new StdSchedulerFactory().GetScheduler()).As<IScheduler>();

        // Schedule jobs
        builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly()).Where(x => typeof(IJob).IsAssignableFrom(x));

        var container = builder.Build();
        DependencyResolver.SetResolver(new AutofacDependencyResolver(container));

        //Schedule
        IScheduler sched = container.Resolve<IScheduler>();
        sched.JobFactory = new AutofacJobFactory(container);
        sched.Start();

        IJobDetail job = JobBuilder.Create<ReleaseJob>()
                .WithIdentity("1Job")
                .Build();

        ITrigger trigger = TriggerBuilder.Create()
            .WithIdentity("1JobTrigger")
            .WithSimpleSchedule(x => x
                .RepeatForever()
                .WithIntervalInSeconds(5)
            )
            .StartNow()
            .Build();

        sched.ScheduleJob(job, trigger);

        job = JobBuilder.Create<HelloJob>()
               .WithIdentity("2Job")
               .Build();

        trigger = TriggerBuilder.Create()
            .WithIdentity("2JobTrigger")
            .WithSimpleSchedule(x => x
                .RepeatForever()
                .WithIntervalInSeconds(5)
            )
            .StartNow()
            .Build();

        sched.ScheduleJob(job, trigger);
    }
}

作业工厂.cs

public class AutofacJobFactory : IJobFactory
{
    private readonly IContainer _container;

    public AutofacJobFactory(IContainer container)
    {
        _container = container;
    }

    public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler)
    {
        return (IJob)_container.Resolve(bundle.JobDetail.JobType);
    }

    public void ReturnJob(IJob job)
    {
    }
}

ReleaseJob.cs

public class ReleaseJob : IJob
{
    private readonly IReleaseService _releaseService;

    public ReleaseJob(IReleaseService releaseService)
    {
        this._releaseService = releaseService;
    }

    public void Execute(IJobExecutionContext context)
    {
        Debug.WriteLine("Release running at " + DateTime.Now.ToString());
    }
}

public class HelloJob : IJob
{
    public void Execute(IJobExecutionContext context)
    {
        Debug.WriteLine("Hello job at " + DateTime.Now.ToString());
    }
}

发布服务模型.cs

public class ReleaseServiceModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<ReleaseService>()
            .As<IReleaseService>()
            .InstancePerLifetimeScope();
    }
}
4

2 回答 2

6

我终于找到了问题所在。

我的发布服务使用的是在不同范围内创建的数据存储库。

我通过创建一个新的测试服务发现了这一点，该服务只返回一个字符串，并且注入到石英作业中。

发现这一点后，我更改了发布服务调用的存储库的范围，然后发布服务开始在石英作业中工作。

我向任何看到这个问题试图帮助我的人道歉。因为没有列出发布服务的代码，所以很难弄清楚哪里出了问题。

我已经用我用于石英和 autofac 的最终工作绑定更新了代码。

于 2013-06-10T22:39:41.917 回答
0

问题是您的 AutofacJobFactory 没有创建ReleaseJob（您正在这样做JobBuilder.Create<ReleaseJob>()），因此 IoC 容器不知道它的实例化意味着无法发生依赖注入。

以下代码应该可以工作：

sched = schedFact.GetScheduler();
sched.JobFactory = new AutofacJobFactory(container);
sched.Start();

// construct job info
JobDetailImpl jobDetail = new JobDetailImpl("1Job", null, typeof(ReleaseJob ));

ITrigger trigger = TriggerBuilder.Create()
    .WithIdentity("1JobTrigger")
    .WithSimpleSchedule(x => x
        .RepeatForever()
        .WithIntervalInSeconds(5)
    )
    .StartNow()
    .Build();

sched.ScheduleJob(jobDetail, trigger);

请注意，在此示例中，我们不再使用JobBuilder.Create<ReleaseJob>()，而是通过对象传递要创建的作业的详细信息，JobDetailImpl并且通过这样做，调度程序的 jobfactory (the AutofacJobFactory) 负责实例化作业并且可以发生依赖注入。

于 2013-06-04T03:56:15.990 回答