Skip to main content

Mastering Logging in .NET Core - A Comprehensive Guide to Using LoggerFactory and Microsoft.Extensions.Logging with C#

Discover the art of logging in .NET Core apps! This tutorial covers best practices, advanced techniques, and testing for effective monitoring and debugging.

Christian Schou

You know how essential a strong logging system is for hassle-free debugging and maintenance if you've ever found yourself sifting through mountains of logs to figure out what went wrong in your .NET Core application. Any well-structured software's foundation is logging, which offers useful insights into the behavior and health of the application.

In this tutorial, I will take you on a journey through the powerful world of logging in .NET Core. We'll explore how to leverage the LoggerFactory and Microsoft.Extensions.Logging to create an efficient and flexible logging setup that perfectly suits your application's needs.

No matter if you're a seasoned developer or just getting started with .NET Core, you can't afford to overlook learning about logging. With useful code examples along the way, we'll cover everything from the fundamentals of logging to advanced features. So fasten your seatbelt and let's begin!

Before we proceed, let's quickly highlight what we'll be covering in this tutorial.

  1. Logging Fundamentals in .NET Core: We'll lay the groundwork by discussing the importance of logging in application development, and why Microsoft.Extensions.Logging is a game-changer.
  2. Setting Up a .NET Core Logging Project: If you're starting from scratch or want to add logging to an existing project, we'll go through the setup process step-by-step.
  3. LoggerFactory and ILogger Interface: We'll demystify the magic behind LoggerFactory and delve into the ILogger interface, which will be your best friend for writing log messages.
  4. Configuring Logging Providers: There are various logging providers at your disposal, from simple console logging during development to more sophisticated options like logging to databases or external services.
  5. Logging Best Practices: We'll cover some best practices to ensure your logging remains effective, clean, and optimized.
  6. Adding Contextual Information to Logs: Learn how to supercharge your logs with additional context, making debugging a breeze.
  7. Handling Exceptions and Error Logging: Errors are unavoidable, but how you log and handle them can significantly impact your troubleshooting efforts.
  8. Logging in Production: We'll tackle logging considerations for production environments, where performance and efficiency are paramount.
  9. Advanced Logging Features: Take your logging skills to the next level with some advanced features provided by Microsoft.Extensions.Logging.
  10. Testing and Mocking Logging: Learn how to test your logging implementation and mock loggers for unit testing purposes.

Enough chit-chat; let's jump right in and get started with the logging magic in .NET Core!

Logging Fundamentals in .NET Core

Before we dive into the specifics of LoggerFactory and Microsoft.Extensions.Logging, I would like to take a moment to make sure that you understand the significance of logging in the world of software development.

Why is Logging Important?

As programmers, we write countless lines of code to create complex applications. We always run into problems and bugs both in development and in production. By effectively logging important data about an application's behavior during runtime, we can effectively analyze, debug, and troubleshoot problems.

Here are a few reasons why I think logging is crucial and what I use it for:

  • Debugging and Troubleshooting - Logs serve as a window into what's happening inside your application during debugging and troubleshooting. Logs offer vital information and context about errors or unexpected behavior when something goes wrong.
  • Monitoring Application Health - We can keep track of the health and functionality of our applications by logging significant metrics and events. This knowledge aids in proactively identifying potential problems or bottlenecks before they become more serious.
  • Auditing and Compliance - Auditing is essential for some applications, especially those that handle sensitive data. Logs can be used to track user activity and ensure legal compliance.
  • Performance analysis - Extensive logging can help you analyze the performance of different parts of your application and support your optimization efforts.

A quick primer to Microsoft.Extensions.Logging

Now that you understand why logging is crucial let's talk about Microsoft.Extensions.Logging, the logging framework provided by Microsoft for .NET Core applications. It is part of the .NET Core extensions and offers a robust and flexible logging infrastructure.

Microsoft.Extensions.Logging Namespace
Contains classes and abstractions for configuring ILogger.

Microsoft.Extensions.Logging is designed around a few key components, let's quickly go over them before we proceed.

  • LoggerFactory - The main element in charge of producing instances of the ILogger interface is the LoggerFactory. It serves as a logger factory and enables us to set up various logging providers.
  • ILogger Interface - To emit log messages, we use the ILogger interface in our application code. It offers different log levels, including Debug, Information, Warning, Error, and others, allowing us to distinguish between the seriousness of log messages. 👍
  • Logging Providers - Microsoft.Extensions.Logging supports various logging providers like Console, Debug, EventLog, TraceSource, and more. These providers handle where the log messages are written. Cool right?! 🔥

Log Levels

According to their severity, or log levels, log messages are categorized in Microsoft.Extensions.Logging. Each log level corresponds to a particular message severity. Common log levels include:

  • Debug - Detailed information, typically useful for debugging purposes.
  • Information - General information about the application's operation.
  • Warning - Indicates a potential issue or unexpected behavior that does not prevent the application from functioning.
  • Error - Indicates a significant problem or error that might require attention.
  • Critical - Indicates a critical error that might lead to the application's failure.

Each message will be given the proper log level as we write it in our code in order to denote its importance and severity at runtime.

In the section that follows, we'll create a .NET Core project and start implementing logging with LoggerFactory and ILogger. Let's get to the fun stuff and write some code! 🚀

Setting Up a .NET Core Logging Project

Now that we understand why logging is crucial and you have a grasp of Microsoft.Extensions.Logging, let's set up a .NET Core project to implement some logging.


Before we begin, ensure you have the following installed on your machine/computer.

  1. .NET Core SDK: Make sure you have the latest .NET Core SDK installed from the official .NET website ( Just download and install the latest version of .NET.

Creating a New .NET Core Project

Let's start by creating a new .NET Core project using the command-line interface (CLI). Open your terminal or command prompt and run the following commands in your console/terminal.