Лучшая архитектура для ViewModels (RxSwift)

Question

Я хочу использовать архитектурный дизайн, который позволяет мне четко обозначать входные и выходные данные в моей модели представления ( Как кормить ViewModels ), но мне интересно, как я могу наилучшим образом интегрировать "работу""часть модели представления в эту структуру.

Я склонен использовать Действия (возможно, не очень элегантно), чтобы связать элементы пользовательского интерфейса с работой, которую они должны выполнить.Проблема, конечно, заключается в том, что некоторые из этих действий основаны на свойствах модели представления, поэтому я не могу создать их в init () в том же виде, что и для Input и Outputs, поскольку свойства еще не инициализированы.Можно обойти это, определив их как частные ленивые переменные, а затем выставив их через структуру, которая по сути представляет открытый интерфейс для Action.Хотя, кажется, что это не очень хорошо, и я узнаю, что если вы затрачиваете много усилий, чтобы заставить структуру подчиниться вашей воле, это, вероятно, запах кода.Пример кода ниже - предложения приветствуются: -)

protocol PatientListViewModelType: ViewModelType { }

final class PatientListViewModel: PatientListViewModelType {
    // MARK:- Protocol conformance
    typealias Dependencies =  HasPatientService

    struct Input {
        let patient: AnyObserver<Patient>
    }
    struct Output {
        let sectionedPatients: Observable<[PatientSection]>
        let patient: Observable<Patient>
    }
    let input: Input
    let output: Output

    struct Actions {
        let deletePatient: Action<Patient, Void>
        let togglePatient: (Patient) -> CocoaAction
        let updatePatient: (Patient) -> Action<String, Void>
    }

    lazy var action: Actions = Actions(deletePatient: self.deletePatient,
                                       togglePatient: self.togglePatient,
                                       updatePatient: self.updatePatient)

    // MARK: Setup
    private let dependencies: Dependencies
    private let patientSubject = ReplaySubject<Patient>.create(bufferSize: 1)

    // MARK:- Init
    init(dependencies: Dependencies) {
        self.dependencies = dependencies

        let sectionedPatients =
            dependencies.patientService.patients()
                .map { results -> [PatientSection] in
                    let scheduledPatients = results
                        .filter("checked == nil")
                        .sorted(byKeyPath: "created", ascending: false)

                    let admittedPatients = results
                        .filter("checked != nil")
                        .sorted(byKeyPath: "checked", ascending: false)

                    return [
                        PatientSection(model: "Scheduled Patients", items: scheduledPatients.toArray()),
                        PatientSection(model: "Admitted Patients", items: admittedPatients.toArray())
                    ]
        }

        self.output = Output(sectionedPatients: sectionedPatients,
                             patient: patientSubject.asObservable() )
        // this is immediately overriden during binding to VC - it just allows us to exit the init without errors
        self.input = Input(patient: patientSubject.asObserver())


    }

    // MARK:- Actions        
    private lazy var deletePatient: Action<Patient, Void> = { (service: PatientServiceType) in
        return Action { patient in
            return service.delete(realmObject: patient)
        }
    }(self.dependencies.patientService)

    lazy var togglePatient: (Patient) -> CocoaAction = { [unowned self] (patient: Patient) -> CocoaAction in
        return CocoaAction {
            return self.dependencies.patientService.toggle(patient: patient).map { _ in }
        }
    }

    private lazy var updatePatient: (Patient) -> Action<String, Void> = { [unowned self] (patient: Patient) in
        return Action { newName in
            return self.dependencies.patientService.update(patient: patient, name: newName).map { _ in }
        }
    }
}

Answer 1

Ответ на самом деле достаточно прост, как только у меня появляется возможность сесть и поиграть. Я поместил действия в выходную структуру (как это казалось наиболее логичным местом), а не создавал выделенный интерфейс, как раньше. Следующий вопрос, конечно же, заключается в том, являются ли Действия наиболее подходящими для этой проблемы, но об этом я расскажу позже ...

final class PatientListViewModel: PatientListViewModelType {
    // MARK:- Protocol conformance
    typealias Dependencies =  HasPatientService

    struct Input {
        let patient: AnyObserver<Patient>
    }
    let input: Input

    struct Output {
        let sectionedPatients: Observable<[PatientSection]>
        let patient: Observable<Patient>
        let deletePatient: Action<Patient, Void>
        let togglePatient: (Patient) -> CocoaAction
        let updatePatient: (Patient) -> Action<String, Void>
    }
    let output: Output

    // MARK: Setup
    private let dependencies: Dependencies
    private let patientSubject = ReplaySubject<Patient>.create(bufferSize: 1)

    // MARK:- Init
    init(dependencies: Dependencies) {
        self.dependencies = dependencies

        let sectionedPatients =
            dependencies.patientService.patients()
                .map { results -> [PatientSection] in
                    let scheduledPatients = results
                        .filter("checked == nil")
                        .sorted(byKeyPath: "created", ascending: false)

                    let admittedPatients = results
                        .filter("checked != nil")
                        .sorted(byKeyPath: "checked", ascending: false)

                    return [
                        PatientSection(model: "Scheduled Patients", items: scheduledPatients.toArray()),
                        PatientSection(model: "Admitted Patients", items: admittedPatients.toArray())
                    ]
        }

        let deletePatient: Action<Patient, Void> = { patientService in
            return Action { patient in
                return patientService.delete(realmObject: patient)
            }
        }(dependencies.patientService)

        let togglePatient: (Patient) -> CocoaAction = { patient in
            return CocoaAction {
                return dependencies.patientService.toggle(patient: patient)
                    .map { _ in }
            }
        }

        let updatePatient: (Patient) -> Action<String, Void> = { patient in
            return Action { newName in
                return dependencies.patientService.update(patient: patient, name: newName)
                    .map { _ in }
            }
        }

        // this is immediately overriden during binding to VC - it just allows us to exit the init without errors
        self.input = Input(patient: patientSubject.asObserver())

        self.output = Output(sectionedPatients: sectionedPatients,
                             patient: patientSubject.asObservable(),
                             deletePatient: deletePatient,
                             togglePatient: togglePatient,
                             updatePatient: updatePatient)
    }