Dependencies of a module

Question

I'm learning AutoFac. I like the idea of modules. From my understanding, I could for example create a module that registers some part of my application dependencies to the container to create some abstraction above it. However, I don't really know what to do in situations where I have multiple modules.

1. First thing is, should I create a seperate LoggerModule just to do this:

   builder.RegisterType<'MyLogger>().As<'ILogger>();

Or should it be put drectly in composition root? The question comes from my confusion if it's a good idea to register modules (higher abstraction) and services (lower abstraction) on the same level of composition root. Should modules be created only for services that use many dependencies, to make the registration simpler on the composition root level?

2. Another thing: What about my other modules that register services that require ILogger? Should I just assume that ILogger is already registered and just c.Resolve<'ILogger>() or should I register it again so that every module has all needed dependencies registered?

3. Can I create a module that registers other modules?

I tried to look for answers to these, but I found only topics that were close, but not really about my issue.

Answer 1

Think of modules as vehicles for configuration, not as components of your application. They exist to setup the container with the components your application will depend upon. With this in mind:

1. Sure. There's no reason why a module shouldn't exist for a single purpose (such as to configure logging in the container). Oftentimes, however, logging is such a fundamental service that it's usually "built-in" at the root (or shell) of the application.
2. Other components should just assume that logging is available and that it's someone else's responsibility to configure it. This is the essence of dependency injection - if the required services are not available your app can't run.
3. This is technically possible, but I wouldn't do it. Try to think of modules as being self-contained and not directly dependent on each other. It's possible in complex applications that the order in which modules are loaded at startup is important, but I consider that an implementation detail that shouldn't affect architectural abstractions.