간접 호출 기반 로깅 시스템 설계

public class Log
{
    private static readonly Lazy<Log> instance = new Lazy<Log>(() => new Log());
    public static Log Instance => instance.Value;
    private Dictionary<LogLevel, Action<string>> _loggers = new Dictionary<LogLevel, Action<string>>();
    private LogType _type = LogType.File;
    private LogLevel _level = LogLevel.Debug;
    private string _path = $@"C:\Logs\cLib.log";
    public LogType Type
    {
        get => _type;
        set
        {
            if (_type != value)
            {
                _type = value;
                Build().Initialize();
            }
        }
    }
    public LogLevel Level
    {
        get => _level;
        set
        {
            if (_level != value)
            {
                _level = value;
                Initialize();
            }
        }
    }
    public string Path
    {
        get => _path;
        set
        {
            if (_path != value)
            {
                _path = value;
                Initialize();
            }
        }
    }
    public Log SetType(LogType type)
    {
        Type = type;
        return this;
    }
    public Log SetLevel(LogLevel level)
    {
        Level = level;
        return this;
    }
    public Log SetPath(string path)
    {
        Path = path;
        return this;
    }
    public Log Build()
    {
        var loggerFactory = _type switch
        {
            LogType.Zero => new ZeroLoggerFactory(),
            LogType.File => new SerilogLoggerFactory(),
            _ => throw new ArgumentException("Invalid LogType")
        };
        InitializeLogger(loggerFactory.CreateLogger(_path, _level));
        return this;
    }
    private void InitializeLogger(ILogger logger)
    {
        _loggers = new Dictionary<LogLevel, Action<string>>
        {
            { LogLevel.Trace, logger.Trace },
            { LogLevel.Debug, logger.Debug },
            { LogLevel.Info, logger.Info },
            { LogLevel.Warn, logger.Info }, // Warn과 Info가 동일한 로그로 처리되는 경우
            { LogLevel.Error, logger.Error }
        };
    }
    public static void LogMessage(LogLevel level, string msg)
    {
        if (Instance._loggers.TryGetValue(level, out var logAction))
        {
            logAction.Invoke(msg);
        }
    }
    public static void Trace(string msg) => LogMessage(LogLevel.Trace, msg);
    public static void Debug(string msg) => LogMessage(LogLevel.Debug, msg);
    public static void Info(string msg) => LogMessage(LogLevel.Info, msg);
    public static void Error(string msg) => LogMessage(LogLevel.Error, msg);
}