我在 Java 中看到过一种模式，它允许您以类型安全的方式实现回调列表的子集，并与使用回调的类内联:

registerHandlers(new ClassWithNoOpMethods() {
    @override
    public void onFooEvent(FooEvent event) { ... }
    @override
    public void onBarEvent(BarEvent event) { ... }
}

一切都很好而且类型安全。我想在 Swift 中做同样的事情，但是谷歌搜索没有找到任何(恕我直言)优雅的解决方案。所以我想到了这个:

let registrar = EventSource.getEventRegistrar()
registrar.onFooEvent = { event in doSomethingFoo(event) }
registrar.onBarEvent = { event in doSomethingBar(event) }
...
EventSource.removeEventCallbacks(registrar)

这对于消费事件来说效果很好——它只是我感兴趣的事件子集，它让我可以定义内联代码，等等。

但是，当我实际实现它时，我得到了很多重复的、样板的、非 DRY 代码。这冒犯了我，但我想不出更好的方法来实现上面显示的方案。我想向 StackOverflow 上的 Swift 大神们求助，向我展示一种更简洁的实现方法。

这是现在的样子:

public class Phone {
    ...phone stuff...
    public class PhoneEventRegistrar {

        let phone : Phone

        init(phone : Phone) {
            self.phone = phone
        }

        public typealias OnErrorCallback = (PhoneErrorType, String) -> Void
        private var onErrorValue : OnErrorCallback?
        public var onError : OnErrorCallback {
            get { return onErrorValue != nil ? onErrorValue! : {_,_ in} }
            set {
                assert(onErrorValue == nil, "onError cannot be set twice")
                onErrorValue = newValue
            }
        }
        func invokeErrorCallback(type : PhoneErrorType, message : String) {
            if let onErrorValue = onErrorValue {
                onErrorValue(type, message)
            }
        }

        public typealias OnCallStateChangeCallback = (CallState) -> Void
        private var onCallStateChangeValue : OnCallStateChangeCallback?
        public var onCallStateChange : OnCallStateChangeCallback {
            get { return onCallStateChangeValue != nil ? onCallStateChangeValue! : {_ in} }
            set {
                assert(onCallStateChangeValue == nil, "onCallStateChange cannot be set twice")
                onCallStateChangeValue = newValue
            }
        }
        func invokeCallStateChangeCallback(state : CallState) {
            if let onCallStateChangeValue = onCallStateChangeValue {
                onCallStateChangeValue(state)
            }
        }

        // and the mostly-similar code shown twice above is repeated for
        // each possible callback
    }

    func invokeErrorCallbacks(type : PhoneErrorType, message : String) {
        objc_sync_enter(self)
        defer { objc_sync_exit(self) }
        registrars.forEach({$0.invokeErrorCallback(type, message: message)})
    }

    func invokeCallStateChangeCallbacks(state : CallState) {
        objc_sync_enter(self)
        defer { objc_sync_exit(self) }
        registrars.forEach({$0.invokeCallStateChangeCallback(state)})
    }

    // again, the mostly similar block of code shown twice above is
    // repeated for each possible callback

    private var registrars : [PhoneEventRegistrar] = []
    public func getPhoneEventRegistrar() -> PhoneEventRegistrar {
        objc_sync_enter(self)
        defer { objc_sync_exit(self) }
        let registrar = PhoneEventRegistrar(phone: self)
        registrars.append(registrar)
        return registrar
    }

    public func removeRegistrarCallbacks(registrar : PhoneEventRegistrar) {
        objc_sync_enter(self)
        defer { objc_sync_exit(self) }
        assert(registrars.contains({$0 === registrar}), "cannot remove callbacks, no matching PhoneEventRegistrar found")
        registrars = registrars.filter({$0 !== registrar})
    }
}

如果人们看到替代实现对事件消费者具有相同的可用性优势，我也很乐意看到这些实现。以下是我想到或尝试过的一些其他选项:

• 实现定义回调的协议(protocol)。让事件消费者实现协议(protocol)并注册回调。否定:要求实现所有方法 - 强制执行过多的无操作回调。
• 同上，但使用默认空白实现扩展协议(protocol)。否定:仍然需要事件消费者为回调实现一个额外的类。此外，缺少协议(protocol)扩展的动态调度意味着注册协议(protocol)将强制生成的事件转到无操作实现而不是真正的事件处理程序。
• 将消费类设置为事件生产者的委托(delegate)。否定:仍然必须实现无操作回调。我只见过每个事件制作人有一个代表，我需要几个。 @Darko 下面的评论促使我进一步考虑这个选项。

最佳答案

NSNotificationCenter

您的问题有多种解决方案。一种可能是简单地使用 NSNotificationCenter 而不是实现您自己的事件机制。

使用 NSNotificationCenter 你可以注册事件:

NSNotificationCenter.defaultCenter().addObserver(
self,
selector: #selector(MyClass.myMethod),
name: "com.mycompany.myEvent1",
object: userData)

并从任何地方发送事件:

let userData: [NSObject: AnyObject] = [anyObject: anyDataToSend]
NSNotificationCenter.defaultCenter.postNotificationName("com.mycompany.myEvent1", object: userData)

您会在 SO 和 Google 上找到大量关于 NSNotificationCenter 的教程。

委托(delegate)可选协议(protocol)

另一种方法是使用委托(delegate)模式。创建一个协议(protocol)并将其标记为@objc，这样协议(protocol)方法就可以标记为“可选”。

@objc protocol MyEventProtocol: class {
  optional func foo() -> Bool
  func bar()
}

现在每个符合此协议(protocol)的对象都必须实现 bar()，但可以可选地实现 foo()。

class MyEventReceiver: MyEventProtocol {
    func bar() { // do something }
}

然后你的事件发送者类可以做这样的事情:

class MyEventSender {
     weak var delegate: MyEventProtocol? // the name "delegate" is just convention, you can use any other name

     init(receiver: MyEventReceiver) {
         self.delegate = receiver
     }

     func sendEventToReceiver() {
         if let delegate = self.delegate {
             delegate.func() // guaranteed by the protocol
             delegate.foo?() // foo is marked as optional, so you have to check it with ?. If foo is implemented on the receiver it will be called, otherwise not.
         }
     }
}

这是基本原则。通过这种方式，您可以为所有可能的事件定义一个协议(protocol)，但协议(protocol)的实现者只需实现未标记为 optional 的方法。它们是“必需的”。

使用默认方法的协议(protocol)扩展

第三种方法是使用默认方法创建协议(protocol)扩展。

protocol MyEventProtocol: {
  func bar()
}

extension MyEventProtocol {
    func foo() -> Bool {
        return true
    }
}

然后 MyEventProtocol 的实现者不必实现 foo()，因为已经有一个实现。 (这是一种带有可选方法的“伪造”@objc 协议(protocol))如果您向该解决方案添加一些通用机制，您还可以防止大量代码重复。 (协议(protocol)中的泛型在 Swift 2.2 中使用 associatedtype 完成，请参阅其他教程)

关于swift - 我怎样才能使这个 Swift 事件处理程序样板更简洁？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36368656/