Should I take ILogger, ILogger, ILoggerFactory or ILoggerProvider for a library?

by

Definition

We have 3 interfaces: ILogger, ILoggerProvider and ILoggerFactory. Let’s look at the source code to find out their responsibilities:

ILogger: is responsible to write a log message of a given Log Level.

ILoggerProvider: is responsible to create an instance of ILogger (you are not supposed to use ILoggerProvider directly to create a logger)

ILoggerFactory: you can register one or more ILoggerProviders with the factory, which in turn uses all of them to create an instance of ILogger. ILoggerFactory holds a collection of ILoggerProviders.

In the example below, we are registering 2 providers (console and file) with the factory. When we create a logger, the factory uses both of these providers to create an instance of Logger:

ILoggerFactory factory = new LoggerFactory().AddConsole();    // add console provider
factory.AddProvider(new LoggerFileProvider("c:\\log.txt"));   // add file provider
Logger logger = factory.CreateLogger(); // creates a console logger and a file logger

So the logger itself, is maintaining a collection of ILoggers, and it writes the log message to all of them. Looking at Logger source code we can confirm that Logger has an array of ILoggers (i.e. LoggerInformation[]), and at the same time it is implementing ILogger interface.

Dependency Injection

MS documentation provides 2 methods for injecting a logger:

1. Injecting the factory:

public TodoController(ITodoRepository todoRepository, ILoggerFactory logger)
{
    _todoRepository = todoRepository;
    _logger = logger.CreateLogger("TodoApi.Controllers.TodoController");
}

creates a Logger with Category = TodoApi.Controllers.TodoController.

2. Injecting a generic ILogger<T>:

public TodoController(ITodoRepository todoRepository, ILogger<TodoController> logger)
{
    _todoRepository = todoRepository;
    _logger = logger;
}

creates a logger with Category = fully qualified type name of TodoController

In my opinion, what makes the documentation confusing is that it does not mention anything about injecting a non-generic, ILogger. In the same example above, we are injecting a non-generic ITodoRepository and yet, it does not explain why we are not doing the same for ILogger.

According to Mark Seemann:

An Injection Constructor should do no more than receiving the
dependencies.

Injecting a factory into the Controller is not a good approach, because it is not Controller’s responsibility to initialize the Logger (violation of SRP). At the same time injecting a generic ILogger<T> adds unnecessary noise. See Simple Injector’s blog for more details: What’s wrong with the ASP.NET Core DI abstraction?

What should be injected (at least according to the article above) is a non-generic ILogger, but then, that’s not something that Microsoft’s Built-in DI Container can do, and you need to use a 3rd party DI Library. These two documents explain how you can use 3rd party libraries with .NET Core.

This is another article by Nikola Malovic, in which he explains his 5 laws of IoC.

Nikola’s 4th law of IoC

Every constructor of a class being resolved should not have any
implementation other than accepting a set of its own dependencies.

More Related Contents:

  1. What are the correct version numbers for C#?
  2. How can I find the method that called the current method?
  3. Does C# 8 support the .NET Framework?
  4. How to print the current Stack Trace in .NET without any exception?
  5. How should I inject a DbContext instance into an IHostedService?
  6. dotnet core System.Text.Json unescape unicode string
  7. Add client certificate to .NET Core HttpClient
  8. System.Text.Json: How do I specify a custom name for an enum value?
  9. Can you configure log4net in code instead of using a config file?
  10. Write to Windows Application Event Log without event source registration
  11. Is ConfigurationManager.AppSettings available in .NET Core 2.0?
  12. How to load assemblies located in a folder in .NET Core console app
  13. Auto Versioning in Visual Studio 2017 (.NET Core)
  14. Using Razor outside of MVC in .NET Core
  15. How do I do logging in C# without using 3rd party libraries? [closed]
  16. How performant is StackFrame?
  17. .NET Core and System.Drawing
  18. How to consume a Scoped service from a Singleton?
  19. Could not load file or assembly Microsoft.Extensions.DependencyInjection.Abstractions, Version=1.1.0.0
  20. Proper way to start and fire-and-forget asynchronous calls?
  21. .NET Core vs Mono
  22. How do I reference a .NET Framework project in a .NET Core project?
  23. How do you log the machine name via log4net?
  24. Can I get parameter names/values procedurally from the currently executing function?
  25. System.ServiceModel not found in .NET Core project
  26. Filter Serilog logs to different sinks depending on context source?
  27. Difference between .Net Core, Portable, Standard, Compact, UWP, and PCL?
  28. Using .net standard 1.5 lib in .net 4.6.2 misses System.Runtime 4.1.0.0
  29. Net Core: Execute All Dependency Injection in Xunit Test for AppService, Repository, etc
  30. HttpContext in .net standard library

Leave a Comment