如何使用Combine实现我的MVP/Rxswift

通常我会这样组织代码（以简化的方式）：

func getSomething() {
    getManagerFuture()
        .sink { result in
            print(result)
        }
}

func getManagerFuture() -> Future<[MyBO], ManagerError> {
    
    Future { promise in
    getProviderFuture()
        .flatMap { dtoList -> ([MyBO], ManagerError) in
            
            let boList = dtoList.map { dto in
                return MyBO(id: dto.id, name: dto.name)
            }
            
            return promise(.success(boList))
        }
    }
}

func getProviderFuture() -> Future<[MyDTO], ProviderError> {

    // should be a webservice call
    
    let dto1 = MyDTO(id: 1, name: "one")
    let dto2 = MyDTO(id: 2, name: "two")
    
    return Future { promise in promise(.success([dto1, dto2])) }
}

演示者订阅我的模型（通过管理员）

管理器从提供程序调用getItems并将DTO->BO转换为：

func getItems(...) -> Single<myObectBO> {
    myProvider.getItems(...).map { myDTO in
        return MyObjectBO(withDTO: myDTO)
    }
}

func getItems（…）->Single{
myProvider.getItems（…）.map{myDTO-in
返回MyObjectBO（带dto:myDTO）
}
}

提供程序返回一个DTO：

func getItems(...) -> Single<myObectDTO> {
    ...
    return Single.just(myObectDTO)
}

func getItems（…）->Single{
...
返回单曲。仅（myobectdo）
}

我尝试了不同的方法，但目前我还没有找到在Combine中实现这一点的方法，有简单的方法吗？ 谢谢你的帮助

---

更清楚地说，我想这样做：

func getSomething() {
    getManagerFuture()
        .sink { result in
            print(result)
        }
}

func getManagerFuture() -> Future<[MyBO], ManagerError> {
    
    Future { promise in
    getProviderFuture()
        .flatMap { dtoList -> ([MyBO], ManagerError) in
            
            let boList = dtoList.map { dto in
                return MyBO(id: dto.id, name: dto.name)
            }
            
            return promise(.success(boList))
        }
    }
}

func getProviderFuture() -> Future<[MyDTO], ProviderError> {

    // should be a webservice call
    
    let dto1 = MyDTO(id: 1, name: "one")
    let dto2 = MyDTO(id: 2, name: "two")
    
    return Future { promise in promise(.success([dto1, dto2])) }
}

func getSomething（）{
getManagerFuture（）
.sink{导致
打印（结果）
}
}
func getManagerFuture（）->Future{
未来{
getProviderFuture（）
中的.flatMap{dtoList->（[MyBO]，ManagerError）
设boList=dtoList.map{dto in
返回MyBO（id:dto.id，name:dto.name）
}
回报承诺（.success（boList））
}
}
}
func getProviderFuture（）->Future{
//应该是一个webservice调用
设dto1=MyDTO（id:1，名称：“一”）
设dto2=MyDTO（id:2，名称：“2”）
返回未来{承诺中的承诺（.success（[dto1，dto2]）}
}

我在getManagerProvider上有以下错误：

实例方法“flatMap（maxPublishers:\）”需要以下类型 “（[MyBO]，ManagerError.Failure”和“Never”是等效的

类型“（[MyBO]，ManagerError）”不能与“Publisher”一致；只有 结构/枚举/类类型可以符合协议

---

我有这样的东西，在操场上很好

为了精确起见，最好删除发布服务器，以便能够在不更改代码外部的情况下更改实现

enum DTOError: Error {
  case wrongDTO
}

enum BOError: Error {
  case wrongBO
}

struct DTO {
  let value = "Value"
}

struct BO {
  let value: String
  init(dto: DTO) {
    self.value = dto.value
  }
}

func getDTO() -> AnyPublisher<DTO, DTOError> {
  Future { promise in
    promise(.success(DTO()))
  }
  .eraseToAnyPublisher()
}

func getBO() -> AnyPublisher<BO, BOError> {
  getDTO()
    .flatMap({ dto -> Future<BO, DTOError> in
      Future<BO, DTOError> { promise in
        promise(.success(BO(dto: dto)))
      }
    })
    .mapError { dtoError -> BOError in
      .wrongBO
    }
    .eraseToAnyPublisher()
}

getBO()
  .sink(receiveCompletion: { completion in
    print(completion)
  }) { data in
    print(data)
  }

enum DTOError:错误{
错案
}
枚举错误：错误{
错案
}
结构DTO{
让value=“value”
}
结构体{
let值：字符串
初始化（dto:dto）{
self.value=dto.value
}
}
func getDTO（）->AnyPublisher{
未来{
承诺（.success（DTO（）））
}
.删除任何发布者（）
}
func getBO（）->AnyPublisher{
getDTO（）
.flatMap（{dto->Future in
未来{
承诺（.success（BO（dto:dto）））
}
})
.mapError{dtoError->BOError在中
厄尔博先生
}
.删除任何发布者（）
}
getBO（）
.sink（receiveCompletion:{completion in
打印（完成）
}){中的数据
打印（数据）
}

---

也许有一个更简洁的解决方案，不过我有类似的东西，那就是在操场上做得很好

为了精确起见，最好删除发布服务器，以便能够在不更改代码外部的情况下更改实现

enum DTOError: Error {
  case wrongDTO
}

enum BOError: Error {
  case wrongBO
}

struct DTO {
  let value = "Value"
}

struct BO {
  let value: String
  init(dto: DTO) {
    self.value = dto.value
  }
}

func getDTO() -> AnyPublisher<DTO, DTOError> {
  Future { promise in
    promise(.success(DTO()))
  }
  .eraseToAnyPublisher()
}

func getBO() -> AnyPublisher<BO, BOError> {
  getDTO()
    .flatMap({ dto -> Future<BO, DTOError> in
      Future<BO, DTOError> { promise in
        promise(.success(BO(dto: dto)))
      }
    })
    .mapError { dtoError -> BOError in
      .wrongBO
    }
    .eraseToAnyPublisher()
}

getBO()
  .sink(receiveCompletion: { completion in
    print(completion)
  }) { data in
    print(data)
  }

enum DTOError:错误{
错案
}
枚举错误：错误{
错案
}
结构DTO{
让value=“value”
}
结构体{
let值：字符串
初始化（dto:dto）{
self.value=dto.value
}
}
func getDTO（）->AnyPublisher{
未来{
承诺（.success（DTO（）））
}
.删除任何发布者（）
}
func getBO（）->AnyPublisher{
getDTO（）
.flatMap（{dto->Future in
未来{
承诺（.success（BO（dto:dto）））
}
})
.mapError{dtoError->BOError在中
厄尔博先生
}
.删除任何发布者（）
}
getBO（）
.sink（receiveCompletion:{completion in
打印（完成）
}){中的数据
打印（数据）
}

---

可能有一个更简洁的解决方案，但具体实现什么？并发症到底在哪里？具体实施什么？并发症到底在哪里？