Hangfire

https://docs.hangfire.io/en/latest
Admin
Hangfire is a .NET library that enables reliable background job processing with support for...
Tokens:89,210
Snippets:937
Trust Score:9.8
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install EntityFramework package

Source: https://docs.hangfire.io/en/latest/_sources/tutorials/highlight.rst.txt

Installs the Entity Framework package via the Package Manager Console.

```powershell
Install-Package EntityFramework
```

--------------------------------

### Install Windows Service with installutil

Source: https://docs.hangfire.io/en/latest/background-processing/processing-jobs-in-windows-service.html

Use installutil to install the built Windows Service executable. If it fails, check the Windows Event Viewer for recent exceptions.

```powershell
installutil <yourproject>.exe
```

--------------------------------

### Hangfire full usage example in C#

Source: https://docs.hangfire.io/en/latest/getting-started/index.html

A complete Hangfire sample that configures global storage, enqueues a background job, and starts a server. Comment out the server lines to run the program multiple times; background jobs will be processed when the server lines are uncommented.

```csharp
using System;
using Hangfire;
using Hangfire.SqlServer;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main()
        {
            GlobalConfiguration.Configuration
                .SetDataCompatibilityLevel(CompatibilityLevel.Version_180)
                .UseColouredConsoleLogProvider()
                .UseSimpleAssemblyNameTypeSerializer()
                .UseRecommendedSerializerSettings()
                .UseSqlServerStorage("Database=Hangfire.Sample; Integrated Security=True;");

            BackgroundJob.Enqueue(() => Console.WriteLine("Hello, world!"));

            using (var server = new BackgroundJobServer())
            {
                Console.ReadLine();
            }
        }
    }
}

```

--------------------------------

### Install Microsoft.Net.Http package

Source: https://docs.hangfire.io/en/latest/tutorials/highlight.html

Install the Microsoft.Net.Http package to enable HTTP requests to the hilite.me API.

```powershell
Install-Package Microsoft.Net.Http

```

--------------------------------

### Create and start a Hangfire Server in a Windows Service

Source: https://docs.hangfire.io/en/latest/_sources/background-processing/processing-jobs-in-windows-service.rst.txt

Shows how to create a Hangfire Server instance inside a Windows Service. The example uses the Hangfire and Hangfire.SqlServer namespaces, configures SQL Server storage with a connection string, and declares a BackgroundJobServer field. The service constructor initializes the component and configures SQL Server storage.

```csharp
using System.ServiceProcess;
using Hangfire;
using Hangfire.SqlServer;

namespace WindowsService1
{
    public partial class Service1 : ServiceBase
    {
        private BackgroundJobServer _server;

        public Service1()
        {
            InitializeComponent();

            GlobalConfiguration.Configuration.UseSqlServerStorage("connection_string");
        }
    }
}
```

--------------------------------

### Install MiniProfiler package

Source: https://docs.hangfire.io/en/latest/tutorials/highlight.html

Command to install the MiniProfiler NuGet package. Run this in the Package Manager Console to add profiling capabilities to the application.

```powershell
Install-Package MiniProfiler

```

--------------------------------

### Install Hangfire.Core package

Source: https://docs.hangfire.io/en/latest/_sources/background-processing/processing-jobs-in-windows-service.rst.txt

Use the Package Manager Console to install the Hangfire.Core package, which is required to start using Hangfire in a Windows Service.

```powershell
PM> Install-Package Hangfire.Core
```

--------------------------------

### Run the application with dotnet run

Source: https://docs.hangfire.io/en/latest/getting-started/aspnet-core-applications.html

Starts the ASP.NET Core application. After startup, Hangfire SQL Server storage and background job server messages should appear.

```bash
dotnet run

```

--------------------------------

### HomeController with Index action

Source: https://docs.hangfire.io/en/latest/_sources/tutorials/highlight.rst.txt

The initial HomeController with an Index action that returns a view. This is the starting point for the tutorial's MVC application.

