Question

Hangfire看起来很漂亮。但是，我正在挑战Hangfire来激活正确的具体课程。

一些背景知识：

public interface IJob
{
    bool Execute(string payload);
}
public interface IJobPayload
{
    string UserId { get; set; }
    string JobName { get; set; }
    string JobQueueName { get; set; }
    int Id { get; set; }
    JobType JobType { get; set; }
    CronExpression Cron { get; set; }
}

现在，我（可能）有数百个所有从IJob继承的作业，并在继承自IJobPayload的有效负载上执行。如果不深入了解每个Job的执行代码，我会有类似的内容：

[Queue("critical")] class Job1 : IJob {...}
[Queue("doors")] class Job2 : IJob {...}
[Queue("doors")] class Job3 : IJob {...}
[Queue("lights")] class Job4 : IJob {...}
[Queue("lights")] class Job5 : IJob {...}
[Queue("adhoc")] class Job6 : IJob {...}
...
[Queue("critical")] class JobN : IJob {...}

提供基本工作的样本：

public class JobDoorStatusChanged : IJob
{
    [Queue("doors")]
    public bool Execute(string payload)
    {
        var command = JsonConvert.DeserializeObject<Payload>(payload);
        // handle execution here...
        return true/false;
    }

    public class Payload : IJobPayload
    {
        public string UserId { get; set; }
        public string JobName { get; set; }
        public string JobQueueName { get; set; }
        public int Id { get; set; }
        public JobType JobType { get; set; }
        public CronExpression Cron { get; set; }
    }
}

我有一个非常简单的Web API Post控制器：

[HttpPost]
public string Post()
{
    var payload = Request.Content.ReadAsStringAsync().Result;
    var queueHandler = new QueueHandler();
    return queueHandler.Load(payload);
}

下一步是我遇到失败的地方。他和我将成为最好的芽。不幸的是！

Hangfire有4个Enqueue方法（2个同步，2个异步）：

public static string Enqueue([NotNull, InstantHandle] Expression<Action> methodCall)
public static string Enqueue([NotNull, InstantHandle] Expression<Func<Task>> methodCall)
public static string Enqueue<T>([NotNull, InstantHandle] Expression<Action<T>> methodCall)
public static string Enqueue<T>([NotNull, InstantHandle] Expression<Func<T, Task>> methodCall)

他们要么采取静态类：

var id = BackgroundJob.Enqueue(() => MyStaticJob.Execute(payload));

或者他们采用一种应该可从Unity解析的类型：

var id = BackgroundJob.Enqueue<ConcreteJobDefinition>(a => a.Execute(payload));

由于我有几十个，甚至太多的对象都是基于IJob ，这些入口点都不适用于我。

我甚至尝试过单一课程来包装我的所有工作并让Hangfire执行单一课程，到目前为止，没有运气：

public interface IJobService
{
    bool Execute(string payload);
}
public class JobService : IJobService
{
    private readonly IUnityContainer _container = UnityConfig.GetConfiguredContainer();
    public bool Execute(string payload)
    {
        var command = JsonConvert.DeserializeObject<PayloadStub>(payload);
        var job = _container.Resolve<IJob>(command.JobName);
        return job.Execute(payload);
    }
    internal class PayloadStub : IJobPayload
    {
        public string UserId { get; set; }
        public string JobName { get; set; }
        public string JobQueueName { get; set; }
        public int Id { get; set; }
        public JobType JobType { get; set; }
        public CronExpression Cron { get; set; }
    }
}

现在我可以用这种方式执行一个具体的实现（谈论混淆！）：

var id = BackgroundJob.Enqueue<JobService>(a => a.Execute(payload));

仍然没有！，你从每一份工作中都失去了Queue Attribute！

所以，我回到我的startup.cs文件：

