我有以下场景-我正在使用ReactiveSwift的Action在我的应用程序中触发网络请求。由于对网络请求的响应进行了处理,因此该网络请求可能很昂贵。因此,当调用方尝试应用该操作时,我希望执行以下操作:
确定操作是否已在进行中
如果是,则返回一个观察进行中操作结果的信号生产者
如果不是,则返回启动时将应用该操作的信号生产者
理想情况下,解决方案是线程安全的,因为调用方可能会尝试从不同的线程应用Action
现在,我使用ReactiveSwift中的缓存示例设法拼凑出一些有用的东西,但我几乎可以肯定我做错了什么,特别是当MutableProperty完成时,如何将nil重置为Action。注意,我还使用静态变量来确保UseCase的多个实例不能绕过我的预期行为。此外,我的示例信号Never输出,但在现实世界中,它们可能:

class UseCase {
  private static let sharedAction = Action<Void, Never, AnyError> {
    return SignalProducer.empty.delay(10, on: QueueScheduler.main).on(completed: {
      print("Done")
      UseCase.sharedProducer.value = nil
    })
  }
  private static let sharedProducer = MutableProperty<SignalProducer<Never, AnyError>?>(nil)

  func sync() -> SignalProducer<Never, AnyError> {
    let result = UseCase.sharedProducer.modify { value -> Result<SignalProducer<Never, AnyError>, NoError> in
        if let inProgress = value {
          print("Using in progress")
          return Result(value: inProgress)
        } else {
          print("Starting new")
          let producer = UseCase.sharedAction.apply().flatMapError { error -> SignalProducer<Never, AnyError> in
              switch error {
              case .disabled:                   return SignalProducer.empty
              case .producerFailed(let error):  return SignalProducer(error: error)
              }
            }.replayLazily(upTo: 1)

          value = producer
          return Result(value: producer)
        }
    }

    guard let producer = result.value else {
      fatalError("Unexpectedly found nil producer")
    }

    return producer
  }
}

最佳答案

这也可能有点冗长,但至少应该更容易理解。你可以问任何问题。
注意:我让这个对象自己开始处理,而不是返回调用方将启动的SignalProducer。相反,我添加了一个只读属性,监听器可以在不启动处理的情况下观察该属性。
我试图让我的观察者尽可能被动,从而使他们更“被动”而不是“主动”。这种模式应该适合你的需要,尽管它有点不同。
我试图让这个例子包括:
共享单个工作单元的结果。
错误处理。
信号保持的最佳实践。
一般解释在评论中,因为好的教程很难找到。
对不起,如果我在解释你已经知道的事情。我不知道你知道多少。
模拟处理延迟(在生产代码中删除)。
它远不是完美的,但应该提供一个坚实的模式,你可以修改和扩展。

struct MyStruct {}

final class MyClass {
    // MARK: Shared Singleton
    static let shared = MyClass()

    // MARK: Initialization
    private init() {}

    // MARK: Public Stuff
    @discardableResult
    func getValue() -> Signal<MyStruct, NoError> {

        if !self.isGettingValue {
            print("Get value")
            self.start()
        } else {
            print("Already getting value.")
        }

        return self.latestValue
            .signal
            .skipNil()
    }
    var latestValue: Property<MyStruct?> {
        // By using a read-only property, the listener can:
        // 1. Choose to take/ignore the previous value.
        // 2. Choose to listen via Signal, SignalProducer, or binding operator '<~'
        return Property(self.latestValueProperty)
    }

    // MARK: Private Stuff
    private var latestValueProperty = MutableProperty<MyStruct?>(nil)

    private var isGettingValue = false {
        didSet { print("isGettingValue: changed from '\(oldValue)' to '\(self.isGettingValue)'") }
    }

    private func start() {
        // Binding with `<~` automatically starts the SignalProducer with the binding target (our property) as its single listener.
        self.latestValueProperty <~ self.newValueProducer()

            // For testing, delay signal to mock processing time.
            // TODO: Remove in actual implementation.
            .delay(5, on: QueueScheduler.main)

            // If `self` were not a Singleton, this would be very important.
            // Best practice says that you should hold on to signals and producers only as long as you need them.
            .take(duringLifetimeOf: self)

            // In accordance with best practices, take only as many as you need.
            .take(first: 1)

            // Track status.
            .on(
                starting: { [unowned self] in
                    self.isGettingValue = true
                },
                event: { [unowned self] event in
                    switch event {
                    case .completed, .interrupted:
                        self.isGettingValue = false
                    default:
                        break
                    }
                }
            )
    }

    private func newValueProducer() -> SignalProducer<MyStruct?, NoError> {
        return SignalProducer<MyStruct?, AnyError> { observer, lifetime in

            // Get Struct with possible error
            let val = MyStruct()

            // Send and complete the signal.
            observer.send(value: val)
            observer.sendCompleted()

            }

            // Don't hold on to errors longer than you need to.
            // I like to handle them as close to the source as I can.
            .flatMapError { [unowned self] error in
                // Deal with error
                self.handle(error: error)

                // Transform error type from `AnyError` to `NoError`, to signify that the error has been handled.
                // `.empty` returns a producer that sends no values and completes immediately.
                // If you wanted to, you could return a producer that sends a default or alternative value.
                return SignalProducer<MyStruct?, NoError>.empty
        }
    }

    private func handle(error: AnyError) {

    }
}

测试
// Test 1: Start processing and observe the results.
MyClass.shared
    .getValue()
    .take(first: 1)
    .observeValues { _ in
        print("Test 1 value received.")
}

// Test 2: Attempt to start (attempt ignored) and observe the same result from Test 1.
MyClass.shared
    .getValue()
    .take(first: 1)
    .observeValues { _ in
        print("Test 2 value received.")
}

// Test 3: Observe Value from Test 1 without attempting to restart.
MyClass.shared
    .latestValue
    .signal
    .skipNil()
    .take(first: 1)
    .observeValues { _ in
        print("Test 3 value received.")
}

// Test 4: Attempt to restart processing and discard signal
MyClass.shared.getValue()

输出:
Get value
isGettingValue: changed from 'false' to 'true'
Already getting value.
Already getting value.

(5秒后)
Test 1 value received.
Test 2 value received.
Test 3 value received.
isGettingValue: changed from 'true' to 'false'

关于ios - 如何多播进行中的结果操作或开始新的结果,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/50429108/

10-12 14:30
查看更多