```csharp
public class HomeController : Controller
{
    public ActionResult Index()
    {
        return View();
    }
}
```

--------------------------------

### Install Postal.Mvc5 package

Source: https://docs.hangfire.io/en/latest/_sources/tutorials/send-email.rst.txt

Installs the Postal.Mvc5 NuGet package for sending email.

```powershell
Install-Package Postal.Mvc5
```

--------------------------------

### Install Hangfire packages with dotnet add package

Source: https://docs.hangfire.io/en/latest/getting-started/index.html

Installs the Hangfire.Core, Hangfire.SqlServer, and Microsoft.Data.SqlClient NuGet packages using the dotnet CLI.

```bash
dotnet add package Hangfire.Core
dotnet add package Hangfire.SqlServer
dotnet add package Microsoft.Data.SqlClient
```

--------------------------------

### Add System.Data.SqlClient PackageReference

Source: https://docs.hangfire.io/en/latest/_sources/configuration/using-sql-server.rst.txt

Adds the System.Data.SqlClient package to a .csproj file for compatibility reasons. Reference it explicitly to ensure SqlClientFactory points to it if Microsoft.Data.SqlClient is also installed.

```xml
<ItemGroup>
    <PackageReference Include="System.Data.SqlClient" Version="*" />
</ItemGroup>
```

--------------------------------

### Create a nested batch with BatchJob.StartNew

Source: https://docs.hangfire.io/en/latest/background-methods/using-batches.html

Starts a parent batch that enqueues a background job and starts a child batch. Use this when you need a batch to contain another batch alongside regular jobs.

```csharp
BatchJob.StartNew(parent =>
{
    parent.Enqueue(() => Console.WriteLine("First"));
    parent.StartNew(child => child.Enqueue(() => Console.WriteLine("Second")));
});

```

--------------------------------

### Define EmailSender class with dependencies

Source: https://docs.hangfire.io/en/latest/_sources/background-methods/passing-dependencies.rst.txt

Shows a class that uses DbContext and EmailService to send emails. This is the initial example before adding a default constructor.

```csharp
public class EmailSender
{
    public void Send(int userId, string message) 
    {
        var dbContext = new DbContext();
        var emailService = new EmailService();

        // Some processing logic
    }
}
```

--------------------------------

### Register ContainerJobActivator with GlobalConfiguration

Source: https://docs.hangfire.io/en/latest/_sources/background-methods/using-ioc-containers.rst.txt

Registers the custom activator in the bootstrap logic, for example in the Global.asax.cs file, before starting the Hangfire server. The example creates a container, configures the activator, and starts the server.

```c#
// Somewhere in bootstrap logic, for example in the Global.asax.cs file
var container = new Container();
GlobalConfiguration.Configuration.UseActivator(new ContainerJobActivator(container));
...
app.UseHangfireServer();
```

--------------------------------

### Configure Hangfire logging in Startup.cs

Source: https://docs.hangfire.io/en/latest/configuration/configuring-logging.html

Add Hangfire services in the ConfigureServices method of Startup.cs. This delegates logging to Microsoft.Extensions.Logging. The UseXXXStorage placeholder should be replaced with the actual storage configuration.

```csharp
public void ConfigureServices(IServiceCollection services)
{
    // ...
    services.AddHangfire(config => config.UseXXXStorage());
}

```

--------------------------------

### Initialize performance counters in OWIN Startup

Source: https://docs.hangfire.io/en/latest/deployment-to-production/performance-counters.html

Use this extension method in your OWIN Startup class to initialize the counters. Ensure the IIS/ASP.NET user is a member of the 'Performance Monitor Users' group.

```csharp
using Hangfire.PerformanceCounters;

public void Configure(IAppBuilder app)
{
    app.UseHangfirePerformanceCounters();
}
```

--------------------------------

### Register Hangfire services in ConfigureServices

Source: https://docs.hangfire.io/en/latest/_sources/getting-started/aspnet-core-applications.rst.txt

Registers Hangfire services and the processing server in Startup.cs. The configuration uses SQL Server storage with the HangfireConnection string and sets compatibility level to Version_180. Note: these settings are for new installations only; existing installations should consult upgrade guides.

```csharp
public void ConfigureServices(IServiceCollection services)
{
    // Add Hangfire services.
    services.AddHangfire(configuration => configuration
        .SetDataCompatibilityLevel(CompatibilityLevel.Version_180)
        .UseSimpleAssemblyNameTypeSerializer()
        .UseRecommendedSerializerSettings()
        .UseSqlServerStorage(Configuration.GetConnectionString("HangfireConnection")));

    // Add the processing server as IHostedService
    services.AddHangfireServer();

    // Add framework services. 
    services.AddMvc();
}
```

--------------------------------

### Enable MiniProfiler in Global.asax.cs

Source: https://docs.hangfire.io/en/latest/_sources/tutorials/highlight.rst.txt

Adds MiniProfiler start and stop calls to the Application_BeginRequest and Application_EndRequest events in the MVC application. Place this code in ~/Global.asax.cs after installing the package.

```csharp
// ~/Global.asax.cs

public class MvcApplication : HttpApplication
{
    /* ... */

    protected void Application_BeginRequest()
    {
        StackExchange.Profiling.MiniProfiler.Start();
    }

    protected void Application_EndRequest()
    {
        StackExchange.Profiling.MiniProfiler.Stop();
    }
}
```

--------------------------------

### Expected Hangfire startup messages

Source: https://docs.hangfire.io/en/latest/getting-started/aspnet-core-applications.html

Expected console output after the application starts and background processing begins. Shows SQL Server storage installation and Hangfire server options.

```text
info: Hangfire.SqlServer.SqlServerStorage[0]
    Start installing Hangfire SQL objects...
    Hangfire SQL objects installed.
    Using job storage: 'SQL Server: .\@AspNetCoreTest'
    Using the following options for SQL Server job storage:
        Queue poll interval: 00:00:15.
info: Hangfire.BackgroundJobServer[0]
    Starting Hangfire Server...
    Using the following options for Hangfire Server:
        Worker count: 20
        Listening queues: 'default'
        Shutdown timeout: 00:00:15
        Schedule polling interval: 00:00:15

```

--------------------------------

### OWIN Startup class with UseHangfireDashboard

Source: https://docs.hangfire.io/en/latest/configuration/using-dashboard.html

Create a Startup class in the root folder of your application and place this code to map the Hangfire Dashboard to the http://<your-app>/hangfire URL. Requires the Microsoft.Owin.Host.SystemWeb package for ASP.NET + IIS. By default, Dashboard access is allowed only for local requests.

```csharp
using Hangfire;
using Microsoft.Owin;
using Owin;

[assembly: OwinStartup(typeof(MyWebApplication.Startup))]

namespace MyWebApplication
{
    public class Startup
    {
        public void Configuration(IAppBuilder app)
        {
            // Map Dashboard to the `http://<your-app>/hangfire` URL.
            app.UseHangfireDashboard();
        }
    }
}

```

--------------------------------

### Recommended SqlServerStorageOptions for Hangfire 1.7

Source: https://docs.hangfire.io/en/latest/_sources/configuration/using-sql-server.rst.txt

Recommended options for new installations starting from Hangfire 1.7.0. These settings will be enabled by default in 2.0; DisableGlobalLocks requires migration to Schema 7.

```csharp
GlobalConfiguration.Configuration
    .UseSqlServerStorage("db_connection", new SqlServerStorageOptions
    {
        CommandBatchMaxTimeout = TimeSpan.FromMinutes(5),
        SlidingInvisibilityTimeout = TimeSpan.FromMinutes(5),
        QueuePollInterval = TimeSpan.Zero,           
        UseRecommendedIsolationLevel = true,
        DisableGlobalLocks = true // Migration to Schema 7 is required
    });