public partial class Startup
{
    public void Configuration(IAppBuilder app)
    {
        Framework.Initialize(); // internal framework here at work...
        AreaRegistration.RegisterAllAreas();
        GlobalConfiguration.Configure(WebApiConfig.Register);
        FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
        RouteConfig.RegisterRoutes(RouteTable.Routes);
        BundleConfig.RegisterBundles(BundleTable.Bundles);
        UnityConfig.RegisterUnity();           // <== UNITY ==
        ConfigureAuth(app);
        HangfireConfig.RegisterHangfire(app);  // <== HANGFIRE ==
    }
}

Class UnityConfig：

public class UnityConfig
{
    public static void RegisterUnity()
    {
        var container = Sol3.Web.WebApi.App_Start.UnityConfig.GetConfiguredContainer();

        // Register Auth & Exception handlers...
        container.RegisterType<IAccessDeniedResult, AccessDeniedResult>();
        container.RegisterType<IExceptionResult, ExceptionResult>();
        container.RegisterType<IJobService, JobService>();

        // Register all IJob concrete implementations found in this project...
        container.RegisterTypes(
            AllClasses.FromLoadedAssemblies().Where(type => typeof(IJob).IsAssignableFrom(type) && type.IsClass),
            WithMappings.FromAllInterfaces,
            t => t.IsNested ? t.DeclaringType.Name + "." + t.Name : t.Name,
            WithLifetime.Transient);
    }
}

班级HangfireConfig：

public class HangfireConfig
{
    public static void RegisterHangfire(IAppBuilder app)
    {
        GlobalConfiguration.Configuration.UseSqlServerStorage(Globals.DatabaseHangfire);
        GlobalJobFilters.Filters.Add(new LogAttribute());
        app.UseHangfireDashboard();
        var options = new BackgroundJobServerOptions
        {
            Queues = Globals.QueueNames,
            Activator = new UnityJobActivator(Sol3.Web.WebApi.App_Start.UnityConfig.GetConfiguredContainer()),
        };
        app.UseHangfireServer(options);

    }
}

我没有看到任何错误。 Unity拥有所有注册。由于我有很多基于单个接口的对象，我知道我正在打破Unity通常用于依赖注入的方式。

有什么想法？你可以看到对代码的任何调整吗？

TIA

Answer 1

看起来开发人员发现了一个错误并修复了它。我现在正在测试它，到目前为止，它看起来更有意义。

Hangfire Issue #656

我也发现了我的定义错误。我需要将执行从 bool 更改为 void 返回类型。

Answer 2

虽然核心概念略有不同，并且可能有更简洁的方法，但您可以尝试将Jobs注册为IEnumerable，然后根据名称选择您需要的那个。我有一个相关的问题，我希望根据传入的标准处理N个处理程序。我在其上写了in my blog。

this Stack Overflow answer

中有一个Unity示例

Answer 3

我遇到了类似的问题，并使用名为JobHandler<T>的通用包装器解决了这个问题。它的工作原理如下：

首先，基地JobHandler：

public abstract class JobHandler
{
    public abstract void Enqueue(string payload);
}

接下来，JobHandler<T>将使用Hangfire作为正确的具体类型进行排队：

public abstract class JobHandler<T> : JobHandler 
    where T: IJob
{
    public override void Enqueue(string payload)
    {
        BackgroundJob.Enqueue<T>(x => x.Execute(payload));
    }
}

JobHandler<T>不一定需要是抽象的，但在我的情况下，我有处理程序执行的其他逻辑，并为每个作业类型提供它的具体实现。然后，我的应用程序注册了每种类型的处理程序，我可以这样做：

JobHandler handler = Activator.CreateInstance(GetHandler("MyJobType")) as JobHandler;

handler.Enqueue(payload)

使用Unity解决JobHandler应该很容易做同样的事情。也就是说，我不确定这是否比简单地解析IJob并对实例进行排队提供了很多好处，因为导致问题的错误已得到修复。

如何将正确的具体类注入封闭的系统

3 个答案: