I have a button that I programmatically created. I want to it to execute the methods in another class when pressed, programmatically. This is part of my horizontal scroll view code.

 let button1 = UIButton(frame: CGRect.zero)
 button1.setImage(UIImage(named: "bell.png"), for: UIControlState.normal)
 horizontalScrollView.addItem(button1)

I want button1 one to open another class and execute methods in there.

Using Protocols for Inter-Class Communication in Swift

Problem

When you want to perform a method in one class based on an action in another class, you need a way to communicate between these classes. In Swift, one common and powerful approach is to use protocols and delegation.

Solution

Here's a step-by-step guide on how to implement this pattern:

1. Define a protocol outside the first class:

protocol ActionDelegate {
    func performAction()
}

2. Inside the first class (let's call it FirstClass), declare a delegate property:

class FirstClass {
    var delegate: ActionDelegate?
    
    func someMethod() {
        // When you want to trigger the action
        delegate?.performAction()
    }
}

3. In the second class where you want to perform the method, conform to the protocol:

class SecondClass: ActionDelegate {
    func performAction() {
        // Code to be executed when the action is triggered
        print("Action performed in SecondClass")
    }
}

4. When instantiating FirstClass in SecondClass, set the delegate:

class SecondClass: ActionDelegate {
    init() {
        let firstClassInstance = FirstClass()
        firstClassInstance.delegate = self
    }
    
    func performAction() {
        print("Action performed in SecondClass")
    }
}

Usage with UITableViewCell

If you're using this pattern with a custom UITableViewCell, here's how you can implement it:

1. Define the protocol:

protocol CellActionDelegate {
    func cellDidTriggerAction(_ cell: UITableViewCell)
}

2. In your custom cell class:

class CustomTableViewCell: UITableViewCell {
    var delegate: CellActionDelegate?
    
    @IBAction func buttonTapped(_ sender: UIButton) {
        delegate?.cellDidTriggerAction(self)
    }
}

3. In your view controller:

class ViewController: UIViewController, UITableViewDataSource, UITableViewDelegate, CellActionDelegate {
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        guard let cell = tableView.dequeueReusableCell(withIdentifier: "CustomCell", for: indexPath) as? CustomTableViewCell else {
            return UITableViewCell()
        }
        
        cell.delegate = self
        // Configure the cell...
        
        return cell
    }
    
    func cellDidTriggerAction(_ cell: UITableViewCell) {
        // Handle the action here
        print("Cell action triggered")
    }
}

Benefits

1. Decoupling: This pattern allows for loose coupling between classes. The first class doesn't need to know the specific implementation of the second class.
2. Flexibility: You can easily change which object responds to the action by changing the delegate.
3. Reusability: The same pattern can be used for different types of actions and in various contexts.

Considerations

• Make sure to declare the delegate as weak to avoid retain cycles:

weak var delegate: ActionDelegate?

• When using this pattern, ensure that you're setting the delegate appropriately to avoid nil delegate calls.

Remember, this is a powerful pattern in Swift and iOS development, commonly used in Apple's frameworks (like UITableViewDelegate, UITextFieldDelegate, etc.) and is a great way to implement communication between objects in a loosely coupled manner.