```

--------------------------------

### Import Hangfire namespaces in Startup.cs

Source: https://docs.hangfire.io/en/latest/_sources/getting-started/aspnet-core-applications.rst.txt

Add these using directives to Startup.cs to import the Hangfire namespaces.

```csharp
// ...
using Microsoft.Extensions.DependencyInjection;
using Hangfire;
using Hangfire.SqlServer;
```

--------------------------------

### Configure unique server name for multiple instances

Source: https://docs.hangfire.io/en/latest/_sources/background-processing/running-multiple-server-instances.rst.txt

Use this snippet to manually set a unique ServerName when running multiple Hangfire server instances in the same process. The example combines the machine name with a new GUID to ensure uniqueness. Both the BackgroundJobServer constructor and the UseHangfireServer extension method accept the same options object.

```csharp
var options = new BackgroundJobServerOptions
{
    ServerName = String.Format(
        "{0}.{1}",
        Environment.MachineName,
        Guid.NewGuid().ToString())
};

var server = new BackgroundJobServer(options);

// or

app.UseHangfireServer(options);
```

--------------------------------

### Install Hangfire.SqlServer package

Source: https://docs.hangfire.io/en/latest/_sources/background-processing/processing-jobs-in-windows-service.rst.txt

Install the SQL Server storage package for Hangfire. The command installs Hangfire.SqlServer so you can use SQL Server as job storage.

```powershell
PM> Install-Package Hangfire.SqlServer
```

--------------------------------

### Configure Multiple Dashboards for Different Storages

Source: https://docs.hangfire.io/en/latest/_sources/configuration/using-dashboard.rst.txt

Shows how to map multiple dashboards, each using a different storage instance, by passing the storage as the third argument to UseHangfireDashboard.

```csharp
var storage1 = new SqlServerStorage("Connection1");
var storage2 = new SqlServerStorage("Connection2");

app.UseHangfireDashboard("/hangfire1", new DashboardOptions(), storage1);
app.UseHangfireDashboard("/hangfire2", new DashboardOptions(), storage2);
```

--------------------------------

### Old way: enqueue jobs one by one with a for loop

Source: https://docs.hangfire.io/en/latest/_sources/background-methods/using-batches.rst.txt

Shows the old approach of enqueuing 1000 background jobs individually with a for loop. If storage becomes unavailable partway through, some jobs may already be processed, causing duplicates on retry.

```csharp
for (var i = 0; i < 1000; i++)
{
    BackgroundJob.Enqueue(() => SendEmail(i));
    // What to do on exception?
}
```

--------------------------------

### Add and run a database migration with Add-Migration and Update-Database

Source: https://docs.hangfire.io/en/latest/_sources/tutorials/highlight.rst.txt

Run these commands in the Package Manager Console to create and apply a migration for the new CodeSnippet entity. The first command scaffolds the migration, and the second applies it to the database.

```powershell
Add-Migration AddCodeSnippet
Update-Database
```

--------------------------------

### Install NLog package via PowerShell

Source: https://docs.hangfire.io/en/latest/_sources/tutorials/send-email.rst.txt

Installs the NLog NuGet package (version 4.2.3) using the Package Manager Console.

```powershell
Install-Package NLog
```

--------------------------------

### Add a dynamic fixed window

Source: https://docs.hangfire.io/en/latest/background-processing/throttling.html

Creates a fixed window of one-hour length with a limit of 4 executions per tenant. With a single bucket, the window is fixed. Up to 1000 fixed windows are allowed.

```csharp
IThrottlingManager manager = new ThrottlingManager();

manager.AddOrUpdateDynamicWindow("newsletter", new DynamicWindowOptions(
    limit: 4,
    interval: TimeSpan.FromHours(1),
    buckets: 1));

