Logging Abstraction Around Quantower

ILogger.cs

public interface ILogger
{
    void Log(string message, LogLevel level = LogLevel.Info);
}

Logger.cs

public class Logger : ILogger
{
    private static readonly Lazy<Logger> instance = new(() => new Logger());
    private ILogger underlyingLogger;

    private Logger()
    {
    }

    public static Logger Instance => instance.Value;

    public static void Initialize(ILogger underlyingLogger)
    {
        if (Instance.underlyingLogger == null)
        {
            Instance.underlyingLogger = underlyingLogger ?? throw new ArgumentNullException(nameof(underlyingLogger));
        }
        else
        {
            throw new InvalidOperationException("Logger has already been initialized.");
        }
    }

    public static void Reset()
    {
        Instance.underlyingLogger = null;
    }

    public void Log(string message, LogLevel level = LogLevel.Info)
    {
        if (underlyingLogger == null)
        {
            throw new InvalidOperationException("Logger has not been initialized.");
        }
        
        underlyingLogger.Log(message, level);
    }
}

QuantowerLogger.cs

public class QuantowerLogger : ILogger
{
    private readonly Strategy strategy;
    private readonly MethodInfo? logMethod;

    public QuantowerLogger(Strategy strategy)
    {
        this.strategy = strategy;
        logMethod = strategy.GetType().GetMethod("Log", BindingFlags.Instance | BindingFlags.NonPublic);

        if (logMethod == null)
            throw new InvalidOperationException("Could not find Log method in strategy");
    }
    
    public void Log(string message, LogLevel level = LogLevel.Info)
    {
        var quantowerLevel = level switch
        {
            LogLevel.Info => StrategyLoggingLevel.Info,
            LogLevel.Error => StrategyLoggingLevel.Error,
            _ => StrategyLoggingLevel.Info
        };
        
        logMethod?.Invoke(strategy, [message, quantowerLevel]);
    }
}

Strategy.cs

public class Strategy : TradingPlatform.BusinessLayer.Strategy
{
  protected override void OnCreated()
  {
    Logger.Initialize(new QuantowerLogger(this));
  }

  protected override void OnRemove()
  {
    Logger.Reset();
  }
}

Usage.cs

// now from my own class, I can easily log messages to the strategy log window without couupling myself directly to the Quantower logger

public class MyOwnClass
{
  public void SomeMethod()
  {
    Logger.Instance.Log("some super important message");
  }
}