Hangfire vs Nexus

Hangfire is a great library for background processing and there's a lot of similarities between Hangfire and Nexus. Nexus Functions was built with Hangfire as an inspiration and it's especially the Functions part of Nexus and Hangfire that have a lot of similarities.

Both Nexus Functions and Hangfire support persistence and scaling out to more than one processing server and are both very easy to setup to run some code in the background. Both have a built-in UI to visualize the background tasks, both have automatic retries, etc. Nexus has a slight edge over Hangfire in that Hangfire was created before Nexus and supports .NET Framework. Whereas Nexus is .NET Core only and follows the modern .NET patterns for configuration and initialization which makes it slightly easier to get started with.

Differences

What sets Hangfire and Nexus apart is that Hangfire uses continuations and batches for more advanced scenarios. For such cases Nexus offers background jobs and queues (eg virtual queues) instead to orchestrate complex data flows.

A batch in Hangfire corresponds to a queue in Nexus with a batch processing job. And a continuation in Hangfire corresponds to multiple queues in Nexus where a processing job for one enqueues to another as an effect of processing a message.

In Nexus a queue message is a core concept when you design your Nexus application. You design your data flows and background tasks around queue messages and the data they contain. In Hangfire a queue message is instead simply the arguments passed to your background task method. While that's technically quite similar since they're both serialized and stored in a database the difference has some effects on your application. With Hangfire you start with a service method that you want to call in the background. With Nexus you instead often start with what data a queue message contains and add processing of that data after the message has been created.

This means that Hangfire might be a better fit when you just want asynchronous and distributed background processing internally in your application and you don't really care about the data as its own entity, you just care about passing arguments to methods.

And Nexus becomes a better fit if you want other applications to enqueue messages to your queue since all queues automatically get API endpoints for that. Differentiating between the data and the processing of that data can also have benefits in larger application where those are different concerns that you don't want to mix. In Hangfire the piece of code that wants something to happen in the background is tightly coupled with the piece of code that will actually be called in the background. In Nexus the piece of code that enqueues a message for background processing doesn't even have to be in the same application as the piece of code that does the processing of that data.