```

--------------------------------

### Create background jobs with BackgroundJobClient

Source: https://docs.hangfire.io/en/latest/index.html

Shows how to instantiate BackgroundJobClient and enqueue a fire-and-forget job with Enqueue, or schedule a delayed job with Delay. Uses regular static or instance methods, so no special classes are required.

```csharp
var client = new BackgroundJobClient();

client.Enqueue(() => Console.WriteLine("Easy!"));
client.Delay(() => Console.WriteLine("Reliable!"), TimeSpan.FromDays(1));
```

--------------------------------

### Install Hangfire with Install-Package

Source: https://docs.hangfire.io/en/latest/_sources/tutorials/highlight.rst.txt

Installs the Hangfire package via the Package Manager Console. Run this command in the Package Manager Console window.

```powershell
Install-Package Hangfire
```

--------------------------------

### Using key prefixes with RedisStorageOptions

Source: https://docs.hangfire.io/en/latest/configuration/using-redis.html

Shows how to specify a unique prefix for each environment when using a shared Redis server. The example uses the default prefix 'hangfire:' and passes the database number 0 to UseRedisStorage.

```csharp
var options = new RedisStorageOptions
{
    Prefix = "hangfire:"; // default value
};

GlobalConfiguration.Configuration.UseRedisStorage("localhost", 0, options);

```

--------------------------------

### Place UseHangfireDashboard After Authentication Methods

Source: https://docs.hangfire.io/en/latest/configuration/using-dashboard.html

In the OWIN Startup class, place the UseHangfireDashboard method after other authentication methods. Otherwise authentication may not work.

```csharp
public void Configuration(IAppBuilder app)
{
    app.UseCookieAuthentication(...); // Authentication - first
    app.UseHangfireDashboard();       // Hangfire - last
}
```

--------------------------------

### Install Hangfire.Throttling via Install-Package command

Source: https://docs.hangfire.io/en/latest/background-processing/throttling.html

Installs the Hangfire.Throttling package using the Package Manager Console. Requires the private Hangfire.Ace NuGet feed to be registered.

```powershell
Install-Package Hangfire.Throttling

```

--------------------------------

### Configure Hangfire Dashboard in OWIN Startup

Source: https://docs.hangfire.io/en/latest/_sources/configuration/using-dashboard.rst.txt

Shows the typical OWIN startup configuration where authentication is set up first and the Hangfire dashboard is added last.

```csharp
public void Configuration(IAppBuilder app)
{            
    app.UseCookieAuthentication(...); // Authentication - first
    app.UseHangfireDashboard();       // Hangfire - last
}
```

--------------------------------

### Install Hangfire.Core package

Source: https://docs.hangfire.io/en/latest/background-processing/processing-jobs-in-console-app.html

Use the Package Manager Console to install the Hangfire.Core package into the console application. This is the first required package for using Hangfire in a console app.

```powershell
PM> Install-Package Hangfire.Core

