James HickeyThe .NET Core CLI comes with tons of pre-built project templates! One of the new templates that will be included with .NET Core 3 will be for building worker services.
Combining .NET Core worker services with Coravel can help you build lightweight background job scheduling applications very quickly. Let's take a look at how you can do this in just a few minutes!
Note: Worker services are lightweight console applications that perform some type of background work like reading from a queue and processing work (like sending e-mails), performing some scheduled background jobs from our system, etc. These might be run as a daemon, windows service, etc.
Installing .NET Core 3 Preview
At the writing on this article, .NET Core 3 is in preview. First, you must install the SDK. You can use Visual Studio Code for everything else in this article 👍.
Coravel's Task Scheduling
Coravel is a .NET Core library that gives you advanced application features out-of-the-box with near-zero config. I was inspired by Laravel's ease of use and wanted to bring that simple and accessible approach of building web applications to .NET Core.
One of those features is a task scheduler that is configured 100% by code.
By leveraging Coravel's ease-of-use with the simplicity of .NET Core's worker service project template, I'll show you how easily and quickly you can build a small back-end console application that will run your scheduled background jobs!
Worker Service Template
First, create an empty folder to house your new project.
Then run:
dotnet new worker
Your worker project is all set to go! 🤜🤛
Check out Program.cs and you'll see this:
public static void Main(string[] args)
{
CreateHostBuilder(args).Build().Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices(services =>
{
services.AddHostedService<Worker>();
});
Configuring Coravel
Let's add Coravel by running dotnet add package coravel.
Next, in Program.cs, we'll modify the generic code that was generated for us and configure Coravel:
public static void Main(string[] args)
{
IHost host = CreateHostBuilder(args).Build();
host.Services.UseScheduler(scheduler => {
// We'll fill this in later ;)
});
host.Run();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices(services =>
{
services.AddScheduler();
});
};
Since Coravel is a native .NET Core set of tools, it just works™ with zero fuss!
Adding An Invocable
One of Coravel's fundamental concepts is Invocables.
Each invocable represents a self-contained job within your system that Coravel leverages to make your code much easier to write, compose and maintain.
Next, then, create a class that implements Coravel.Invocable.IInvocable:
public class MyFirstInvocable : IInvocable
{
public Task Invoke()
{
Console.WriteLine("This is my first invocable!");
return Task.CompletedTask;
}
}
Since we are going to simulate some async work, we'll just log a message to the console and then return Task.CompletedTask to the caller.
Scheduling Your Invocable
Here's where Coravel really shines 😉.
Let's schedule our new invocable to run every 5 seconds. Inside of our Program.cs main method we'll add:
host.Services.UseScheduler(scheduler => {
// Yes, it's this easy!
scheduler
.Schedule<MyFirstInvocable>()
.EveryFiveSeconds();
});
Don't forget to register your invocable with .NET Core's service container:
.ConfigureServices(services =>
{
services.AddScheduler();
// Add this 👇
services.AddTransient<MyFirstInvocable>();
});
In your terminal, run dotnet run.
You should see the output in your terminal every five seconds!
Real-World Invocable
Sure, writing to the console is great - but you are going to be making API calls, database queries, etc. after all.
Let's modify our invocable so that we can do something more interesting:
public class SendDailyReportEmailJob : IInvocable
{
private IMailer _mailer;
private IUserRepository _repo;
public SendDailyReportEmailJob(IMailer mailer, IUserRepository repo)
{
this._mailer = mailer;
this._repo = repo;
}
public async Task Invoke()
{
var users = await this._repo.GetUsersAsync();
foreach(var user in users)
{
var mailable = new DailyReportMailable(user);
await this._mailer.SendAsync(mailable);
}
}
}
Since this class will hook into .NET Core's service container, all the constructor dependencies will be injected via dependency injection.
If you wanted to build a lightweight background application that processes and emails daily reports for all your users then this might be a great option.
Configuring As A Windows Service
While beyond the scope of this article, you can take a look at how .NET Core 3 will allow configuring your worker as a windows service.
And, apparently, there's upcoming support for systemd too!
Conclusion
What do you guys think about .NET Core's worker services?
I find they are so easy to get up-and-running. Coupled with the accessibility designed into Coravel, I find these two make an awesome pair for doing some cool stuff!
All of Coravel's features can be used within these worker services - such as queuing tasks, event broadcasting, mailing, etc.
One thing I'd love to try is to integrate Coravel Pro with a worker service. One step at a time though 🤣.
Keep In Touch
Don't forget to connect with me on:
You can also find me at my web site www.jamesmichaelhickey.com.
Navigating Your Software Development Career Newsletter
An e-mail newsletter that will help you level-up in your career as a software developer! Ever wonder:
✔ What are the general stages of a software developer?
✔ How do I know which stage I'm at? How do I get to the next stage?
✔ What is a tech leader and how do I become one?
✔ Is there someone willing to walk with me and answer my questions?
Sound interesting? Join the community!
