CODEWITHSUNDEEP
c#.netmongodbcollections
EDZ III
EDZ III

Reputation: 33

How to handle multiple MongoDB Collections in an API for .net

I'm trying to make a backend for my .Net webApp using MongoDB for this purpose. I'm new to MongoDB and quite frankly I feel lost in all the documentation. Until now I've followed the Microsoft guide on how to make the first steps in building an "onedimensional" api. I could potentially build everything using only one collection, but I feel like this will quite hard to handle down the road. That's why I thought it would be wise to split everything into smaller collections. The API is written with C#. My code so far:

appsetting:

{
  "FantaTrainerDatabaseSettings": {
    //"UsersCollectionName": "Users",
    "FantaTrainerCollectionName": "Trainers",
    //"TeamsCollectionName": "Teams",
    "SoccerPlayersCollectionName": "SoccerPlayers",
    "ConnectionString": "mongodb://localhost:27017",
    "DatabaseName": "FantaTrainerDb"
  }
}

The Startup.cs file has this method where the Controllers are instanciated:

public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<FantaTrainerDatabaseSettings>(
        Configuration.GetSection(nameof(FantaTrainerDatabaseSettings)));
            services.AddSingleton<IFantaTrainerDatabaseSettings>(sp =>
                sp.GetRequiredService<IOptions<FantaTrainerDatabaseSettings>>().Value);
            services.AddSingleton<FantaTrainerService>();
            services.AddControllers();
        }

What I tried was

public void ConfigureServices(IServiceCollection services)
        {
            services.Configure<FantaTrainerDatabaseSettings>(
        Configuration.GetSection(nameof(FantaTrainerDatabaseSettings)));
            services.AddSingleton<IFantaTrainerDatabaseSettings>(sp =>
                sp.GetRequiredService<IOptions<FantaTrainerDatabaseSettings>>().Value);
            services.AddSingleton<FantaTrainerService>();

services.Configure<SoccerPlayersDatabaseSettings>(
        Configuration.GetSection(nameof(SoccerPlayersDatabaseSettings)));
            services.AddSingleton<ISoccerPlayersDatabaseSettings>(sp =>
                sp.GetRequiredService<IOptions<SoccerPlayersDatabaseSettings>>().Value);
            services.AddSingleton<SoccerPlayersService>();
            services.AddControllers();
        }

But as I supposed It doesn't work this way..

I'm not going to paste all the other code since it's more or less a copy-paste from the Microsoft guide, with renamed variables. But let me know if you need more details.

To make it short, I don't get where I need to put the reference to access the other collections. Do I need like a big controller class that handles all the controllers, or do I need to make the ConfigureServices() dynamic and figure out a way to handle the different collections? Is there a right way to do that?

Let me know if you need further details or maybe reformulate the question to make it clearer what the problem is.

Upvotes: 2

Views: 2282

Answers (1)

Dĵ ΝιΓΞΗΛψΚ
Dĵ ΝιΓΞΗΛψΚ

Reputation: 5679

data & collection modelling:

don't put everything in one collection. even though you can. it get's extremely difficult to query and update deeply nested entities as your app grows in complexity due to the c# mongodb driver having limitations on what it can do (without jumping through hoops).

i usually have one collection per logical entity. such as Book,Author,Publisher and have references between them when needed to define relationships. some may say that modelling your entities like a relational db beats the purpose of a nosql db but i don't agree with that becuase it helps with ease of development and maintaining your app in the longrun. you do lose a bit of performance doing lookups/joins but it won't be much worse than mysql/sql-server (with the proper use if indexes).

also keep in mind that mongodb has a hard limit on how big a single document can get, which is 16mb in size. so it would be a bad idea to embed millions of entities inside an array field of an entity. my personal rule of thumb is; if there's going to be more than a few hundred entities embeded in a field, store it in it's own collection. even if it's going to be less than a few hundred, something may get it's own collection if it's a complex (enough) entity.

sometimes, you'll be duplicating data to make queries fast. for ex: you could choose to embed a list of author names inside of the publisher entity. but that has the downside of you having to manually update that embeded list when there's a change to a name of one of the authors. the more places you duplicate in, the more work you have to do to keep data consistent.

in the end, it all really depends on how your app's views/ui/api is going be querying your data. when doing complex apps, you will have to choose the right balance of embedded vs. referenced.

app architecture & layering:

following microsoft tutorials is fine for just getting a lay of the land but they are just too basic when you need to figure out how to build complex systems.

my suggestion is to find some open source projects on github and study how people do things when building real-world apps. but choose wisely what you look at, because there's tendancy in the industry to over-engineer and over-complicate things due to trends/ hype of certain patterns, frameworks and technologies. a couple of such things would be: dependency injection, mocking, ddd, etc. i can suggest the following youtube videos if you'd like to cut through the crap and get to the heart of what really matters.

  1. Core Principles Of API Design
  2. Responsibilities Of a Controller
  3. Dependency Injection? No Thank you!
  4. Mocking? No Thank you!
  5. Interfaces? No Thank you!

you might also find this mongodb web-api starter template interesting where i try to simplify things as much as possible in order to increase ease of development, readability and maintainability.

Upvotes: 1

Related Questions