Microsoft ILogger to Windsor ILogger and Factory

logger.cs

public class ThisLogger: ILoggerFactory
    {
        private readonly Microsoft.Extensions.Logging.ILoggerFactory _logger;

        public ThisLogger(Microsoft.Extensions.Logging.ILoggerFactory logger)
        {
            _logger = logger;
        }

        public ILogger Create(Type type)
        {
            return new Adapter(_logger.CreateLogger(type));
        }

        public ILogger Create(string name)
        {
            return new Adapter(_logger.CreateLogger(name));
        }

        public ILogger Create(Type type, LoggerLevel level)
        {
            return new Adapter(_logger.CreateLogger(type));
        }


        public ILogger Create(string name, LoggerLevel level)
        {
            return new Adapter(_logger.CreateLogger(name));
        }
    }

    public class Adapter : ILogger
    {
        private readonly Microsoft.Extensions.Logging.ILogger _logger;

        public Adapter(Microsoft.Extensions.Logging.ILogger logger)
        {
            _logger = logger;
        }

        public ILogger CreateChildLogger(string loggerName) => throw new NotImplementedException();

        public void Trace(string message) => _logger.LogTrace(message);

        public void Trace(Func<string> messageFactory) => _logger.LogTrace(messageFactory());

        public void Trace(string message, Exception exception) => _logger.LogTrace(exception, message);

        public void TraceFormat(string format, params object[] args) => _logger.LogTrace(format, args);


        public void TraceFormat(Exception exception, string format, params object[] args) => _logger.LogTrace(exception, format, args);
        public void TraceFormat(IFormatProvider formatProvider, string format, params object[] args)
        {
            throw new NotImplementedException();
        }

        public void TraceFormat(Exception exception, IFormatProvider formatProvider, string format, params object[] args)
        {
            throw new NotImplementedException();
        }


        public void Warn(string message) => _logger.LogWarning(message);

        public void Warn(Func<string> messageFactory) => _logger.LogWarning(messageFactory());

        public void Warn(string message, Exception exception) => _logger.LogWarning(exception, message);

        public void WarnFormat(string format, params object[] args) => _logger.LogWarning(format, args);


        public void WarnFormat(Exception exception, string format, params object[] args) => _logger.LogWarning(exception, format, args);

        public void WarnFormat(IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();

        public void WarnFormat(Exception exception, IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();



        public void Debug(string message) => _logger.LogDebug(message);

        public void Debug(Func<string> messageFactory) => _logger.LogDebug(messageFactory());

        public void Debug(string message, Exception exception) => _logger.LogDebug(exception, message);

        public void DebugFormat(string format, params object[] args) => _logger.LogDebug(format, args);


        public void DebugFormat(Exception exception, string format, params object[] args) => _logger.LogDebug(exception, format, args);

        public void DebugFormat(IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();

        public void DebugFormat(Exception exception, IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();


        public void Error(string message) => _logger.LogError(message);

        public void Error(Func<string> messageFactory) => _logger.LogError(messageFactory());

        public void Error(string message, Exception exception) => _logger.LogError(exception, message);

        public void ErrorFormat(string format, params object[] args) => _logger.LogError(format, args);


        public void ErrorFormat(Exception exception, string format, params object[] args) => _logger.LogError(exception, format, args);

        public void ErrorFormat(IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();

        public void ErrorFormat(Exception exception, IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();


        public void Fatal(string message) => _logger.LogCritical(message);

        public void Fatal(Func<string> messageFactory) => _logger.LogCritical(messageFactory());

        public void Fatal(string message, Exception exception) => _logger.LogCritical(exception, message);

        public void FatalFormat(string format, params object[] args) => _logger.LogCritical(format, args);


        public void FatalFormat(Exception exception, string format, params object[] args) => _logger.LogCritical(exception, format, args);

        public void FatalFormat(IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();

        public void FatalFormat(Exception exception, IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();


        public void Info(string message) => _logger.LogInformation(message);

        public void Info(Func<string> messageFactory) => _logger.LogInformation(messageFactory());

        public void Info(string message, Exception exception) => _logger.LogInformation(exception, message);

        public void InfoFormat(string format, params object[] args) => _logger.LogInformation(format, args);


        public void InfoFormat(Exception exception, string format, params object[] args) => _logger.LogInformation(exception, format, args);

        public void InfoFormat(IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();

        public void InfoFormat(Exception exception, IFormatProvider formatProvider, string format, params object[] args) => throw new NotImplementedException();

        public bool IsTraceEnabled { get; }
        public bool IsDebugEnabled { get; }
        public bool IsErrorEnabled { get; }
        public bool IsFatalEnabled { get; }
        public bool IsInfoEnabled { get; }
        public bool IsWarnEnabled { get; }
    }