ASP.NET Core Web API Logging from a Static Class

I found this question with answers useful, but I remembered I already have installed Serilog. Instead of implementing a custom static instance, I could use the default implementation from Serilog.

It comes with multiple nice logging features with multiple overloaded version.
Here are two examples:

using Serilog; ... Log.Error(myException, "my message"); Log.Warning("My message", myValue); 

Serilog.Log is a static instance that is ready when configured in Program.cs or Startup.cs.

You can use the static LoggerFactory instance with the following extension method which accepts a regular parameter of type Type, rather than a generic type parameter: CreateLogger(ILoggerFactory, Type)

i.e. loggerFactory.CreateLogger(typeof(T)) rather than loggerFactory.CreateLogger<T>()

Here is the combined answer of @JohnC & @Pekaaw,

LoggingFactory can be created from SeriLog logger to retain same the log configuration and it can be used for logging mechanism

(Microsoft.Extensions.Logging.LoggerFactory)Serilog.SerilogLoggerFactoryExtensions.AddSerilog(new Microsoft.Extensions.Logging.LoggerFactory(), Serilog.Log.Logger);

using Microsoft.Extensions.Logging; /// <summary> /// Shared logger /// </summary> internal static class ApplicationLogging { internal static ILoggerFactory LoggerFactory { get; set; } = (LoggerFactory)Serilog.SerilogLoggerFactoryExtensions.AddSerilog ( new LoggerFactory(), Serilog.Log.Logger ); internal static ILogger CreateLogger<T>() => LoggerFactory.CreateLogger<T>(); internal static ILogger CreateLogger (string categoryName) => LoggerFactory.CreateLogger(categoryName); } 

public static class YourClass { public static readonly ILogger _logger = ApplicationLogging.CreateLogger("YourClass"); public static void MyMethod(string param) { try { _logger.LogInformation($"Inside MyMethod { param }"); //Todo: my static code; } } } 

I've added a static member of ILoggerFactory in Startup class so it can be used in other classes.

public class Startup { internal static ILoggerFactory LogFactory { get; set; } … public void Configure(…, ILoggerFactory logFactory) { … LogFactory = logFactory; } } 

Then use it in the static class.

static class YourClass { private static ILogger<YourClass> Logger = Startup.LogFactory.CreateLogger<YourClass>(); … 

However, this code will result in a TypeInitializationException when the CreateLogger throws an exception, so you should try to do better. [1]

For .net core 7/.net7, I have prepared static logger class which has a initialization method to initialize an instance of static ILogger object from ILoggerFactory

public static class LogHelperService{ private static ILoggerFactory _loggerFactory; private static ILogger _logger; private static IHttpContextAccessor _httpContextAccessor; public static void Initialize(ILoggerFactory loggerFactory,IHttpContextAccessor httpContextAccessor) { _loggerFactory = loggerFactory; _logger = _loggerFactory.CreateLogger("LogHelperService"); _httpContextAccessor = httpContextAccessor; } public static void LogError( Exception exception, string message, params object[] args) { _logger.Log(LogLevel.Error, exception, message, args); } public static void LogError( string message, params object[] args) { _logger.Log(LogLevel.Error, message, args); } public static void LogInformation(string message, params object[] args) { _logger.Log(LogLevel.Information, message, args); } public static void LogInformation(Exception exception, string message, params object[] args) { _logger.Log(LogLevel.Information, exception, message, args); } } 

Then In Program.js, After the app object created from WebApplicationBuilder, I have called the Initialization function to create the static Logger

var app = builder.Build(); //initialize Static service with server resources LogHelperService.Initialize( app.Services.GetService<ILoggerFactory>() ,app.Services.GetService<IHttpContextAccessor>()); 

First of all, I agree with NightOwl888 answer.

But as an option (consider this as a workaround) you could inject ILogger dependency via method parameter => so a class that will call this static method should be responsible for providing a correct implementation of ILogger.

static class YourClass { public static void DoSomething(ILogger logger) { // do something // call log.Log(); } }