Does this Factory method violate the Open-Closed principle?

Question

I wonder if this Factory method pattern implementation violates the Open-Closed principle from the SOLID principles, because the switch in GetTradeManager has to be updated everytime we add another Trade Manager to the project. If it violates it, how do I make it meet the Open-Closed principle requirements?

services.AddSingleton<LiveTradeManager>();
services.AddSingleton<BacktestTradeManager>();
services.AddSingleton<ITradeManagerFactory, TradeManagerFactory>();

// the types
public interface ITradeManager
{
    Task RunAsync(CancellationToken cancellationToken);
}

public class BacktestTradeManager : ITradeManager
{
    public Task RunAsync(CancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }
}

public class LiveTradeManager : ITradeManager
{
    public Task RunAsync(CancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }
}

public class TradeManagerFactory : ITradeManagerFactory
{
    private readonly IServiceProvider _serviceProvider;

    public TradeManagerFactory(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public ITradeManager GetTradeManager(TradeManagerType tradeManagerType)
    {
        return tradeManagerType switch
        {
            TradeManagerType.Live => _serviceProvider.GetService<LiveTradeManager>() ?? throw new NullReferenceException(),
            TradeManagerType.Backtest => _serviceProvider.GetService<BacktestTradeManager>() ?? throw new NullReferenceException(),
            _ => throw new ArgumentOutOfRangeException(nameof(tradeManagerType), tradeManagerType, null)
        };
    }
}

Edit:

A Factory Pattern that will satisfy the Open/Closed Principle? doesn't solve my question, because I used to have something similar to:

public class BinanceClientFactory : IBinanceClientFactory
{
    private IServiceProvider Provider { get; }

    public BinanceClientFactory(IServiceProvider provider)
    {
        Provider = provider;
    }

    public IBinanceClient GetBinanceClient(WalletType walletType)
    {
        return walletType switch
        {
            WalletType.Spot => ActivatorUtilities.CreateInstance<BinanceClientSpot>(Provider),
            WalletType.Margin => ActivatorUtilities.CreateInstance<BinanceClientMargin>(Provider),
            WalletType.Futures => ActivatorUtilities.CreateInstance<BinanceClientFutures>(Provider),
            _ => null,
        };
    }
}

which doesn't add the created objects to the IoC container and I had to manually Dispose() them. Which is really not what I want to.

In the link you gave

public static class AnimalFactory
{
    public static Animal CreateAnimal(AnimalInfo aInfo)
    {
        if (aInfo is DogInfo)
            return new Dog(aInfo as DogInfo);
        if (aInfo is CatInfo)
            return new Cat(aInfo as CatInfo);
        return null;
    }
}

they are creating the objects outside the IoC container, which leads to what I described above. I need the IoC container to call Dispose() for me.

Answer 1

One common way of handling this that would avoid violating the Open/Closed Principle that you're concerned with would be to register the types as strategies and use those in the factory. To start, I'd recommend creating an internal strategy interface (internal since it's an implementation detail, not part of the public interface):

internal interface ITradeManagerStrategy : ITradeManager
{
    bool SupportsType(TradeManagerType tradeManagerType);
}

And then have each TradeManager implement this interface (note that they still end up implementing the public interface ITradeManager):

public class BacktestTradeManager : ITradeManagerStrategy
{
    public Task RunAsync(CancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }

    public bool SupportsType(TradeManagerType tradeManagerType) => tradeManagerType == TradeManagerType.Backtest;
}

public class LiveTradeManager : ITradeManagerStrategy
{
    public Task RunAsync(CancellationToken cancellationToken)
    {
        throw new NotImplementedException();
    }

    public bool SupportsType(TradeManagerType tradeManagerType) => tradeManagerType == TradeManagerType.Live;
}

And then your factory can resolve all of the strategies and return the instance (through the public interface) at runtime using the strategy method:

internal class TradeManagerFactory : ITradeManagerFactory
{
    private readonly IEnumerable<ITradeManagerStrategy> _tradeManagerStrategies;

    public TradeManagerFactory(IEnumerable<ITradeManagerStrategy> tradeManagerStrategies)
    {
        _tradeManagerStrategies = tradeManagerStrategies;
    }

    public ITradeManager GetTradeManager(TradeManagerType tradeManagerType)
    {
        return _tradeManagerStrategies.FirstOrDefault(s => s.SupportsType(tradeManagerType))
            ?? throw new ArgumentOutOfRangeException(nameof(tradeManagerType), tradeManagerType, null);
    }
}

Note that this requires registering the internal interfaces with DI along with the factory, for example:

.AddTransient<ITradeManagerStrategy, BacktestTradeManager>()
.AddTransient<ITradeManagerStrategy, LiveTradeManager>()
.AddTransient<ITradeManagerFactory, TradeManagerFactory>()