A benchmark for AutofacSerilogIntegration under different registrations

AutofacSerilogBench.cs

using System;
using Autofac;
using AutofacSerilogIntegration;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Running;
using Serilog;

namespace AutofacSerilogBench
{
    [GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
    [CategoriesColumn]
    public class ActivationBenchmarks
    {
        private IContainer _containerWithLogging;
        private IContainer _containerNoLogging;

        [GlobalSetup]
        public void Setup()
        {
            var logger = new LoggerConfiguration()
                .CreateLogger();

            var containerBuilder = new ContainerBuilder();
            containerBuilder.RegisterLogger(logger, dispose: true);

            containerBuilder.RegisterInstance(new InstanceDependency());
            containerBuilder.Register(_ => new DelegateDependency());
            containerBuilder.Register(_ => new DelegateDependency2());
            containerBuilder.RegisterType<ReflectionDependency>();
            containerBuilder.RegisterType<ReflectionDependencyWithLogger>();

            containerBuilder.RegisterType<Service<InstanceDependency>>();
            containerBuilder.RegisterType<Service<DelegateDependency>>();
            containerBuilder.RegisterType<Service<ReflectionDependency>>();
            containerBuilder.RegisterType<Service<ReflectionDependencyWithLogger>>();
            containerBuilder.RegisterType<Service2>();

            _containerWithLogging = containerBuilder.Build();

            containerBuilder = new ContainerBuilder();

            containerBuilder.RegisterInstance(new InstanceDependency());
            containerBuilder.Register(_ => new DelegateDependency());
            containerBuilder.Register(_ => new DelegateDependency2());
            containerBuilder.RegisterType<ReflectionDependency>();

            containerBuilder.RegisterType<Service<InstanceDependency>>();
            containerBuilder.RegisterType<Service<DelegateDependency>>();
            containerBuilder.RegisterType<Service<ReflectionDependency>>();
            containerBuilder.RegisterType<Service2>();

            _containerNoLogging = containerBuilder.Build();
        }

        [GlobalCleanup]
        public void Cleanup()
        {
            _containerWithLogging.Dispose();
            _containerNoLogging.Dispose();
        }

        [BenchmarkCategory("AutofacSerilog")]
        [Benchmark(Baseline = true)]
        public Service<ReflectionDependency> Reflection() => _containerWithLogging.Resolve<Service<ReflectionDependency>>();

        [BenchmarkCategory("AutofacSerilog")]
        [Benchmark]
        public Service<ReflectionDependencyWithLogger> ReflectionWithLogger() => _containerWithLogging.Resolve<Service<ReflectionDependencyWithLogger>>();

        [BenchmarkCategory("AutofacSerilog")]
        [Benchmark]
        public Service<InstanceDependency> Instance() => _containerWithLogging.Resolve<Service<InstanceDependency>>();

        [BenchmarkCategory("AutofacSerilog")]
        [Benchmark]
        public Service<DelegateDependency> Delegate() => _containerWithLogging.Resolve<Service<DelegateDependency>>();

        [BenchmarkCategory("AutofacSerilog")]
        [Benchmark]
        public Service2 TwoDelegates() => _containerWithLogging.Resolve<Service2>();

        [BenchmarkCategory("Pure")]
        [Benchmark(Baseline = true)]
        public Service<ReflectionDependency> ReflectionNoLogger() => _containerNoLogging.Resolve<Service<ReflectionDependency>>();

        [BenchmarkCategory("Pure")]
        [Benchmark]
        public Service<InstanceDependency> InstanceNoLogger() => _containerNoLogging.Resolve<Service<InstanceDependency>>();

        [BenchmarkCategory("Pure")]
        [Benchmark]
        public Service<DelegateDependency> DelegateNoLogger() => _containerNoLogging.Resolve<Service<DelegateDependency>>();

        [BenchmarkCategory("Pure")]
        [Benchmark]
        public Service2 TwoDelegatesNoLogger() => _containerNoLogging.Resolve<Service2>();
    }

    public class InstanceDependency { }
    public class DelegateDependency { }
    public class DelegateDependency2 { }
    public class ReflectionDependency {}

    public class ReflectionDependencyWithLogger
    {
        private readonly ILogger _logger;

        public ReflectionDependencyWithLogger(ILogger logger) => _logger = logger;
    }

    public class Service<T>
    {
        private readonly T _dependency;

        public Service(T dependency) => _dependency = dependency;
    }

    public class Service2
    {
        private readonly DelegateDependency _dependency;
        private readonly DelegateDependency2 _dependency2;

        public Service2(DelegateDependency dependency, DelegateDependency2 dependency2)
        {
            _dependency = dependency;
            _dependency2 = dependency2;
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            var summary = BenchmarkRunner.Run<ActivationBenchmarks>();
        }
    }
}