ASP.NET Core Web API and MongoDB with multiple Collections

I think, Retic's approach is not so bad.

Lets continue on his answer and extract the database configuration into a separate method ConfigureMongoDb:

public void ConfigureServices(IServiceCollection services)
{
    ConfigureMongoDb(services);

    services.AddControllers()
        .AddNewtonsoftJson(options => options.UseMemberCasing());
}

private void ConfigureMongoDb(IServiceCollection services)
{
    var settings = GetMongoDbSettings();
    var db = CreateMongoDatabase(settings);

    var collectionA = db.GetCollection<Author>(settings.AuthorsCollectionName);
    services.AddSingleton(collectionA);
    services.AddSingleton<AuthorService>();

    var collectionB = db.GetCollection<Book>(settings.BooksCollectionName);
    services.AddSingleton(collectionB);
    services.AddSingleton<BookService>();
}

private BookstoreDatabaseSettings GetMongoDbSettings() =>
    Configuration.GetSection(nameof(BookstoreDatabaseSettings)).Get<BookstoreDatabaseSettings>();

private IMongoDatabase CreateMongoDatabase(BookstoreDatabaseSettings settings)
{
    var client = new MongoClient(settings.ConnectionString);
    return client.GetDatabase(settings.DatabaseName);
}

or in a more compact form:

private void ConfigureMongoDb(IServiceCollection services)
{
    var settings = GetMongoDbSettings();
    var db = CreateMongoDatabase(settings);

    AddMongoDbService<AuthorService, Author>(settings.AuthorsCollectionName);
    AddMongoDbService<BookService, Book>(settings.BooksCollectionName);

    void AddMongoDbService<TService, TModel>(string collectionName)
    {
        services.AddSingleton(db.GetCollection<TModel>(collectionName));
        services.AddSingleton(typeof(TService));
    }
}

The downside with this approach is, that all mongodb related instances (except the services) are created at startup. This is not always bad, because in the case of wrong settings or other mistakes you get immediate response on startup.

If you want lazy initialization for this instances, you can register the database creation and the collection retrieval with a factory method:

public void ConfigureMongoDb(IServiceCollection services)
{
    var settings = GetMongoDbSettings();
    services.AddSingleton(_ => CreateMongoDatabase(settings));

    AddMongoDbService<AuthorService, Author>(settings.AuthorsCollectionName);
    AddMongoDbService<BookService, Book>(settings.BooksCollectionName);

    void AddMongoDbService<TService, TModel>(string collectionName)
    {
        services.AddSingleton(sp => sp.GetRequiredService<IMongoDatabase>().GetCollection<TModel>(collectionName));
        services.AddSingleton(typeof(TService));
    }
}

In the service you have to inject just the registered collection.

public class BookService
{
    private readonly IMongoCollection<Book> _books;

    public BookService(IMongoCollection<Book> books)
    {
        _books = books;
    }
}

public class AuthorService
{
    private readonly IMongoCollection<Author> _authors;

    public AuthorService(IMongoCollection<Author> authors)
    {
        _authors = authors;
    }
}

You can register a single Instance of the IMongoDatabase in your Services container. then you can add Singleton Collections to your services container using the IMongoDatabase Instance.

var client = new MongoClient(connectionString);
var db = client.GetDatabase(dbName);
 
var collectionA = db.GetCollection<Model>(collectionName);
services.AddSingleton<IMongoDatabase, db>();
services.AddSingleton<IMongoCollection, collectionA>();

to use these you would expose your services to your controllers via the controllers constructor.

public class SomeController
{
   private readonly IMongoCollection<SomeModel> _someCollection;

   public SomeController(IMongoCollection<SomeModel> someCollection)
   {
      _someCollection = someCollection;
   }
}

I am working on a project that will have multiple collection. I am not sure about how to structure the appSetting.json file:

"DatabaseSettings": {
"ConnectionString": "somestrings",
"DatabaseName": "somename",
"CollectionName": "One Collection"

}, is it fine to have to do an array of the collection name:

"DatabaseSettings": {
    "ConnectionString": "somestrings",
    "DatabaseName": "somename",
    "CollectionName": ["One Collection", "Second Collection" "Third Collection"]
  }, 

I register it as a singleton like this:

builder.Services.Configure<DatabaseSettings>(builder.Configuration.GetSection("DatabaseSettings"));

builder.Services.AddSingleton<IMongoDatabase>(sp => {
    
    var databaseSettings = sp.GetRequiredService<IOptions<DatabaseSettings>>().Value;
    var mongoDbClient = new MongoClient(databaseSettings.ConnectionString);
    var mongoDb = mongoDbClient.GetDatabase(databaseSettings.DatabaseName);

    return mongoDb;
});


builder.Services.AddScoped<IStudentRepository, StudentRepository>();

I get settings from appsettings.json like this:

{
  "DatabaseSettings": {
    "ConnectionString": "mongodb+srv://xwezi:[email protected]",
    "DatabaseName": "school"
  }
}

and I'm using in my repository like this:

public class StudentRepository : IStudentRepository
{
    private readonly DatabaseSettings databaseSettings;
    private readonly IMongoCollection<Student> students;

    public StudentRepository(
        IOptions<DatabaseSettings> databaseOptions,
        IMongoDatabase mongoDatabase)
    {
        databaseSettings = databaseOptions.Value;
        students = mongoDatabase.GetCollection<Student>("students");
    }

    public Student? GetStudent(string id)
    {
        return students?.Find(s => s.Id == id).FirstOrDefault();
    }

    public IList<Student>? GetStudents()
    {
        return students?.Find(s => true).ToList();
    }
}

I return just a mongo client when i register it and get the database later.. i don't see any reason why not to?

builder.Services.AddSingleton<IMongoClient>(options => {
    var settings = builder.Configuration.GetSection("MongoDBSettings").Get<MongoDBSettings>();
    var client = new MongoClient(settings.ConnectionString);
    return client;
});
builder.Services.AddSingleton<IvMyRepository, vMyRepository>();

Then i use like this:

    public vapmRepository(IMongoClient mongoClient)
    {
        IMongoDatabase mongoDatabase = mongoClient.GetDatabase("mdb01");
        _vprocesshealthCollection = mongoDatabase.GetCollection<vMsg>("vhealth");
    }

Now you have a MongoClient and can connect to any database(s) you want freely for any n collections