具有多个 DBContext 的存储库还是每个具有 DBContext 的多个存储库？

Question

I am creating a web API with a resource and its sub-resources. Because the API will be hosted on multiple servers with varying database schemas (which I cannot change), I needed to create different implementations of the DBContext and create some logic in Startup.cs that handles context binding based on a property in appsettings.json . Some of the servers store the resource data on different databases, which means I have to use multiple DBContext for those servers' implementations.

The question arises how should I structure the repositories and contexts in a way that minimizes code duplication while also keeping code bloat down?

Should I create a single repository for the resource and its sub-resources that holds multiple contexts? If so, how do I ensure my app instantiates and binds these multiple contexts to a respository?

Should I create a separate repository for each resource with each holding its corresponding context?

Am I using the wrong pattern here or misusing the pattern?

Answer 1

Most importantly, you must have defined abstractions for working with data. These are interfaces. A lot of small interfaces that follow the principles of SOLID.

For example:

interface IUser
{
    User GetById(int id);
    void Save(User user);
}

Moreover, you can go further and break this interface into even smaller ones:

interface IGetUser
{
    User GetById(int id);
}

interface ISaveUser
{
    void Save(User user);
}

This is instead of one huge IRepository interface, with dozens and hundreds of methods.

Then you use these interfaces in your code without much thinking about how they are implemented.

Now you can use a mini-repository like this in one place:

class FirstUserRepository : IUser
{
    private FirstContext _context;

    // here constructor

    public User GetById(int id)
    {
        return _context.Users.FirstOrDefault(u => u.Id == id);
    }
    // ...
}

And such in another place:

class SecondUserRepository : IUser
{
    private SecondContext _context;
    //...
}

Accordingly, the necessary context implementations are created, linked to different databases.

// Connect to a one database
class FirstContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Customer> Customers { get; set; }
}

// Connect to an another database
class SecondContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Product> Products { get; set; }
}

And so on.