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();
    }
}