Qual è l'approccio migliore per implementare l'integrazione delle dipendenze usando MVVM Architecture?

Devo usare DispatchQueue all'interno del controller e passarlo come dipendenza. Questo è quello che ho provato fino ad ora e ho elaborato due soluzioni. Hai bisogno di chiedere cosa sia meglio e di uso comune da parte di altri sviluppatori:

protocol DispatchQueuerable: class {
    func perform(withDelay delay: Double, block: @escaping () -> Void)
    func performAsync(block: @escaping () -> Void)
}

Prima soluzione:

class DispatchQueuer: DispatchQueuerable {
    private let queue: DispatchQueue
    init(queue: DispatchQueue) {
        self.queue = queue
    }
    func perform(withDelay delay: Double, block: @escaping () -> Void) {
        queue.asyncAfter(deadline: .now() + delay as DispatchTime, execute: block)
    }
    func performAsync(block: @escaping () -> Void) {
        queue.async {
            block()
        }
    }
}

Seconda soluzione:

extension DispatchQueue: DispatchQueuerable {
    func perform(withDelay delay: Double, block: @escaping () -> Void) {
        asyncAfter(deadline: .now() + delay as DispatchTime, execute: block)
    }
    func performAsync(block: @escaping () -> Void) {
        async {
            block()
        }
    }
}

La mia domanda è: approccio migliore per evitare l'accoppiamento stretto nel codice e utilizzare correttamente MVVM Archtecture:

Come li uso?

Prima soluzione:

let queuer = DispatchQueuer(queue: DispatchQueue.main)
MyViewController(queuer: queuer)

class MyViewController: UIViewController {
    private let queuer: DispatchQueuer
    init(queuer: DispatchQueuer) {
        self.queuer = queuer
    }
}

Seconda soluzione:

let queue = DispatchQueue.main
MyViewController(queue: queue)

class MyViewController: UIViewController {
    private let queue: DispatchQueue
    init(queue: DispatchQueue) {
        self.queue = queue
    }
}

Mi piace davvero la PRIMA soluzione e la conosco, ma cosa ne pensi?