我正在学习状态模式(有限状态机) 在我构建的示例项目中，我发现更新 UI 的唯一方法是将呈现 View 的引用传递给状态机，然后从我正在工作的状态更新 UI。我做错了吗？?

这是我的状态机

class CapturePhotoStateMachine {
    var noPictureTakenState: NoPictureTakenState?
    var pictureTakenState: PictureTakenState?
    var initialState: InitialState?
    var vc: SignupAvatarView?

    var capturePhotoState: CapturePhotoState?

    init(viewController: SignupAvatarView) {
        noPictureTakenState = NoPictureTakenState(stateMachine: self)
        pictureTakenState = PictureTakenState(stateMachine: self)
        initialState = InitialState(stateMachine: self)
        vc = viewController
        capturePhotoState = initialState
    }

    func setCapturePhotoState(newState: CapturePhotoState) {
        self.capturePhotoState = newState
    }

    func takePicture() {
        self.capturePhotoState?.takePicture()
    }

    func savePicture(image: UIImage) {
        self.capturePhotoState?.savePicture(image: image)
    }


    func retakePicture() {
        self.capturePhotoState?.retakePicture()
    }

    func setup() {
        self.capturePhotoState?.setup()
    }
}

这是我的协议(protocol)

protocol CapturePhotoState {
    func takePicture()
    func savePicture(image: UIImage)
    func retakePicture()
    func setup()
}

这是状态的一个子类

class NoPictureTakenState: CapturePhotoState {

    var stateMachine: CapturePhotoStateMachine?

    init(stateMachine: CapturePhotoStateMachine) {
        self.stateMachine = stateMachine
    }

    func takePicture() {
        stateMachine!.vc?.previewView.isHidden = true
        stateMachine!.vc?.capturedImage.isHidden = false
        stateMachine!.vc?.saveButton.isHidden = false
        stateMachine!.vc?.retakePhoto.isHidden = false
        stateMachine?.setCapturePhotoState(newState: (stateMachine?.pictureTakenState)!)
    }

    func savePicture(image: UIImage) {
    }

    func retakePicture() {}

    func setup() {}
}

最佳答案

状态机用途的关键似乎是您拥有要根据状态启用或禁用的接口(interface)对象。启用/禁用应该是 View Controller 的工作。状态本身只是回答诸如“当前情况如何”和“接下来应该发生什么”等问题的基础。

这里有一个简短的状态机示例来说明。这是故意的琐碎。我们只有两个按钮，只有两个状态；在每种状态下，应该只启用一个按钮。状态由枚举的情况表示，我们在该枚举上使用 setter 观察器以在状态更改时做出响应。枚举封装了有多少个状态以及下一个状态是什么的逻辑，而 View Controller 在状态变化和界面变化之间进行调解:

class ViewController: UIViewController {
    @IBOutlet weak var takePictureButton: UIButton!
    @IBOutlet weak var deletePictureButton: UIButton!
    @IBOutlet weak var pictureImageView: UIImageView! // not used in the example

    @IBAction func doTakePicture(_ sender: Any) {
        // do stuff
        doNextState()
    }

    @IBAction func doDeletePicture(_ sender: Any) {
        // do stuff
        doNextState()
    }

    enum State {
        case pictureNotTaken
        case pictureTaken
        var nextState : State {
            switch self {
            case .pictureNotTaken:
                return .pictureTaken
            case .pictureTaken:
                return .pictureNotTaken
            }
        }
    }
    var state : State = .pictureNotTaken {
        didSet {
            updateInterface()
        }
    }
    func doNextState() {
        self.state = self.state.nextState // triggers the setter observer
    }
    func updateInterface() {
        switch state {
        case .pictureNotTaken:
            takePictureButton.isEnabled = true
            deletePictureButton.isEnabled = false
        case .pictureTaken:
            takePictureButton.isEnabled = false
            deletePictureButton.isEnabled = true
        }
    }
}

您可能需要对该模式进行一些扩展。

the only way that I figured out to update the UI is to pass a reference of the presenting view to the state machine

这就是上面的模式没有做的事情。 setter observer 为我们解决了这个问题。

现在，您可能会反对 updateInterface 中的 switch 语句做了错误的工作。它将界面如何反射(reflect)状态的知识完全放在 View Controller 中。你的冲动是说知识肯定是状态的一部分(这就是你按照你的方式构建代码的原因)。

我的回答是:好吧，是的，也不是。有时我确实有这种感觉，我解决问题的方法是赋予状态机属性，表达 View Controller 可能对当前状态意味着关于界面的所有问题。这样一来，知识就被转移到了状态中，但是界面仍然正确地由 View Controller 控制。

因此，例如，我们可以将这两个属性添加到我们的 State 枚举中:

enum State {
    // ... everything else is as before ...
    var userCanTakePicture : Bool { return self == .pictureNotTaken }
    var userCanDeletePicture : Bool { return self == .pictureTaken }
}

所以，现在，我们的 updateInterface 不需要任何关于每个状态含义的特殊知识；它只是询问状态接口(interface)应该是什么，这更简单并且可能提供更令人满意的权力分离:

func updateInterface() {
    self.takePictureButton.isEnabled = state.userCanTakePicture
    self.deletePictureButton.isEnabled = state.userCanDeletePicture
}

关于swift - 我是否正确使用了状态模式？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/53529070/