How can I connect to multiple databases from a Blazor .NET Core project?

Question

How do I connect to multiple database instances from a Blazor WebAssembly project, where I have also added the ASP.NET Core hosted?

My thought was to initiate the DBContexts into the `Startup.cs`` (from Blazor.Server Application which has a reference to Blazor.Client Application):

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<DatabaseContext>(options =>
            options.UseSqlite(
                "connection string holder ..."));
}

like this but I want to let the user choose in my View if they want to do a test run of the App where the SQLite database instance will be created. The regular run will be an instance to SQL Server database. How can I do this in the ConfigureServices method?

Right now I am building the DBContexts classes, are these effected too?

The controllers are not done yet, are ASP.NET Core MVC controllers the right choice?

Answer 1

You can implement that using 2 DB contexts, one interface and a service choosing the context from data sent in API requests:

DB context interface

public interface IDatabaseContext
{
// add all DbSet declaration here
}

db context

public class DatabaseContext : IDatabaseContext
{
// db context implementation
}

Test db context

public class TestDatabaseContext: DatabaseContext
{
// add your constructor
}

DbContext resolver service

public class DbContextResolver
{
    public bool IsTest { get; set; }

Server side DI setup

services.AddDbContext<DatabaseContext>(options =>
            options.UseSqlServer(
                "SqlServer connection string holder ..."))
        .AddDbContext<TestDatabaseContext>(options =>
            options.UseSqlite(
                "Sqlite connection string holder ..."))
        .AddScoped<DbContextResolver>())
        .AddScoped<IDatabaseContext>(p =>
        {
            var resolver = p.GetRequiredService<DbContextResolver>();
            if (resolver.IsTest)
            {
                retrun p.GetRequiredService<TestDatabaseContext>();
            }
            return p.GetRequiredService<DatabaseContext>();
        }));

Select the DB Context from request

public void Configure(IApplicationBuilder app)
{
     app.Use((context, next) =>
     {
          var resolver = context.RequestServices.GetRequiredService<DbContextResolver>();
          resolver.IsTest = context.Request.Query.ContainsKey("test"); // here the context is choosed by query string but you can choose to send an header instead
          return next();
     }
}

use the chosen DB context in controller or a service

public class MyController : Controller
{
     public MyController(IDatabaseContext context)
...
}

Answer 2

I haven't tried but you can try something like this-

In Blazor client Program.cs -

builder.Services.AddDatabaseStorage();

In Blazor server Startup.cs -

   public void ConfigureServices(IServiceCollection services)
    {
        services.AddDatabaseStorage();
    }

Create a static class and add all the DB storage interfaces and their implementations-

public static class StorageServiceCollections
{
    public static IServiceCollection AddDatabaseStorage(this IServiceCollection 
 services)
    {
  //you may also return DB service based on certain condition here. Like factory, singleton pattern.
        return services
            .AddSingleton<IDBStorageService, SQLStorageService>()
            .AddSingleton<IMongoDBStorageService, MongoStorageService>();
    }
}

Stablish DB connections and their implementation classes e.g. SQLStorageService, MongoStorageService Something like this -

  public MongoStorageService()
    {
        var client = new MongoClient("mongodb://localhost:23456");
        _mongoDatabase = client.GetDatabase("DB");
    }

Inject in razor components to call them -

@inject IDBStorageService dbStorage

Answer 3

Server side Blazor :

services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"));
services.AddDbContext<ApplicationDbContext>(options => options.UseFirebird(Configuration.GetConnectionString("FirebirdConnection"));

Then register your service:

services.AddSingleton<SalesService>();

where your service has a model you can return using any connection:

public Task<Sales[]> GetSalesRangeAsync(DateTime StartDate, DateTime EndDate)
{
    IDbConnection db = new FbConnection(Startup.FirebirdDatabase);
    
    // QUERY
    return Task.FromResult(Enumerable.Range(0, 1).Select(index => new Sales
    {
        // RESULTS
    }).ToArray());
}