iOS Swift Combine: cancel a Set<AnyCancellable> iOS Swift Combine: cancel a Set<AnyCancellable> ios ios

iOS Swift Combine: cancel a Set<AnyCancellable>

On deinit your ViewController will be removed from memory. All of its instance variables will be deallocated.

The docs for Combine > Publisher > assign(to:on:) say:

An AnyCancellable instance. Call cancel() on this instance when you no longer want the publisher to automatically assign the property. Deinitializing this instance will also cancel automatic assignment.

1 - Should I cancel subscription in deinit? or it does the job automatically?

You don't need to, it does the job automatically. When your ViewController gets deallocated, the instance variable bag will also be deallocated. As there is no more reference to your AnyCancellable's, the assignment will end.

2 - If so, how can I cancel all the stored subscriptions?

Not so. But often you might have some subscriptions that you want to start and stop on, say, viewWillAppear/viewDidDissapear, for example. In this case your ViewController is still in memory.

So, in viewDidDissappear, you can do bag.removeAll() as you suspected. This will remove the references and stop the assigning.

Here is some code you can run to see .removeAll() in action:

var bag = Set<AnyCancellable>()func testRemoveAll() {  Timer.publish(every: 1, on: .main, in: .common).autoconnect()    .sink { print("===== timer: \($0)") }    .store(in: &bag)  Timer.publish(every: 10, on: .main, in: .common).autoconnect()    .sink { _ in self.bag.removeAll() }    .store(in: &bag)}

The first timer will fire every one second and print out a line. The second timer will fire after 10 seconds and then call bag.removeAll(). Then both timer publishers will be stopped.

if you happened to subscribe to a publisher from your View controller, likely you will capture self in sink, which will make a reference to it, and won't let ARC remove your view controller later if the subscriber didn't finish, so it's, advisable to weakly capture self

so instead of:

   ["title"]      .publisher      .sink { (publishedValue) in        self.title.text = publishedValue    }.store(in: &cancellable)

you should use a [weak self]:

   ["title"]      .publisher      .sink { [weak self] (publishedValue) in        self?.title.text = publishedValue    }.store(in: &cancellable)

thus, when View controller is removed, you won't have any retain cycle or memory leaks.

Try creating a pipeline and not storing the cancellable in some state variable. You’ll find that the pipeline stops as soon as it encounters an async operation. That’s because the Cancellable was cleaned up by ARC and it was thus automatically cancelled. So you don’t need to call cancel on a pipeline if you release all references to it.

From the documentation:

An AnyCancellable instance automatically calls cancel() when deinitialized.