How to implement multiple Connection Strings for one DbContext in EF Core?

Time needed: 25 minutes

Essentially, you just need to have 2 Database Context classes inheriting your primary Context (in this case, ReadOnlyApplicationDbContext and ReadWriteApplicationDbContext are inheriting ApplicationDbContext)

1. using System;
using System.Linq;
...
 
namespace YourNamespace
{
    public class ApplicationDbContext : IdentityDbContext
    {
       
        protected ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }
 
        protected ApplicationDbContext(DbContextOptions options)
            : base(options)
        {
        }
 
        public DbSet<YourStuff> YourStuff { get; set; }
    }
 
    public class ReadWriteApplicationDbContext : ApplicationDbContext
    {
        internal ReadWriteApplicationDbContext(DbContextOptions options)
            : base(options)
        {
        }
 
        public ReadWriteApplicationDbContext(DbContextOptions<ReadWriteApplicationDbContext> options)
            : base(options)
        {
        }
    }
 
    public class ReadOnlyApplicationDbContext : ApplicationDbContext
    {
        internal ReadOnlyApplicationDbContext(DbContextOptions options)
            : base(options)
        {
 
        }
 
        public ReadOnlyApplicationDbContext(DbContextOptions<ReadOnlyApplicationDbContext> options)
            : base(options)
        {
        }
 
        // <summary>
        // This context cannot be used for saving. In production, this configuration is automatic (it connects to a read-only db), but in localhost it needs to be underlined like this.
        // </summary>
        public override int SaveChanges()
        {
            throw new Exception("This is a read-only context!");
        }
    }
}
   
   In this case, I’m using just one model, and one database, but two contexts – so I’m inheriting both of my contexts from my pre-existing database context (ApplicationDbContext) that actually has the entities in it.

2. Then, just inject two separate contexts to your application on startup – something like this in your Startup.cs file:

   namespace YourApp
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }
 
        public IConfiguration Configuration { get; }
 
        public void ConfigureServices(IServiceCollection services)
              {           
                             // Add the read-only connection as the default
                            services.AddDbContext<ReadOnlyApplicationDbContext>(options =>
                             {
                             options.UseSqlServer(Configuration.GetConnectionString("ReadOnlyConnection"));
              });
                                          
                             // And add the read-write connection to be used if need be
                            services.AddDbContext<ReadWriteApplicationDbContext>(options =>
              {
                 options.UseSqlServer(Configuration.GetConnectionString("ReadWriteConnection"));
                             });
 
                             // Rest of the implementation omitted for clarity ...
              }
    }
}
3. After creating the database context classes and configuring them in Startup, you’re ready to actually use them! Inject both of the contexts in your code.

   Below, I’m injecting both the ReadOnly and Read-Write -database contexts into the same controller.
   
   
   _{Injecting 2 DbContexts into the constructor of a Controller class in .NET Core / EF Core.}
   
   And then use them like… Well, like you’d use any DbContext, I suppose!
   

4. In case you want to initiate it in an Azure Function, it looks something like the below:

   
   
   _{How to initiate an Entity Framework Core Database Context in an Azure Function?}