How to implement a triggerless .NET Core Console App as a continuous Azure WebJob?

Question

All the code samples I've seen so far for Azure WebJobs rely on some kind of trigger (eg TimerTrigger or QueueTrigger ). I am looking specifically at WebJobs SDK 3.x , by the way.

So. For a triggerless WebJob (Windows Service-alike one), am I expected to use NoAutomaticTrigger and find a way to kickoff my "main" code manually?

Or should I resort to implementing and registering a class that implements the IHostedService interface? So far that's the approach I'm taking but it feels more of a hack than a recommended way. I have not even tried to deploy this code and only ran it on my local machine, so I am afraid that the publishing process will confirm my code is not suitable for Azure WebJobs in its current form.

---

EntryPoint.cs

This is how the application is being bootstrap when the process is starting.

using Microsoft.Azure.ServiceBus;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace AbcCorp.Jobs
{
    public static class Program
    {
        static async Task Main(string[] args)
        {
            var config = new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
                .AddJsonFile($"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json", false)
                .Build();

            var hostBuilder = new HostBuilder()
                .ConfigureWebJobs(builder => { builder.AddAzureStorageCoreServices(); })
                .ConfigureServices(serviceCollection =>
                {
                    ConfigureServices(serviceCollection, config);
                    serviceCollection.AddHostedService<ConsoleApplication>();
                });

            using (var host = hostBuilder.Build())
                await host.RunAsync();
        }

        private static IServiceCollection ConfigureServices(IServiceCollection services, IConfigurationRoot configuration)
        {
            services.AddTransient<ConsoleApplication>();
            // ... more DI registrations
            return services;
        }
    }
}

ConsoleApplication.cs

This would normally be implemented as a function with a trigger. The thing is, I want this code to only run once on the process startup. It will start listening on the service bus events using the regular Microsoft.Azure.ServiceBus SDK package.

using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Hosting;
using AbcCorp.Internal.Microsoft.Azure.ServiceBus;
using AbcCorp.Api.Messaging;

namespace AbcCorp.Jobs
{
    public sealed class ConsoleApplication: IHostedService
    {
        private readonly IReceiver<SubmissionNotification> _messageReceiver;
        private readonly MessageHandler _messageHandler;

        public ConsoleApplication(IReceiver<SubmissionNotification> messageReceiver, MessageHandler messageHandler)
        {
            _messageReceiver = messageReceiver;
            _messageHandler = messageHandler;
        }

        public Task StartAsync(CancellationToken cancellationToken)
        {
            _messageReceiver.StartListening(_messageHandler.HandleMessage, _messageHandler.HandleException);
            return Task.Delay(Timeout.Infinite);
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
            _messageReceiver.Dispose();
            return Task.CompletedTask;
        }
    }
}

Answer 1

I have some workers attached to service bus topics and what we do is the following (ServiceBusClient is a custom Class that contains our Subscription Client):

public override Task StartAsync(CancellationToken cancellationToken)
    {
        _serviceBusClient.RegisterOnMessageHandlerAndReceiveMessages(MessageReceivedAsync);

        _logger.LogDebug($"Started successfully the Import Client. Listening for messages...");
        return base.StartAsync(cancellationToken);
    }


        public void RegisterOnMessageHandlerAndReceiveMessages(Func<Message, CancellationToken, Task> ProcessMessagesAsync)
    {
        // Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
        var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
        {
            // Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
            // Set it according to how many messages the application wants to process in parallel.
            MaxConcurrentCalls = 1,

            // Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
            // False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
            AutoComplete = false
        };

        // Register the function that processes messages.
        SubscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
    }

And then you can use DI to instantiate your service bus client and inject on the constructor of your Worker class.

Here i have the initialization of the singleton instance of my custom class Service Bus Client

services.AddSingleton<IServiceBusClient, ServiceBusClient>((p) =>
                {

                    var diagnostics = p.GetService<EventHandling>();
                    var sbc = new ServiceBusClient(
                        programOptions.Endpoint,
                        programOptions.TopicName,
                        programOptions.Subscriber,
                        programOptions.SubscriberKey);

                    sbc.Exception += exception => diagnostics.HandleException(exception);

                    return sbc;
                });

Then on this custom class, i initialize my subscription client

public ServiceBusClient(
        string endpoint,
        string topicName,
        string subscriberName,
        string subscriberKey, ReceiveMode mode = ReceiveMode.PeekLock)
    {
        var connBuilder = new ServiceBusConnectionStringBuilder(endpoint, topicName, subscriberName, subscriberKey);
        var connectionString = connBuilder.GetNamespaceConnectionString();

        ConnectionString = connectionString;
        TopicName = topicName;
        SubscriptionName = topicName;

        SubscriptionClient = new SubscriptionClient(connectionString, topicName, subscriberName, mode);
    }

Answer 2

So you want a console application to run in a WebJob and listen to messages. You don't really care about WebJob magic like triggers, it's just a place to run your console app. I've done the exact same thing before.

I found the IHostedService abstraction to be very helpful, but I didn't like their SDK. I found it bloated and hard to use. I didn't want to take a large dependency in order use a large array of special magic Azure stuff, when all I wanted to do was run a console application in a WebJob for now, and maybe move it elsewhere later.

So I ended just deleting that dependency, stealing the Shutdown code from the SDK and writing my own Service Host. The result is on my Github Repo azure-webjob-host . Feel free to use it or raid it for ideas. I don't know, maybe if I did it again I'd have another attempt at getting the SDK to work, but I present this is a bit of an alternative to the SDK.

Basically I wrote an IServiceHost not too different from yours (except that StartAsync exited when stuff started instead of just hanging). Then I wrote my own service host, which is basically just a loop:

await _service.StartAsync(cancellationToken);
while (!token.IsCancellationRequested){await Task.Delay(1000);}
await _service.StopAsync(default);

Then I stole the WebJobsShutdownWatcher code from their repo .

Then I created an IServiceHost that started my message handler. (I was using Rabbit, which has nothing to do with triggers or azure stuff)

public class MessagingService : IHostedService, IDisposable
{
    public MessagingService(ConnectionSettings connectionSettings,
        AppSubscriberSettings subscriberSettings,
        MessageHandlerTypeMapping[] messageHandlerTypeMappings,
        ILogger<MessagingService> logger)
    {
        ....
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        cancellationToken.ThrowIfCancellationRequested();
        await Task.WhenAll(subscribers.Value.Select(s => s.StartSubscriptionAsync()));
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        ...
    }

    public void Dispose()
    {
        ...
    }
}

Then I put that all together into something like this:

IHostedService myService = new MyService();

using (var host = new ServiceHostBuilder().HostService(myService))
{
    await host.RunAsync(default);
}

Answer 3

You can check @george chen's answer from this post How to create service bus trigger webjob?

where instead of creating a receiver and registering a message handler, you can use the in built queue trigger and and write your message handler logic inside it.