SwiftUI + MVVM + async tasks in model - asynchronous

Question

For a small application that I want to implement I’d like to use SwiftUI and stick with MVVM.
But async tasks in the model are giving me a headache.
I have created a very simplified example to explain it:
View:
import SwiftUI
struct ContentView: View {
#ObservedObject var viewModel: ViewModel
var body: some View {
VStack {
Text("\(viewModel.model.numberToDisplay)")
Button(action: {self.viewModel.model.increase()}) {
Text("increase")
}
}
}
struct ContentView_Previews: PreviewProvider {
static var previews: some View {
ContentView(viewModel: ViewModel())
}
}
}
ViewModel:
import Foundation
import SwiftUI
class ViewModel: ObservableObject {
#Published var model = Model()
}
Model:
import Foundation
struct Model {
private(set) var numberToDisplay: Int = 0
mutating func increase() {
for _ in 0...2 {
self.numberToDisplay += 1
sleep(1)
}
}
}
Having this the UI will show “0” at the start. Hitting “increase” gives a blocked UI for 3s (see for loop in the model) and afterwards it’ll show “3”.
What I would like to have is a non-blocked UI and that all updates of numberToDisplay are shown (0 -> 1 -> 2 -> 3 instead of 0 -> 3).
If I try to use a DispatchQueue like this in the model:
DispatchQueue.global().async {
self.numberToDisplay += 1
}
it just gives me an „Escaping closure captures mutating 'self' parameter” error.
Using a class instead of a struct for the model allows me to use a DispatchQueue, but even worse the UI does not get updated at all. (The usage of DispatchQueue does not play any role in here.)
So what the appropriate approach to use SwiftUI with MVVM and async functions within the model?
Best regards
Just Alex

Answer 1

It is just a question of responsibility... if to think about model as a passive storage of data, then here is possible solution.
Tested with Xcode 11.4 / iOS 13.4
struct ContentView: View {
#ObservedObject var viewModel: ViewModel
var body: some View {
VStack {
Text("\(viewModel.model.numberToDisplay)")
Button(action: {self.viewModel.increase()}) {
Text("increase")
}
}
}
}
class ViewModel: ObservableObject {
#Published var model = Model()
func increase() {
DispatchQueue.global(qos: .background).async {
for _ in 0...2 {
DispatchQueue.main.async {
self.model.numberToDisplay += 1
}
sleep(1)
}
}
}
}
struct Model {
var numberToDisplay: Int = 0
}
Note: ... and I would say that even this is not the end, because numberToDisplay semantically cannot be part of model, and belongs to view model layer, so you can continue...

Answer 2

DispatchQueue.global().async {
self.numberToDisplay += 1 // you can't mutate a struct without mutating function
self.increase() // may work
}
If you change model to reference type, i.e.; class, the reference itself does not change even when you mutate its properties, because reference just points to some memory whose content is modified, but not the reference itself.
So your observer won't work with reference type model.