利用对象类型闭包和NSMapTable实现多播闭包

首先普及一个概念，就是多播代理，或者叫多播委托
我们知道swift回调有代理、通知、kvo和闭包
项目中多对多一般就用通知了，通知是有很多缺点的，例如难以维护，有些场景并不适合通知（举个例子：各大即时通讯的消息列表，都用的是多播代理）

多播代理的原理：
普通代理只能实现一对一，例如controller是tableview的代理，我们为了避免内存泄漏，delegate都是weak的。而多代理就是拿一个weak类型的数组把delegate存起来，这个数组就是NSHashTable
代码：

@objc
protocol AnimalPrtocol {
    func eat()
    func sleep()
}

class Controller: UIViewController {

// 没用过的注意options的weakMemory，资料很多不做赘述
       private let hashTable = NSHashTable<NSObject>.init(options: .weakMemory)
// 添加代理
       public func addDelegate(_ delegate: AnimalPrtocol) {
        hashTable.add(delegate)
      }

// 调用代理方法,饿了去吃
    private func hungry() {
        hashTable.allObjects.forEach { $0.eat() }
    }
}

已上就实现了多代理

而如果想把这个代理改成闭包呢？

第一、NSHashTable可以实现一个weak的数组，NSMapTable可以实现一个weak的字典
第二、要创建一个存储闭包的类型，例如

class Block {
  var stringCallback: ((String) -> ())?
  var intCallback: ((Int) -> ())?
  var modelCallback: ((XXXModel) -> ())?
}

缺点很明显，需要设置无数个回调
这里推荐使用王巍大大的Delegate类型
使用 protocol 和 callAsFunction 改进 Delegate
https://onevcat.com/2020/03/improve-delegate/
具体内容可以去看，本人不做赘述
以下是demo, 就这么三五十行。。要看效果的新建项目复制粘贴快很多.也可以去下载看看
https://gitee.com/nameUser/multicast-closure

import UIKit

class Model: NSObject {
    
    var name: String = ""
    convenience init(name: String) {
        self.init()
        self.name = name
    }
}

class ViewController: UIViewController {
    // 这里的valueOptions如果不在这里存直接释放所以用了strong，当key释放时，value自动释放。valueOptions根据自己是否保存过去选择weak或者strong，一般闭包只在这里引用一次
    var mapTable = NSMapTable<Model, Delegate<String, Void>>.init(keyOptions: .weakMemory, valueOptions: .strongMemory)
    var models: [Model] = []

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view.
        
        for i in 0..<10 {
            let model = Model.init(name: "\(i)")
            models.append(model)
            let comp: Delegate<String, Void> = .init()
            mapTable.setObject(comp, forKey: model)
        }
        
        for object in mapTable.keyEnumerator() {
            if let objc = object as? Model {
                mapTable.object(forKey: objc)?.delegate(on: self, closure: { (self, string) -> Void in
                    print(string)
                })
            }
        }
// 也可以直接取 value
        /*
         mapTable.objectEnumerator()?.allObjects.forEach {
            if let value = $0 as? Delegate<String, Void> {
                value.delegate(on: self, closure: { (self, string) -> Void in
                    print(string)
                })
            }
         }
         */
    }

    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
        models.removeFirst()
        for object in mapTable.keyEnumerator() {
            if let objc = object as? Model {
                mapTable.object(forKey: objc)?.callAsFunction(objc.name)
            }
        }
        print(mapTable)
    }

}

以下是王巍大大的Delegate整合

import Foundation

public class Delegate<Input, Output> {
    
    public init() {}
    
    private var closure: ((Input) -> Output?)?
    
    /// 委托回调
    /// - Parameters:
    ///   - target: 目标对象
    ///   - closure: 回调闭包
    public func delegate<T: AnyObject>(on target: T, closure: @escaping ((T, Input) -> Output)) {
        // The `target` is weak inside block, so you do not need to worry about it in the caller side.
        self.closure = { [weak target] input in
            guard let target = target else { return nil }
            return closure(target, input)
        }
    }
    
    /// 取消代理回调
    public func cancell() {
        self.closure = nil
    }

    @discardableResult
    public func callAsFunction(_ input: Input) -> Output? {
        return closure?(input)
    }
}

extension Delegate where Input == Void {
    
    public func delegate<T: AnyObject>(on target: T, closure: @escaping ((T) -> Output)) {
        // The `target` is weak inside block, so you do not need to worry about it in the caller side.
        self.closure = { [weak target] _ in
            guard let target = target else { return nil }
            return closure(target)
        }
    }
    
    @discardableResult
    public func callAsFunction() -> Output? {
        return closure?(())
    }
}

public protocol OptionalProtocol {
    static var Nil: Self { get }
}

extension Optional: OptionalProtocol {
    
    public static var Nil: Optional<Wrapped> {
        return nil
    }
}

extension Delegate where Output: OptionalProtocol {
    
    @discardableResult
    public func callAsFunction(_ input: Input) -> Output {
        switch closure?(input) {
        case .some(let value):
            return value
            
        case .none:
            return .Nil
        }
    }
}

缺点就是每加一个方法就要加一个NSMapTable去记录，去callAsFunction，大于两个回调方法还是建议用多播代理，两个以内可以用这个