Question

我试图了解如何使用对象列表和UICollectionView实现MVVM。我不了解如何实现用户迭代->模型流程。

我已经设置了一个test application，Model只是一个带有Int的类，而View是一个UICollectionViewCell，它显示带有相应Int值的文本，并具有加，减和删除按钮以进行增，减并分别删除一个元素。每个条目看起来像：我想知道使用MVVM和RxSwift更新/删除单元格的最佳方法。

我有一个随机生成的Int值列表

let items: [Model]

仅具有Int值的模型

class Model {
    var number: Int

    init(_ n: Int = 0) {
        self.number = n
    }
}

仅包含模型并具有Observable的ViewModel类

class ViewModel {

    var value: Observable<Model>

    init(_ model: Model) {
        self.value = Observable.just(model)
    }
}

还有细胞

class Cell : UICollectionViewCell {
    class var identifier: String { return "\(self)" }

    var bag = DisposeBag()

    let label: UILabel
    let plus: UIButton
    let minus: UIButton
    let delete: UIButton
....
    var viewModel: ViewModel? = nil {
        didSet {
        ....
            viewModel.value
                .map({ "number is \($0.number)" })
                .asDriver(onErrorJustReturn: "")
                .drive(self.label.rx.text)
                .disposed(by: self.bag)
        ....
        }
    }
}

我不清楚该怎么做，是如何将按钮连接到相应的动作，然后再更新模型和视图。

Cell的ViewModel负责吗？应该是接收tap事件，更新Model然后更新视图的人吗？

在删除情况下，单元格的删除按钮需要从数据列表中删除当前模型。如何在不将所有内容混合在一起的情况下完成此操作？

Answer 1

以下是GitHub中具有以下更新的项目：https://github.com/dtartaglia/RxCollectionViewTester

我们要做的第一件事是概述所有输入和输出。输出应该是视图模型结构的成员，输入应该是输入结构的成员。

在这种情况下，我们从单元格中获得了三个输入：

struct CellInput {
    let plus: Observable<Void>
    let minus: Observable<Void>
    let delete: Observable<Void>
}

单元格本身的一个输出（标签），单元格父级的两个输出（可能是视图控制器的视图模型）。

struct CellViewModel {
    let label: Observable<String>
    let value: Observable<Int>
    let delete: Observable<Void>
}

我们还需要设置单元格以接受工厂功能，以便它可以创建视图模型实例。该单元还需要能够重置自身：

class Cell : UICollectionViewCell {

    var bag = DisposeBag()

    var label: UILabel!
    var plus: UIButton!
    var minus: UIButton!
    var delete: UIButton!

    // code to configure UIProperties omitted. 

    override func prepareForReuse() {
        super.prepareForReuse()
        bag = DisposeBag() // this resets the cell's bindings
    }

    func configure(with factory: @escaping (CellInput) -> CellViewModel) {
        // create the input object
        let input = CellInput(
            plus: plus.rx.tap.asObservable(),
            minus: minus.rx.tap.asObservable(),
            delete: delete.rx.tap.asObservable()
        )
        // create the view model from the factory
        let viewModel = factory(input)
        // bind the view model's label property to the label
        viewModel.label
            .bind(to: label.rx.text)
            .disposed(by: bag)
    }
}

现在，我们需要构建视图模型的init方法。这是所有实际工作发生的地方。

extension CellViewModel {
    init(_ input: CellInput, initialValue: Int) {
        let add = input.plus.map { 1 } // plus adds one to the value
        let subtract = input.minus.map { -1 } // minus subtracts one

        value = Observable.merge(add, subtract)
            .scan(initialValue, accumulator: +) // the logic is here

        label = value
            .startWith(initialValue)
            .map { "number is \($0)" } // create the string from the value
        delete = input.delete // delete is just a passthrough in this case
    }
}

您会注意到，视图模型的init方法比工厂功能提供的更多。视图控制器在创建工厂时将提供额外的信息。

视图控制器将在其viewDidLoad中添加它：

viewModel.counters
    .bind(to: collectionView.rx.items(cellIdentifier: "Cell", cellType: Cell.self)) { index, element, cell in
        cell.configure(with: { input in
            let vm = CellViewModel(input, initialValue: element.value)
            // Remember the value property tracks the current value of the counter
            vm.value
                .map { (id: element.id, value: $0) } // tell the main view model which counter's value this is
                .bind(to: values)
                .disposed(by: cell.bag)

            vm.delete
                .map { element.id } // tell the main view model which counter should be deleted
                .bind(to: deletes)
                .disposed(by: cell.bag)
            return vm // hand the cell view model to the cell
        })
    }
    .disposed(by: bag)

对于上述示例，我假设：

counters类型为Observable<[(id: UUID, value: Int)]>，来自视图控制器的视图模型。
values类型为PublishSubject<(id: UUID, value: Int)>，并输入到视图控制器的视图模型中。
deletes类型为PublishSubject<UUID>，并输入到视图控制器的视图模型中。

视图控制器的视图模型的构建遵循与单元格相同的模式：

