2

我有一些昂贵的承诺会在不同的地方被调用。理想情况下，我只想链接现有的飞行中的承诺（带有可选的力量），所以我发现自己在做这样的事情：

class Expensive {
  var fooPromise : Promise<Foo>?
  var barPromise : Promise<Bar>?

  func doExpensiveFoo(force: bool = false) -> Promise<Foo> {
    if let existing = fooPromise where existing.pending || (existing.fufilled && !force) {
      // Return the existing promise
      return existing
    }

    // Start a new Foo
    return firstly {
       // ...
    }
  }

  func doExpensiveBar(force: bool = false) -> Promise<Bar> {
    if let existing = barPromise where existing.pending || (existing.fufilled && !force) {
      // Return the existing promise
      return existing
    }

    // Start a new Bar
    return firstly {
       // ...
    }
  }
}

但这感觉像是相当多的样板（每个承诺的局部变量，以及每个函数开头的现有块），所以我想知道是否有人看到了抽象变量和包装器的好模式?

借用 Python 的一个术语，我正在寻找一个可以隐藏所有这些的装饰器。就像是：

class Expensive {

  private func startFoo() -> Promise<Foo> {
    return firstly {
       //..
    }
  }

  public doExpensiveFoo = wrapExpensive(startFoo)

}

有什么建议，还是我应该考虑自己动手？

4

2 回答 2

1

我不是专家，但这种模式对我有用：

private var fooPromise : Promise<Foo>?

func doExpensiveFoo() -> Promise<Foo> {
    if let fooPromise = self.fooPromise, fooPromise.isPending {
        // return the pending promise
        return fooPromise
    }

    // reassign a newly created promise
    fooPromise = firstly { 
        // do your thing
        ...
    }

    return fooPromise!
  }

我喜欢这种模式的地方在于，该方法在内部处理挂起状态，并且如果在完成后调用，promise 会自动重新执行。这允许调用者对内部机制或承诺的状态一无所知。显然，如果您需要调用者成为决策的一部分，那么请保留“强制”标志方法。

于 2017-07-21T13:06:08.870 回答
0

在您的示例中，我没有看到 Foo 和 Bar 的任何共同基础。但即使他们有一个 Swift 仍然不支持泛型类型参数的协变。首先，您需要为这两种类型创建一个通用协议。也许这可以帮助您走上正轨：

在 Swift 数组中存储通用对象

于 2016-04-13T20:32:11.860 回答