MVVM-使用闭包将ViewModel与数据源绑定：是否需要捕获列表？

Question

I have a viewController keeping a (strong) reference to its viewModel

lazy private var viewModel: ListViewModel = {
   return ListViewModel()
}()

override func viewDidLoad() {
   super.viewDidLoad()

   initViewModel()
}

private func initViewModel() {
   viewModel.onModelChange = { [weak self] () in
      DispatchQueue.main.async {
         self?.tableView.reloadData()
      }
   }

   viewModel.fetchData()
}

Apple´s Swift documentation days that:

A strong reference cycle can also occur if you assign a closure to a property of a class instance, and the body of that closure captures the instance.

This viewController holds a viewController which holds a closure that captures the viewController , so I understand a strong reference cycle could occur.

These are the viewModel 's properties:

var onModelChange: (() -> Void)?

private var model: [MyModel] = [MyModel]() {
    didSet {
        self.onModelChange?()
    }
}

On the other hand, this viewController is the root one, so won´t be deallocated during the app's life. And I don´t explicitly nilify its viewModel property. So:

• Question 1 : is there actually a risk of a strong reference cycle happening? Should I provide a capture list to the closure anyway?
• Question 2 : I set the capture list to be [weak self] but, since it seems the viewController and its viewModel would be deallocated same time, I guess I should have defined [unowned self] instead? Does it hurt to define [weak self] in case of doubt?

Let's think that now the viewController is one that is pushed on top of the root one, so it could be pop during the life of the app. The viewController 's fetchData() method is like this:

func fetchData() {
    dataSource.getData(completion: { (result, error) -> Void in
        if error != nil {
            self.model = [MyModel]()
        } else {
            if let result = result {
                self.model = result
            } else {
                self.model = [MyModel]()
            }
        }
    })
}

where dataSource is a strong property and could get the data from either a local file (sync task) or to call a service (asyn task).

The model is also a property that is observed and calls the closure provided from the viewController

So:

• Question 3 : in case the dataSource is getting the data from a local file. What happens then if the viewController is pop in the meanwhile? Would the viewModel still be alive until the dataSource finishes? In such case, is it correct to provide the [weak self] capture list in the closure?
• Question 4 : in case the dataSource is performing an async network call, and the viewController is pop in the meanwhile, would be the same scenario than before? I mean, would the viewModel be still alive until the dataSource finishes?

EDIT: Scenario/Question 5

Now my viewModel asks also an object UserSettingsManager to get some other data:

func getUserSettings() {
    UserSettingsManager.getInfo { (result, error) in
        if error == nil {
            self.userData = result
            }
        }
    }
}

But this UserSettingsManager is not a property of the viewModel as dataSource is, it is a class that only provides static func . Those static func are passed closures as @escaping , so I guess a strong reference cycle could also happen in this scenario, right? Or would this scenario be different from the previous ones? Which capture list would I need here (if any)?

Answer 1

Question 1: is there actually a risk of a strong reference cycle happening? Should I provide a capture list to the closure anyway?

The strong reference cycle will happen. The question should be whether or not the strong reference cycle matters. In this case probably not, but it would probably be a good idea to keep the weak reference anyway, just in case you move the controller in the future. It's a small price to pay for future safety.

Question 2: I set the capture list to be [weak self] but, since it seems the viewController and its viewModel would be deallocated same time, I guess I should have defined [unowned self] instead? Does it hurt to define [weak self] in case of doubt?

[unowned self] implies that self will definitely exist when the closure is called. Unless you are absolutely sure that's the case, you should stick with [weak self] . My preference is to always use weak as it's not to much extra effort to safely unwrap, and you avoid a crash if you somehow missed a case where self could be deallocated. If you use self many times in a closure it might be nice to unwrap it in a guard statement or move the code to a separate function.

Question 3: in case the dataSource is getting the data from a local file. What happens then if the viewController is pop in the meanwhile? Would the viewModel still be alive until the dataSource finishes? In such case, is it correct to provide the [weak self] capture list in the closure?

In your example you have a strong reference to self in the closure, so you have a strong reference cycle which means the ViewController will never be deallocated.

Either way, if you grab the data synchronously, a tap to dismiss the view controller won't get to do it's work until after the fetch from the file and the code in the block is complete. Those would have to complete before the main thread becomes unblocked and the code to dismiss the controller can execute.

Question 4: in case the dataSource is performing an async network call, and the viewController is pop in the meanwhile, would be the same scenario than before? I mean, would the viewModel be still alive until the dataSource finishes?

If you made it a weak reference and dataSource was retained outside the controller so it outlives the controller, it is possible that self could be nil when the closure is called.