CA1848 High-performance logging in .NET Framework 4.8 and .NET 5.0+

namespace logging
{
    using Microsoft.Extensions.Logging;

    public class SimpleLogging
    {
        private readonly ILogger _logger;

        public SimpleLogging(ILogger logger)
        {
            _logger = logger;
        }

        public void ThingThatLogs()
        {
            string message = "I need to be logged";
            _logger.LogInformation("Something about {message} needs to be logged", message);
        }
    }
}

namespace logging
{
    using Microsoft.Extensions.Logging;
    using System;

    public class HighPerformanceLogging
    {
        private readonly Log _logger;

        public HighPerformanceLogging(ILogger logger)
        {
            _logger = new Log(logger);
        }

        public void ThingThatLogs()
        {
            _logger.LogMessage("I need to be logged", null);
        }

        /// <summary>
        /// Defines the possible EventId's by also tying them to a human-readable name.<br/>
        /// Used together with the parent class and the sibling class <see cref="Log"/>.
        /// </summary>
        /// <remarks>
        /// This could entirely be replaced by new'ing these up within <see cref="Log"/>,<br/>
        /// but having given them names will reduce the risk of re-using the same ID for things that shouldn't be sorted together.<br/>
        /// So in a real world scenario, you would have a selection of EventIDs in the private LogEvents-class, not just one.
        /// </remarks>
        internal static class LogEvents
        {
            public static readonly EventId ExampleEventId = new EventId(2, nameof(HighPerformanceLogging));
        }

        /// <summary>
        /// Sets up the Action-delegate(s) and exposes the actual call(s) to send the log to the provided <see cref="ILogger"/> instance.
        /// </summary>
        private class Log
        {
            private static readonly Action<ILogger, string, Exception> _createUserRequestedTemplate =
                LoggerMessage.Define<string>(
                    LogLevel.Information,
                    LogEvents.ExampleEventId,
                    "Something about {message} needs to be logged");

            private readonly ILogger _logger;

            public Log(ILogger logger)
            {
                this._logger = logger;
            }

            public void LogMessage(string message, Exception exception)
                => _createUserRequestedTemplate(_logger, message, exception);
        }
    }
}

namespace runner
{
    using BenchmarkDotNet.Running;

    internal class Program
    {
        private static void Main()
        {
            BenchmarkRunner.Run<LogTests>();
        }
    }
}

namespace runner
{
    using BenchmarkDotNet.Attributes;
    using logging;
    using Microsoft.Extensions.Logging;

    [MemoryDiagnoser]
    public class LogTests
    {
        private readonly ILogger _logger = LoggerFactory.Create(builder =>
                    builder.SetMinimumLevel(LogLevel.Trace))
                        .CreateLogger<Program>();

        private SimpleLogging _sl;
        private HighPerformanceLogging _hpl;

        [GlobalSetup]
        public void Setup()
        {
            _sl = new SimpleLogging(_logger);
            _hpl = new HighPerformanceLogging(_logger);
        }

        [Benchmark]
        public void SimpleLoggingBench()
        {
            _sl.ThingThatLogs();
        }

        [Benchmark]
        public void HighPerformanceLoggingBench()
        {
            _hpl.ThingThatLogs();
        }
    }
}

BenchmarkDotNet v0.13.12, Windows 10 (10.0.19045.4651/22H2/2022Update)
Intel Core i7-4771 CPU 3.50GHz (Haswell), 1 CPU, 8 logical and 4 physical cores
  [Host]     : .NET Framework 4.8.1 (4.8.9256.0), X64 RyuJIT VectorSize=256
  DefaultJob : .NET Framework 4.8.1 (4.8.9256.0), X64 RyuJIT VectorSize=256

namespace logging;

using Microsoft.Extensions.Logging;

/// <summary>
/// The entire class needs to be partial, as this is a requirement for a Source Generator to work
/// </summary>
public partial class HighPerformanceLoggingWithAttributes
{
    private readonly ILogger _logger;

    public HighPerformanceLoggingWithAttributes(ILogger logger)
    {
        this._logger = logger;
    }

    /// <summary>
    /// One noticable difference with the source generator version is that EventId is _only_ an <see cref="int"/>, <br/>
    /// whereas the other two versions uses an <see cref="EventId"/> type where you can set your own <see cref="EventId.Name"/>.<br/>
    /// In this version, the name of the class this method resides in will automatically be set as the Name instead.<br/>
    /// Also pay attention to the fact that this method is also set as `partial`, as this is a requirement for a Source Generator to work.
    /// </summary>
    /// <param name="message">Message to log.</param>
    [LoggerMessage(
        EventId = 3,
        Level = LogLevel.Debug,
        Message = "Something about {message} needs to be logged")]
    public partial void LoggingMethod(string message);

    public void ThingThatLogs()
    {
        this.LoggingMethod("I need to be logged");
    }
}

BenchmarkDotNet v0.13.12, Windows 10 (10.0.19045.4651/22H2/2022Update)
Intel Core i7-4771 CPU 3.50GHz (Haswell), 1 CPU, 8 logical and 4 physical cores
.NET SDK 8.0.303
  [Host]     : .NET 8.0.7 (8.0.724.31311), X64 RyuJIT AVX2
  DefaultJob : .NET 8.0.7 (8.0.724.31311), X64 RyuJIT AVX2