Swift closure stored as a variable produces memory leak

Question

I have a retain cycle when defining a closure as a variable.

The variable is defined as below:

public class MyCell: UICollectionViewCell {
    public var callback: ((MyCell)->Void)?
}

If I use delegates instead of closures, the retain cycle disappears, but I would like to know how can it be defined with closures for future cases.

I tried to set callback variable as weak, but, as I suppose, weak attribute can only be applied to class and class-bound protocol types.

EDIT

Usage:

class CustomController: UIViewController {
   private func onActionOccurs(_ cell: MyCell) {
       cell.backgroundColor = .red // For example
   }

   // After dequeuing the cell:
   {
       cell.callback = onActionOccurs(_:)
   }
}

Thanks

check this https://stackoverflow.com/questions/49302197/add-unowned-self-to-the-closure-argument-swift/49302347#49302347 — Reinier Melian, Aug 01 '18 at 09:12
If the callback argument is the instance itself, then `MyCell` can be changed to `weak self` like @JoakimDanielson said. — Rakesha Shastri, Aug 01 '18 at 09:14
why passing MyCell as argument to the block ? No need of this, wherever you assigning the block variable, you can capture cell. — vivekDas, Aug 01 '18 at 09:19

score 6 · Accepted Answer · edited Oct 11 '19 at 17:43

If you don't need to use self, then you can use the cell itself, and modifying your closure implementation in cell like this

public class MyCell: UICollectionViewCell {
    public var callback: (()->Void)?
}

then you can use it, like this example

class CustomController: UIViewController {
   private func onActionOccurs(_ cell: MyCell) {
       cell.backgroundColor = .red // For example
   }

   // After dequeuing the cell:
   {
       cell.callback = {
         cell.backgroundColor = .red // For example
        }
   }
}

but if you need to use a ViewController method then you need to use the [weak self] capture list If you need use UIViewController methods

class CustomController: UIViewController {
   private func onActionOccurs(_ cell: MyCell) {
       cell.backgroundColor = .red // For example
   }

   // After dequeuing the cell:
   {
       cell.callback = { [weak self] in
         guard let self = self else { return }

         self.viewControllerMethod()
        }
   }
}

Anyone knows why it stays in memory if we use like this? `cell.callback = onActionOccurs(_:)` . I understand that it uses self for somecases but some are not using even self functions or methods. Still stay if we don't use like Reinier's. — flyingBear, Sep 18 '18 at 13:17
Because if you use `cell.callback = onActionOccurs(_:)`, cell will hold the reference from UIViewController, it is a retain cycle. Reinier's idea callback is holding a closure in stack memory only, it will be destroyed after function call. — Weidian Huang, Dec 20 '19 at 03:01

Swift closure stored as a variable produces memory leak

1 Answers1