The history of one study in log4net and its acceleration by more than 10 times

using System;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
using System.Security.Principal;
using System.Threading;
using log4net.Appender;
using log4net.Core;
namespace log4net.ext.boost
{
    public sealed class AccelerateForwardingAppender : ForwardingAppender
    {
        private static readonly FieldAccessor LoggingEventDataAccessor;
        static AccelerateForwardingAppender()
        {
            LoggingEventDataAccessor = new FieldAccessor(@"m_data");
        }
        public AccelerateForwardingAppender()
        {
            CacheUsername = true;
            CacheIdentity = true;
            Username = WindowsIdentity.GetCurrent().Name ?? string.Empty;
            Identity = Thread.CurrentPrincipal.Identity?.Name ?? string.Empty;
        }
        public bool CacheUsername { get; set; }
        public bool CacheIdentity { get; set; }
        public string Username { get; set; }
        public string Identity { get; set; }
        protected override void Append(LoggingEvent loggingEvent)
        {
            Accelerate(loggingEvent);
            base.Append(loggingEvent);
        }
        protected override void Append(LoggingEvent[] loggingEvents)
        {
            for (var i = 0; i < loggingEvents.Length; i++)
            {
                Accelerate(loggingEvents[i]);
            }
            base.Append(loggingEvents);
        }
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void Accelerate(LoggingEvent loggingEvent)
        {
            if (CacheUsername || CacheIdentity)
            {
                var loggingEventData = LoggingEventDataAccessor.Get(loggingEvent);
                if (CacheUsername)
                {
                    loggingEventData.UserName = Username;
                }
                if (CacheIdentity)
                {
                    loggingEventData.Identity = Identity;
                }
                LoggingEventDataAccessor.Set(loggingEvent, loggingEventData);
            }
        }
        private sealed class FieldAccessor
        {
            public readonly Func Get;
            public readonly Action Set;
            public FieldAccessor(string fieldName)
            {
                Get = FieldReflection.CreateGetDelegate(fieldName);
                Set = FieldReflection.CreateSetDelegate(fieldName);
            }
        }
        private static class FieldReflection
        {
            public static Func CreateGetDelegate(string fieldName)
            {
                var owner = Expression.Parameter(typeof(TSubject), @"owner");
                var field = Expression.Field(owner, fieldName);
                var lambda = Expression.Lambda>(field, owner);
                return lambda.Compile();
            }
            public static Action CreateSetDelegate(string fieldName)
            {
                var owner = Expression.Parameter(typeof(TS), @"owner");
                var value = Expression.Parameter(typeof(TF), @"value");
                var field = Expression.Field(owner, fieldName);
                var assign = Expression.Assign(field, value);
                var lambda = Expression.Lambda>(assign, owner, value);
                return lambda.Compile();
            }
        }
    }
}

using System;
using System.Diagnostics;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Columns;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Running;
using log4net.Appender;
using log4net.Core;
using log4net.Layout;
namespace log4net.ext.boost.benchmark
{
    public static class Program
    {
        private static void Main(string[] args)
        {
            var config = ManualConfig.Create(DefaultConfig.Instance)
                .With(PlaceColumn.ArabicNumber)
                .With(StatisticColumn.AllStatistics)
                .With(Job.Default);
            BenchmarkRunner.Run(config);
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey(true);
        }
        public class BoostBenchmark
        {
            public BoostBenchmark()
            {
                Trace.AutoFlush = Trace.UseGlobalLock = false;
                Trace.Listeners.Clear();
                TraceAppender = new TraceAppender { Layout = new PatternLayout("%timestamp [%thread] %ndc - %message%newline") };
                AccelerateForwardingAppender = new AccelerateForwardingAppender();
                AccelerateForwardingAppender.AddAppender(TraceAppender);
            }
            private TraceAppender TraceAppender { get; }
            private AccelerateForwardingAppender AccelerateForwardingAppender { get; }
            [Benchmark]
            public void TraceAppenderBenchmark()
            {
                Perform(TraceAppender);
            }
            [Benchmark]
            public void AcceleratedTraceAppenderBenchmark()
            {
                Perform(AccelerateForwardingAppender);
            }
            private static void Perform(IAppender appender)
            {
                appender.DoAppend(new LoggingEvent(new LoggingEventData { TimeStamp = DateTime.UtcNow, Message = "TEST" }));
            }
        }
    }
}