```

--------------------------------

### Hangfire console sample: configure storage and enqueue background job

Source: https://docs.hangfire.io/en/latest/_sources/getting-started/index.rst.txt

Fully working sample that configures Hangfire with SQL Server storage and enqueues a background job printing "Hello, world!". Comment the server lines to run the program several times; all background jobs are processed once the server lines are uncommented.

```c#
using System;
using Hangfire;
using Hangfire.SqlServer;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main()
        {
            GlobalConfiguration.Configuration
                .SetDataCompatibilityLevel(CompatibilityLevel.Version_180)
                .UseColouredConsoleLogProvider()
                .UseSimpleAssemblyNameTypeSerializer()
                .UseRecommendedSerializerSettings()
                .UseSqlServerStorage("Database=Hangfire.Sample; Integrated Security=True;");

            BackgroundJob.Enqueue(() => Console.WriteLine(
```

```c#
Hello, world!
```

```csharp
Hello, world!
```

--------------------------------

### Implementing a custom logging adapter with ILog and ILogProvider in C#

Source: https://docs.hangfire.io/en/latest/_sources/configuration/configuring-logging.rst.txt

Use this snippet to create a custom logging adapter when your logging library is not supported out of the box. Implement ILog and ILogProvider, then register the resulting log provider in a global configuration instance. The Log method must handle a null messageFunc by probing the log level, and should include the exception parameter when writing messages.

```csharp
using Hangfire.Logging;

public class CustomLogger : ILog
{
    public string Name { get; set; }

    public bool Log(LogLevel logLevel, Func<string> messageFunc, Exception exception = null)
    {
        if (messageFunc == null)
        {
            // Before calling a method with an actual message, LogLib first probes
            // whether the corresponding log level is enabled by passing a `null`
            // messageFunc instance.
            return logLevel > LogLevel.Info;
        }

        // Writing a message somewhere, make sure you also include the exception parameter,
        // because it usually contain valuable information, but it can be `null` for regular
        // messages.
        Console.WriteLine(String.Format("{0}: {1} {2} {3}", logLevel, Name, messageFunc(), exception));

        // Telling LibLog the message was successfully logged.
        return true;
    }
}

public class CustomLogProvider : ILogProvider
{
    public ILog GetLogger(string name)
    {
        // Logger name usually contains the full name of a type that uses it,
        // e.g. "Hangfire.Server.RecurringJobScheduler".
        return new CustomLogger { Name = name }; // <1> Creating a logger instance for a given name. This method will be called once per type that uses it, so you can cache the loggers if needed. // <2> The name of the logger is usually the full name of the type that uses it, e.g. 
```

```csharp
   public class CustomLogProvider : ILogProvider
   {
       public ILog GetLogger(string name)
       {
           // Logger name usually contains the full name of a type that uses it,
           // e.g. "Hangfire.Server.RecurringJobScheduler".
           return new CustomLogger { Name = name };
       }
   }

   public class CustomLogProvider : ILogProvider
   {
       public ILog GetLogger(string name)
       {
           // Logger name usually contains the full name of a type that uses it,
           // e.g. "Hangfire.Server.RecurringJobScheduler".
           return new CustomLogger { Name = name };
       }
   }
```

--------------------------------

### Global.asax.cs with Application_Start and Application_End

Source: https://docs.hangfire.io/en/latest/deployment-to-production/making-aspnet-app-always-running.html

Starts Hangfire in Application_Start and stops it in Application_End. Important to call Stop and to start Hangfire in environments without auto-start (e.g., development machines).

```csharp
public class Global : HttpApplication
{
    protected void Application_Start(object sender, EventArgs e)
    {
        HangfireBootstrapper.Instance.Start();
    }

    protected void Application_End(object sender, EventArgs e)
    {
        HangfireBootstrapper.Instance.Stop();
    }
}

```

--------------------------------

### Install Hangfire.SqlServer via PackageReference

Source: https://docs.hangfire.io/en/latest/_sources/configuration/using-sql-server.rst.txt

Adds the Hangfire.SqlServer NuGet package to a .csproj file. This package is a dependency of the Hangfire bootstrapper package, so it is not needed separately if Hangfire is already installed.

```xml
<ItemGroup>
  <PackageReference Include="Hangfire.SqlServer" Version="1.8.*" />
</ItemGroup>
```

--------------------------------

### Attach a background job to an existing batch with BatchJob.Attach

Source: https://docs.hangfire.io/en/latest/background-methods/using-batches.html

Starts a batch and attaches a second background job to it. If the batch has already finished, attaching a job moves it back to the started state.

```csharp
var batchId = BatchJob.StartNew(batch => batch.Enqueue(() => Console.WriteLine("First")));
BatchJob.Attach(batchId, batch => batch.Enqueue(() => Console.WriteLine("Second")));
```

--------------------------------

### Configure Hangfire in Startup.cs

Source: https://docs.hangfire.io/en/latest/getting-started/aspnet-applications.html

Use this snippet in a modern ASP.NET application with a Startup.cs file. It configures Hangfire with SQL Server storage, starts the background server, and enables the dashboard. Note that dashboard authorization must be configured for remote access.

```csharp
// Startup.cs
using Hangfire;
using Hangfire.SqlServer;

public class Startup
{
    private IEnumerable<IDisposable> GetHangfireServers()
    {
        GlobalConfiguration.Configuration
            .SetDataCompatibilityLevel(CompatibilityLevel.Version_180)
            .UseSimpleAssemblyNameTypeSerializer()
            .UseRecommendedSerializerSettings()
            .UseSqlServerStorage("Server=.\\SQLEXPRESS; Database=HangfireTest; Integrated Security=True;");

        yield return new BackgroundJobServer();
    }

    public void Configuration(IAppBuilder app)
    {
        app.UseHangfireAspNet(GetHangfireServers);
        app.UseHangfireDashboard();

        // Let's also create a sample background job
        BackgroundJob.Enqueue(() => Debug.WriteLine("Hello world from Hangfire!"));

        // ...other configuration logic
    }
}

```

--------------------------------

### HangfireBootstrapper class implementing IRegisteredObject

Source: https://docs.hangfire.io/en/latest/deployment-to-production/making-aspnet-app-always-running.html

Ensures initialization logic runs exactly once even when both Application_Start and Preload are called. Registers with HostingEnvironment, configures SQL Server storage, and starts BackgroundJobServer.

```csharp
public class HangfireBootstrapper : IRegisteredObject
{
    public static readonly HangfireBootstrapper Instance = new HangfireBootstrapper();

    private readonly object _lockObject = new object();
    private bool _started;

    private BackgroundJobServer _backgroundJobServer;

    private HangfireBootstrapper()
    {
    }

    public void Start()
    {
        lock (_lockObject)
        {
            if (_started) return;
            _started = true;

            HostingEnvironment.RegisterObject(this);

            GlobalConfiguration.Configuration
                .UseSqlServerStorage("connection string");
                // Specify other options here

            _backgroundJobServer = new BackgroundJobServer();
        }
    }

    public void Stop()
    {
        lock (_lockObject)
        {
            if (_backgroundJobServer != null)
            {
                _backgroundJobServer.Dispose();
            }

            HostingEnvironment.UnregisterObject(this);
        }
    }

    void IRegisteredObject.Stop(bool immediate)
    {
        Stop();
    }
}

```

--------------------------------

### Start a nested batch with continuations

Source: https://docs.hangfire.io/en/latest/_sources/background-methods/using-batches.rst.txt

Starts a parent batch that contains nested batches. Use this when you need to create a hierarchy of batches where the parent batch can have child batches and background jobs.

```csharp
BatchJob.StartNew(parent =>
{
    var nested1 = parent.StartNew(nested =>
    {
        nested.Enqueue(() => Console.WriteLine("First"));
    });
});
```

--------------------------------

### Install Hangfire.Pro.Redis via NuGet Package Manager

Source: https://docs.hangfire.io/en/latest/configuration/using-redis.html

Use this command in the NuGet Package Manager Console to install the Hangfire.Pro.Redis package. Requires a configured private Hangfire Pro NuGet feed.

```powershell
PM> Install-Package Hangfire.Pro.Redis

```

--------------------------------

### Manual schema migration with SINGLE_USER and MULTI_USER

Source: https://docs.hangfire.io/en/latest/_sources/upgrade-guides/upgrading-to-hangfire-1.7.rst.txt

Wrap the DefaultInstall.sql or Install.sql migration script with these lines to reduce downtime during manual schema migration. This aborts all current transactions and prevents new ones until the upgrade completes, so perform it during off-hours.

```sql
ALTER DATABASE [HangfireDB] SET SINGLE_USER WITH ROLLBACK IMMEDIATE;

-- DefaultInstall.sql / Install.sql contents

ALTER DATABASE [HangfireDB] SET MULTI_USER;
```
Tokens:
Raw