RXSwift链式观察者和捕捉错误

Question

我有一些代码，应该监听一些observable操作何时完成，但我有麻烦，以最理想的方式写它。

重要的是，最终的订阅结果是事件，并且 updateEvent 是最后运行的。

这是我的代码。

/// Update Event
///
/// Updates an event and invites or removes any members from the event before updating the actual event information. This ensures newly updated event to contain the updated list of attendes
///
/// - Parameters:
///   - event: The event to update
///   - group: The group that the event belongs to
///   - newMembers: A list of new group members that should be invited to the invited
///   - removeMembers: A list of event attendees that should be removed from the event
func updateEvent(_ event: EventModel, _ group: GroupModel, newMembers: [MemberModel], removeMembers: [AttendanceModel]) {

    let updateEventObserver = self.repository.updateEvent(group, event)
    var memberObservers: [Observable<AttendanceModel>] = []

    if newMembers.count > 0 {
        memberObservers.append(contentsOf: newMembers.map { (member) in
            return self.repository.inviteToEvent(member: member, event: event, group: group)
        })
    }

    if removeMembers.count > 0 {
        memberObservers.append(contentsOf: removeMembers.map { (member) in
            return self.repository.removeFromEvent(member: member, event: event, group: group)
        })
    }

    if memberObservers.count > 0 {

        Observable
            .zip(memberObservers)
            .subscribe(onNext: { (_) in
                updateEventObserver
                    .subscribe(onNext: { event in
                        self.presenter.eventSuccessfullyUpdated(event)
                    }, onError: { error in
                        self.presenter.failedWithError(error)
                    }).disposed(by: self.disposeBag)
            }, onError: { (error) in
                self.presenter.failedWithError(error)
            }).disposed(by: self.disposeBag)
    } else {
        updateEventObserver
            .subscribe(onNext: { event in
                self.presenter.eventSuccessfullyUpdated(event)
            }, onError: { error in
                self.presenter.failedWithError(error)
            }).disposed(by: self.disposeBag)
    }

}

我觉得我的代码很 "丑陋"，我觉得有更好的方法。谢谢你！我有一些代码应该是监听事件的，我觉得有更好的方法。

Answer 1

嗯，这个比较干净。

func updateEvent(_ event: EventModel, _ group: GroupModel, newMembers: [MemberModel], removeMembers: [AttendanceModel]) {

    let invitedResults = newMembers
        .compactMap { [repository] member in
            repository?.inviteToEvent(member: member, event: event, group: group)
        }

    let removedResults = removeMembers
        .compactMap { [repository] member in
            repository?.removeFromEvent(member: member, event: event, group: group)
        }

    Observable.zip(invitedResults + removedResults)
        .flatMap { [repository] _ in repository?.updateEvent(group, event) ?? .empty() }
        .subscribe(
            onNext: { [presenter] event in
                presenter?.eventSuccessfullyUpdated(event)
            },
            onError: { [presenter] error in
                presenter?.failedWithError(error)
            }
        )
        .disposed(by: disposeBag)
}

它避免了捕获自我，至少避免了一个保留周期。但如果 任何 的邀请或删除错误，它可能会让你的系统处于无效状态... ...