[TickerQ](https://tickerq.net/) is a fast, reflection-free background task scheduler for .NET — built with source generators, EF Core integration, cron + time-based execution, and a real-time dashboard. You can integrate TickerQ with the ABP to use it instead of the [default background job manager](../background-jobs). In this way, you can use the same background job API for TickerQ and your code will be independent of TickerQ. If you like, you can directly use TickerQ's API, too.
> See the [background jobs document](../background-jobs) to learn how to use the background job system. This document only shows how to install and configure the TickerQ integration.
## Installation
It is suggested to use the [ABP CLI](../../../cli) to install this package.
### Using the ABP CLI
Open a command line window in the folder of the project (.csproj file) and type the following command:
````bash
abp add-package Volo.Abp.BackgroundJobs.TickerQ
````
> If you haven't done it yet, you first need to install the [ABP CLI](../../../cli). For other installation options, see [the package description page](https://abp.io/package-detail/Volo.Abp.BackgroundJobs.TickerQ).
### Manual Installation
If you want to manually install;
1. Add the [Volo.Abp.BackgroundJobs.TickerQ](https://www.nuget.org/packages/Volo.Abp.BackgroundJobs.TickerQ) NuGet package to your project:
[TickerQ](https://github.com/dotnetdevelopersdz/TickerQ) is a fast, reflection-free background task scheduler for .NET — built with source generators, EF Core integration, cron + time-based execution, and a real-time dashboard. You can integrate TickerQ with the ABP Framework to use it instead of the [default background worker manager](../background-workers).
The major advantages of TickerQ include:
- **Performance**: Reflection-free design with source generators for optimal performance
- **EF Core Integration**: Native support for Entity Framework Core for job persistence
- **Flexible Scheduling**: Support for both cron expressions and time-based execution
- **Real-time Dashboard**: Built-in dashboard for monitoring and managing background jobs
- **Modern .NET**: Built for modern .NET with async/await support throughout
[TickerQ](https://tickerq.net/) is a fast, reflection-free background task scheduler for .NET — built with source generators, EF Core integration, cron + time-based execution, and a real-time dashboard. You can integrate TickerQ with the ABP to use it instead of the [default background worker manager](../background-workers).
1. Add the [Volo.Abp.BackgroundWorkers.TickerQ](https://www.nuget.org/packages/Volo.Abp.BackgroundWorkers.TickerQ) NuGet package to your project:
@ -35,177 +28,16 @@ If you want to manually install:
````csharp
[DependsOn(
//...other dependencies
typeof(AbpBackgroundWorkersTickerQModule) //Add the new module dependency
)]
//...other dependencies
typeof(AbpBackgroundWorkersTickerQModule) //Add the new module dependency
)]
public class YourModule : AbpModule
{
}
````
> TickerQ background worker integration provides an adapter `TickerQPeriodicBackgroundWorkerAdapter` to automatically load any `PeriodicBackgroundWorkerBase` and `AsyncPeriodicBackgroundWorkerBase` derived classes as `ITickerQBackgroundWorker` instances. This allows you to easily switch over to use TickerQ as the background manager even if you have existing background workers that are based on the [default background workers implementation](../background-workers).
> TickerQ background worker integration provides an adapter `TickerQPeriodicBackgroundWorkerAdapter` to automatically load any `PeriodicBackgroundWorkerBase` and `AsyncPeriodicBackgroundWorkerBase` derived classes as `ITickerQBackgroundWorker` instances. This allows you to still to easily switch over to use TickerQ as the background manager even you have existing background workers that are based on the [default background workers implementation](../background-workers).
## Configuration
You need to configure TickerQ with your preferred storage provider. TickerQ supports various storage options including Entity Framework Core.
1. First, configure TickerQ in your module's `ConfigureServices` method:
````csharp
public override void ConfigureServices(ServiceConfigurationContext context)
{
var configuration = context.Services.GetConfiguration();
var hostingEnvironment = context.Services.GetHostingEnvironment();
* **MaxRetryAttempts** - Maximum number of retry attempts on failure (default is 3)
* **AutoRegister** - Whether to automatically register this worker (default is true)
> You can directly implement the `ITickerQBackgroundWorker` interface, but `TickerQBackgroundWorkerBase` provides useful properties like Logger and service access.
## Register Background Workers
TickerQ background workers are automatically registered if `AutoRegister` is `true` (default). However, you can also manually register them:
## Migrating from Other Background Worker Implementations
TickerQ integration provides adapters for existing background workers:
### From Default Background Workers
Existing `AsyncPeriodicBackgroundWorkerBase` and `PeriodicBackgroundWorkerBase` workers will automatically work with TickerQ through the adapter system. The adapter will convert timer periods to appropriate cron expressions.
### From Quartz or Hangfire
When migrating from Quartz or Hangfire, you can:
1. Keep existing workers unchanged (they'll work through adapters)
2. Gradually migrate to `TickerQBackgroundWorkerBase` for better performance and features
3. Use the native TickerQ features like source generator optimizations
## Dashboard Integration
TickerQ provides a real-time dashboard for monitoring background jobs. To enable the dashboard:
````csharp
public override void OnApplicationInitialization(ApplicationInitializationContext context)
{
var app = context.GetApplicationBuilder();
// ... others
// TODO: Add TickerQ dashboard integration when available
// app.UseTickerQDashboard("/tickerq");
app.UseConfiguredEndpoints();
}
````
## Advanced Features
### Source Generator Optimizations
TickerQ uses source generators to eliminate reflection and improve performance. When using TickerQ-specific features, your jobs will benefit from:
- Compile-time job registration
- Zero-allocation job execution
- Optimized serialization
### EF Core Integration
TickerQ provides native Entity Framework Core integration for job persistence:
````csharp
public class MyEfCoreWorker : TickerQBackgroundWorkerBase
maliming
4 months ago