Handler handler = new();
Command cmd1 = new FooCommand();
Command cmd2 = new BarCommand();
handler.HandleCommand(cmd1);
handler.HandleCommand(cmd2);

internal abstract class Command
{
    public abstract void Execute(Handler handler);
}

internal class FooCommand : Command
{
    public override void Execute(Handler handler) =>
        handler.HandleCommand(this);
}

internal class BarCommand : Command
{
    public override void Execute(Handler handler) =>
        handler.HandleCommand(this);
}

internal class Handler
{
    public void HandleCommand(Command command) =>
        command.Execute(this);

    public void HandleCommand(FooCommand command) =>
        Console.WriteLine("Handle Foo command.");

    public void HandleCommand(BarCommand command) =>
        Console.WriteLine("Handle Bar command.");
}

ICommandHandlerFactory factory = new CommandHandlerFactory()
    .AddHandler<FooCommand, FooCommandHandler>();

Command cmd = new FooCommand();
var handler = factory.GetCommandHandler(cmd.GetType());
handler.HandleCommand(cmd);

internal interface ICommandHandlerFactory
{
    ICommandHandler GetCommandHandler(Type commandType);
}

internal interface ICommandHandler
{
    void HandleCommand(Command command);
}

internal abstract class Command
{
}

internal class FooCommand : Command
{
}

internal class FooCommandHandler : ICommandHandler
{
    public void HandleCommand(Command command) =>
        HandleCommand(command as FooCommand ??
            throw new ArgumentException("Invalid command type", nameof(command)));

    private void HandleCommand(FooCommand command) =>
        Console.Write("Handle FooCommand");
}

internal class CommandHandlerFactory : ICommandHandlerFactory
{
    private readonly Dictionary<Type, Func<ICommandHandler>> _factories = new();

    public ICommandHandler GetCommandHandler(Type commandType)
    {
        return _factories.TryGetValue(commandType, out var f) ?
            f() : throw new ArgumentException("Invalid type", nameof(commandType));
    }

    public CommandHandlerFactory AddHandler<TCommand, THandler>()
        where THandler : ICommandHandler, new()
    {
        _factories.Add(typeof(TCommand), () => new THandler());
        return this;
    }
}