使用Azure WebJobs SDK进行依赖注入？

Question

问题在于Azure WebJobs SDK只支持公共静态方法作为作业入口点，这意味着无法实现构造函数/属性注入。

我在官方WebJobs SDK文档/资源中找不到有关此主题的任何内容。我遇到的唯一解决方案是基于本文描述的服务定位器（anti）模式。

对于基于Azure WebJobs SDK的项目，有没有一种好方法可以使用“适当的”依赖项注入？

Answer 1

在问了我自己关于如何处理范围界定的问题后...我刚刚想出了这个解决方案：我不认为这是理想的，但我暂时找不到任何其他解决方案。

在我的示例中，我处理的是ServiceBusTrigger。

当我使用SimpleInjector时，IJobActivator接口的实现如下所示：

public class SimpleInjectorJobActivator : IJobActivator
{
    private readonly Container _container;

    public SimpleInjectorJobActivator(Container container)
    {
        _container = container;
    }

    public T CreateInstance<T>()
    {
        return (T)_container.GetInstance(typeof(T));
    }
}

在这里，我正在处理触发的webjobs。

因此，我有两个依赖项：

>

public interface ISingletonDependency { }

public class SingletonDependency : ISingletonDependency { }

另一个只需要在我的功能被触发时才有效：

public class ScopedDependency : IScopedDependency, IDisposable
{
    public void Dispose()
    {
         //Dispose what need to be disposed...
    }
}

因此，为了有一个独立于webjob运行的进程。我已将我的流程封装到一个类中：

public interface IBrokeredMessageProcessor
{
    Task ProcessAsync(BrokeredMessage incommingMessage, CancellationToken token);
}

public class BrokeredMessageProcessor : IBrokeredMessageProcessor
{
    private readonly ISingletonDependency _singletonDependency;
    private readonly IScopedDependency _scopedDependency;

    public BrokeredMessageProcessor(ISingletonDependency singletonDependency, IScopedDependency scopedDependency)
    {
        _singletonDependency = singletonDependency;
        _scopedDependency = scopedDependency;
    }

    public async Task ProcessAsync(BrokeredMessage incommingMessage, CancellationToken token)
    {
        ...
    }
}

因此，现在当webjob启动时，我需要根据依赖项的作用域注册它们：

class Program
{
    private static void Main()
    {
        var container = new Container();
        container.Options.DefaultScopedLifestyle = new ExecutionContextScopeLifestyle();
        container.RegisterSingleton<ISingletonDependency, SingletonDependency>();
        container.Register<IScopedDependency, ScopedDependency>(Lifestyle.Scoped);
        container.Register<IBrokeredMessageProcessor, BrokeredMessageProcessor>(Lifestyle.Scoped);
        container.Verify();

        var config = new JobHostConfiguration
        {
            JobActivator = new SimpleInjectorJobActivator(container)
        };

        var servicebusConfig = new ServiceBusConfiguration
        {
            ConnectionString = CloudConfigurationManager.GetSetting("MyServiceBusConnectionString")
        };

        config.UseServiceBus(servicebusConfig);
        var host = new JobHost(config);
        host.RunAndBlock();
    }
}

这是触发的作业：

>

只有一个依赖项：IoC容器。因为这个类是我作文根的一部分，所以应该可以。

它将作用域处理到触发函数中。

public class TriggeredJob
{
    private readonly Container _container;

    public TriggeredJob(Container container)
    {
        _container = container;
    }

    public async Task TriggeredFunction([ServiceBusTrigger("queueName")] BrokeredMessage message, CancellationToken token)
    {
        using (var scope = _container.BeginExecutionContextScope())
        {
            var processor = _container.GetInstance<IBrokeredMessageProcessor>();
            await processor.ProcessAsync(message, token);
        }
    }
}

Answer 2

这就是我使用新SDK处理范围的方式。如Alexander Molenkamp所述，使用IJobActivator。

public class ScopedMessagingProvider : MessagingProvider
{
    private readonly ServiceBusConfiguration _config;
    private readonly Container _container;

    public ScopedMessagingProvider(ServiceBusConfiguration config, Container container)
        : base(config)
    {
        _config = config;
        _container = container;
    }

    public override MessageProcessor CreateMessageProcessor(string entityPath)
    {
        return new CustomMessageProcessor(_config.MessageOptions, _container);
    }

    private class CustomMessageProcessor : MessageProcessor
    {
        private readonly Container _container;

        public CustomMessageProcessor(OnMessageOptions messageOptions, Container container)
            : base(messageOptions)
        {
            _container = container;
        }

        public override Task<bool> BeginProcessingMessageAsync(BrokeredMessage message, CancellationToken cancellationToken)
        {
            _container.BeginExecutionContextScope();
            return base.BeginProcessingMessageAsync(message, cancellationToken);

        }

        public override Task CompleteProcessingMessageAsync(BrokeredMessage message, FunctionResult result, CancellationToken cancellationToken)
        {
            var scope = _container.GetCurrentExecutionContextScope();
            if (scope != null)
            {
                scope.Dispose();
            }

            return base.CompleteProcessingMessageAsync(message, result, cancellationToken);
        }
    }
}

您可以在JobHost配置中使用自定义MessagingProvider，如

var serviceBusConfig = new ServiceBusConfiguration
{ 
    ConnectionString = config.ServiceBusConnectionString
};
serviceBusConfig.MessagingProvider = new ScopedMessagingProvider(serviceBusConfig, container);
jobHostConfig.UseServiceBus(serviceBusConfig);

Answer 3

Azure WebJobs SDK现在支持实例方法。将其与自定义IJobActivator相结合，可以使用DI。

首先，创建可以使用您喜爱的DI容器解析作业类型的自定义IJobActivator：

public class MyActivator : IJobActivator
{
    private readonly IUnityContainer _container;

    public MyActivator(IUnityContainer container)
    {
        _container = container;
    }

    public T CreateInstance<T>()
    {
        return _container.Resolve<T>();
    }
}

您需要使用自定义JobHostConfiguration注册此类：

var config = new JobHostConfiguration
{
    JobActivator = new MyActivator(myContainer)
};
var host = new JobHost(config);

然后，您可以为您的作业使用一个带有实例方法的简单类（这里我使用Unity的构造函数注入特性）：

public class MyFunctions
{
    private readonly ISomeDependency _dependency;

    public MyFunctions(ISomeDependency dependency)
    {
        _dependency = dependency;
    }

    public Task DoStuffAsync([QueueTrigger("queue")] string message)
    {
        Console.WriteLine("Injected dependency: {0}", _dependency);

        return Task.FromResult(true);
    }
}