输入：

struct Input {
    let value: Observable<(id: UUID, value: Int)>
    let add: Observable<Void>
    let delete: Observable<UUID>
}

输出：

struct ViewModel {
    let counters: Observable<[(id: UUID, value: Int)]>
}

逻辑：

extension ViewModel {
    private enum Action {
        case add
        case value(id: UUID, value: Int)
        case delete(id: UUID)
    }

    init(_ input: Input, initialValues: [(id: UUID, value: Int)]) {
        let addAction = input.add.map { Action.add }
        let valueAction = input.value.map(Action.value)
        let deleteAction = input.delete.map(Action.delete)
        counters = Observable.merge(addAction, valueAction, deleteAction)
            .scan(into: initialValues) { model, new in
                switch new {
                case .add:
                    model.append((id: UUID(), value: 0))
                case .value(let id, let value):
                    if let index = model.index(where: { $0.id == id }) {
                        model[index].value = value
                    }
                case .delete(let id):
                    if let index = model.index(where: { $0.id == id }) {
                        model.remove(at: index)
                    }
                }
        }
    }
}

Answer 2

我正在这样做：

ViewModel.swift

import Foundation
import RxSwift
import RxCocoa

typealias Model = (String, Int)

class ViewModel {
    let disposeBag = DisposeBag()
    let items = BehaviorRelay<[Model]>(value: [])
    let add = PublishSubject<Model>()
    let remove = PublishSubject<Model>()
    let addRandom = PublishSubject<()>()

    init() {
        addRandom
            .map { _ in (UUID().uuidString, Int.random(in: 0 ..< 10)) }
            .bind(to: add)
            .disposed(by: disposeBag)
        add.map { newItem in self.items.value + [newItem] }
            .bind(to: items)
            .disposed(by: disposeBag)
        remove.map { removedItem in
            self.items.value.filter { (name, _) -> Bool in
                name != removedItem.0
            }
            }
            .bind(to: items)
            .disposed(by: disposeBag)
    }
}

Cell.swift

import Foundation
import Material
import RxSwift
import SnapKit

class Cell: Material.TableViewCell {
    var disposeBag: DisposeBag?
    let nameLabel = UILabel(frame: .zero)
    let valueLabel = UILabel(frame: .zero)
    let removeButton = FlatButton(title: "REMOVE")

    var model: Model? = nil {
        didSet {
            guard let (name, value) = model else {
                nameLabel.text = ""
                valueLabel.text = ""
                return
            }
            nameLabel.text = name
            valueLabel.text = "\(value)"
        }
    }

    override func prepare() {
        super.prepare()
        let textWrapper = UIStackView()
        textWrapper.axis = .vertical
        textWrapper.distribution = .fill
        textWrapper.alignment = .fill
        textWrapper.spacing = 8

        nameLabel.font = UIFont.boldSystemFont(ofSize: 24)
        textWrapper.addArrangedSubview(nameLabel)
        textWrapper.addArrangedSubview(valueLabel)

        let wrapper = UIStackView()
        wrapper.axis = .horizontal
        wrapper.distribution = .fill
        wrapper.alignment = .fill
        wrapper.spacing = 8
        addSubview(wrapper)
        wrapper.snp.makeConstraints { make in
            make.edges.equalToSuperview().inset(8)
        }
        wrapper.addArrangedSubview(textWrapper)
        wrapper.addArrangedSubview(removeButton)
    }
}

ViewController.swift

import UIKit
import Material
import RxSwift
import SnapKit

class ViewController: Material.ViewController {
    let disposeBag = DisposeBag()
    let vm = ViewModel()

    let tableView = UITableView()
    let addButton = FABButton(image: Icon.cm.add, tintColor: .white)

    override func prepare() {
        super.prepare()

        view.addSubview(tableView)
        tableView.snp.makeConstraints { make in
            make.edges.equalToSuperview()
        }

        addButton.pulseColor = .white
        addButton.backgroundColor = Color.red.base
        view.layout(addButton)
            .width(48)
            .height(48)
            .bottomRight(bottom: 16, right: 16)
        addButton.rx.tap
            .bind(to: vm.addRandom)
            .disposed(by: disposeBag)

        tableView.register(Cell.self, forCellReuseIdentifier: "Cell")
        vm.items
            .bind(to: tableView.rx.items) { (tableView, row, model) in
                let cell = tableView.dequeueReusableCell(withIdentifier: "Cell") as! Cell
                cell.model = model
                cell.disposeBag = DisposeBag()
                cell.removeButton.rx.tap
                    .map { _ in model }
                    .bind(to: self.vm.remove)
                    .disposed(by: cell.disposeBag!)
                return cell
            }
            .disposed(by: disposeBag)
    }
}

请注意，常见的错误是在Cell内仅创建一次DisposeBag，这将在触发操作时引起混乱。

每次重新使用Cell时，都必须重新创建 DisposeBag 。

可以找到完整的工作示例here。

如何使用MVVM和RxSwift编辑和删除UICollectionView单元格

2 个答案: