Alternative CommandProcessor

public interface ICommand
    {
        int ResultId { get; }
    }

public class CommandProcessor : ICommandProcessor
    {
        private readonly IKernel _kernel;
        private readonly IDatabase _db;
        private readonly Queue<CommandData> _commandSet = new Queue<CommandData>();

        public CommandProcessor(IKernel kernel, IDatabase database)
        {
            _kernel = kernel;
            _db = database;
        }

        public async Task Process<T>(T cmd) where T : ICommand
        {
            using (var connection = await _db.CreateConnection())
            {
                var transaction = connection.BeginTransaction();

                var handler = _kernel.Get<IHandleCommand<T>>();
                await handler.Handle(cmd, connection, transaction);

                transaction.Commit();
            }
        }

        public void Set<TCommand>(TCommand cmd) where TCommand : ICommand
        {
            var commandData = new CommandData();
            var handler = _kernel.Get<IHandleCommand<TCommand>>();
            commandData.Process = (conn, tran) => handler.Handle(cmd, conn, tran);
            _commandSet.Enqueue(commandData);
        }

        public async Task ProcessMultiple()
        {
            if (_commandSet.Count == 0)
                throw new Exception("Set commands");

            using (var connection = await _db.CreateConnection())
            {
                var transaction = connection.BeginTransaction();
                while (_commandSet.Count > 0)
                {
                    var commandData = _commandSet.Dequeue();
                    await commandData.Process(connection, transaction);
                }
                transaction.Commit();
            }
        }

        private class CommandData
        {
            public Func<SqlConnection, SqlTransaction, Task> Process { get; set; }
        }
    }


public class TicketService
{
    public async Task AddTicket(){
        //Some validationt to see if multipel add commands needed
        var courierAddCommand = new CourierAddCommand();
        _commandProcess.Set(courierAddCommand);

        await _commandProcessor.ProcessMultiple();

        await _commandProcessor.Process(new TicketAddCommand{CourierId = courierAddCommand.Result});
    }
}