Hangfire-afhankelijkheidsinjectie met .NET Core

Hoe kan ik de standaard afhankelijkheidsinjectie van .NET Core gebruiken in Hangfire?

Ik ben nieuw bij Hangfire en ben op zoek naar een voorbeeld dat werkt met ASP.NET Core.

Antwoord 1, autoriteit 100%

Bekijk het volledige voorbeeld op GitHub https://github.com/gonzigonz/HangfireCore-Example.

Live-site op http://hangfirecore.azurewebsites.net/

1. Zorg ervoor dat je de Core-versie van Hangfire hebt:
   dotnet add package Hangfire.AspNetCore

2. Configureer uw IoC door een JobActivatorte definiëren. Hieronder vindt u de configuratie voor gebruik met de standaard asp.net core-containerservice:

   public class HangfireActivator : Hangfire.JobActivator
   {
       private readonly IServiceProvider _serviceProvider;
       public HangfireActivator(IServiceProvider serviceProvider)
       {
           _serviceProvider = serviceProvider;
       }
       public override object ActivateJob(Type type)
       {
           return _serviceProvider.GetService(type);
       }
   }  
   

3. Registreer vervolgens hangfire als een service in de Startup.ConfigureServices-methode:

   services.AddHangfire(opt => 
       opt.UseSqlServerStorage("Your Hangfire Connection string"));
   

4. Configureer hangfire met de methode Startup.Configure. In relatie tot uw vraag is de sleutelhet configureren van hangfire om de nieuwe HangfireActivatorte gebruiken die we zojuist hierboven hebben gedefinieerd. Om dit te doen, moet je hangfire voorzien van de IServiceProvideren dit kan worden bereikt door het gewoon toe te voegen aan de lijst met parameters voor de methode Configure. Tijdens runtime zal DI deze service voor u leveren:

   public void Configure(
       IApplicationBuilder app, 
       IHostingEnvironment env, 
       ILoggerFactory loggerFactory,
       IServiceProvider serviceProvider)
   {
       ...
       // Configure hangfire to use the new JobActivator we defined.
       GlobalConfiguration.Configuration
           .UseActivator(new HangfireActivator(serviceProvider));
       // The rest of the hangfire config as usual.
       app.UseHangfireServer();
       app.UseHangfireDashboard();
   }  
   

5. Wanneer u een taak in de wachtrij plaatst, gebruik dan het geregistreerde type dat gewoonlijk uw interface is. Gebruik geen concreet type tenzij u het op die manier hebt geregistreerd. Je moet het type gebruiken dat bij je IoC is geregistreerd, anders kan Hangfire het niet vinden.
   Bijvoorbeeldstel dat u de volgende services heeft geregistreerd:

   services.AddScoped<DbManager>();
   services.AddScoped<IMyService, MyService>();
   

Dan zou je DbManagerin de wachtrij kunnen zetten met een geïnstantieerde versie van de klasse:

   BackgroundJob.Enqueue(() => dbManager.DoSomething());

U kunt echter niet hetzelfde doen met MyService. In de wachtrij plaatsen met een geïnstantieerde versie zou mislukken omdat DI zou mislukken omdat alleen de interface is geregistreerd. In dit geval zou je als volgt in de wachtrij staan:

   BackgroundJob.Enqueue<IMyService>( ms => ms.DoSomething());

Antwoord 2, autoriteit 44%

Het antwoord van DoritoBandito is onvolledig of verouderd.

public class EmailSender {
     public EmailSender(IDbContext dbContext, IEmailService emailService)
     {
         _dbContext = dbContext;
         _emailService = emailService;
     }
}

Services registreren:

services.AddTransient<IDbContext, TestDbContext>();
services.AddTransient<IEmailService, EmailService>();

In wachtrij:

BackgroundJob.Enqueue<EmailSender>(x => x.Send(13, "Hello!"));

Bron:
http://docs.hangfire.io/en/latest/background -methods/passing-dependencies.html

Antwoord 3, autoriteit 20%

Voor zover ik weet, kunt u .net cores-afhankelijkheidsinjectie op dezelfde manier gebruiken als voor elke andere service.

U kunt een service gebruiken die de uit te voeren taken bevat, die zo kunnen worden uitgevoerd

var jobId = BackgroundJob.Enqueue(x => x.SomeTask(passParamIfYouWish));

Hier is een voorbeeld van de Job Service-klasse

public class JobService : IJobService
{
    private IClientService _clientService;
    private INodeServices _nodeServices;
    //Constructor
    public JobService(IClientService clientService, INodeServices nodeServices)
    {
        _clientService = clientService;
        _nodeServices = nodeServices;
    }
    //Some task to execute
    public async Task SomeTask(Guid subject)
    {
        // Do some job here
        Client client = _clientService.FindUserBySubject(subject);
    }      
}

En in uw projecten Startup.cs kunt u zoals gewoonlijk een afhankelijkheid toevoegen

services.AddTransient< IClientService, ClientService>();

Ik weet niet zeker of dit je vraag beantwoordt of niet

Antwoord 4, autoriteit 20%

Alle antwoorden in deze thread zijn fout/onvolledig/verouderd. Hier is een voorbeeld met ASP.NET Core 3.1 en Hangfire.AspnetCore 1.7.

Klant:

//...
using Hangfire;
// ...
public class Startup
{
    // ...
    public void ConfigureServices(IServiceCollection services)
    {
        //...
        services.AddHangfire(config =>
        {
            // configure hangfire per your requirements
        });
    }
}
public class SomeController : ControllerBase
{
    private readonly IBackgroundJobClient _backgroundJobClient;
    public SomeController(IBackgroundJobClient backgroundJobClient)
    {
        _backgroundJobClient = backgroundJobClient;
    }
    [HttpPost("some-route")]
    public IActionResult Schedule([FromBody] SomeModel model)
    {
        _backgroundJobClient.Schedule<SomeClass>(s => s.Execute(model));
    }
}

Server (dezelfde of andere toepassing):

{
    //...
    services.AddScoped<ISomeDependency, SomeDependency>();
    services.AddHangfire(hangfireConfiguration =>
    {
        // configure hangfire with the same backing storage as your client
    });
    services.AddHangfireServer();
}
public interface ISomeDependency { }
public class SomeDependency : ISomeDependency { }
public class SomeClass
{
    private readonly ISomeDependency _someDependency;
    public SomeClass(ISomeDependency someDependency)
    {
        _someDependency = someDependency;
    }
    // the function scheduled in SomeController
    public void Execute(SomeModel someModel)
    {
    }
}

Antwoord 5, autoriteit 3%

Momenteel is Hangfire diep geïntegreerd met Asp.Net Core. Installeer Hangfire.AspNetCorenaar stel het dashboarden DI-integratie automatisch in. Vervolgens hoeft u alleen uw afhankelijkheden te definiëren met behulp van de ASP.NET-kern zoals altijd.