The .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:

• Twitter
• LinkedIn

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!