Using Entity Framework Core to process Azure Service Messages in ASP.NET Core

This article shows how to use Entity Framework Core together with an Azure Service Bus receiver in ASP.NET Core. This message handler is a singleton and so requires that an Entity Framework Core context inside this singleton is not registered as a scoped service but created and disposed for each message event.


Posts in this series:


2021-05-18 Updated .NET, Azure Service Bus SDK

Processing the Azure Service Bus Messages

The ProcessData class is used to handle the messages in the ASP.NET Core application. The service uses an Entity Framework Core context to save the required data to a database.

using AspNetCoreServiceBusApi2.Model;
using Microsoft.Extensions.Configuration;
using ServiceBusMessaging;
using System;
using System.Threading.Tasks;

namespace AspNetCoreServiceBusApi2
    public class ProcessData : IProcessData
        private IConfiguration _configuration;

        public ProcessData(IConfiguration configuration)
            _configuration = configuration;
        public async Task Process(MyPayload myPayload)
            using (var payloadMessageContext = 
                new PayloadMessageContext(
                await payloadMessageContext.AddAsync(new Payload
                    Name = myPayload.Name,
                    Goals = myPayload.Goals,
                    Created = DateTime.UtcNow

                await payloadMessageContext.SaveChangesAsync();

The services used to consume the Azure Service Bus are registered to the IoC (Inversion of Control) as singletons. Due to this, only singletons or transient services can be used. If we use the context as a singleton, we will end up having connection and pooling problems with the database.

services.AddSingleton<IServiceBusConsumer, ServiceBusConsumer>(); services.AddSingleton<IServiceBusTopicSubscription, ServiceBusTopicSubscription>(); services.AddSingleton<IProcessData, ProcessData>();

A PayloadMessageContext Entity Framework Core context was created for the Azure Service Bus message handling.

using Microsoft.EntityFrameworkCore;

namespace AspNetCoreServiceBusApi2.Model
    public class PayloadMessageContext : DbContext
        private string _connectionString;

        public DbSet<Payload> Payloads { get; set; }

        public PayloadMessageContext(string connectionString)
            _connectionString = connectionString;

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)

        protected override void OnModelCreating(ModelBuilder builder)
            builder.Entity<Payload>().Property(n => n.Id).ValueGeneratedOnAdd();
            builder.Entity<Payload>().HasKey(m => m.Id); 

The required NuGet packages were added to the project. This demo uses SQLite. Microsoft.EntityFrameworkCore.Sqlite

The service is then added in the Startup class as a singleton. The Entity Framework Core context used for the messaging is not registered here, because it is used inside the singleton instance and we do not want a context which is a singleton, because it will have problems with the database connections, and pooling. Instead a new context is created inside the service for each message event and disposed after. If you have a lot of messages, this would need to be optimized.

Now when the ASP.NET Core application receives messages, the singleton service context handles this messages, and saves the data to a database.


Azure Service Bus Topologies

Always subscribe to Dead-lettered messages when using an Azure Service Bus

One comment

  1. Rob Martin · · Reply

    RE: “If you have a lot of messages, this would need to be optimized”, could you please suggest a strategy.

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

%d bloggers like this: