在我的应用程序中,用户可以执行一些操作,包括redo支持。

因此,我觉得有必要通过对象化Action进行管理,并按如下方式实现它。

1.实施 RecoverableAction

abstract class RecoverableAction {
    abstract fun getActionName(): String
    abstract fun run()
    abstract fun undoActionName(): String

    enum class List(val action: RecoverableAction) {
        CONTAINER_CREATE(ContainerActions.CREATE),
        CONTAINER_COPY(ContainerActions.COPY),
        CONTAINER_DELETE(ContainerActions.DELETE)
    }
}

2.为Actions实现 Redo
    class ContainerActions private constructor() {
        companion object {
            val CREATE = object : RecoverableAction {
                override fun run() {
                    //do create
                }
                override fun getActionName() = List.CONTAINER_CREATE.name
                override fun undoActionName() = List.CONTAINER_DELETE.name
            }

            val DELETE = object : RecoverableAction {
                override fun run() {
                    //do create
                }
                override fun getActionName() = List.CONTAINER_CREATE.name
                override fun undoActionName() = List.CONTAINER_DELETE.name
            }

            val COPY = object : RecoverableAction {
                override fun run() {
                    //do copy
                }
                override fun getActionName() = List.CONTAINER_CREATE.name
                override fun undoActionName() = List.CONTAINER_DELETE.name
            }
        }
    }

3. 在任何地方进行Action 2种方式
    CotainerActions.CREATE.run()
    RecoverableAction.List.CONTAINER_COPY.action.run()

我不喜欢使用static变量,但是我不希望每次从用户执行时都实例化每个Action。我还将其实现为companion,以便可以直接从几个不同的类中运行相应的Action

另外,我需要通过将用户执行的 Action 作为redo进行管理来实现stack函数。我将RecoverableAction支持的Action实现为enum的原因是,我想通过Action record stack而不是nameAction object中管理它。

我一直在考虑设计实现这些要求的结构,但我认为这可能是一个很好的结构。这是“好方法”吗?

最佳答案

对我来说,



看起来很乱。

为什么不:

sealed class RecoverableActions {
    abstract val actionName: String

    abstract val undoActionName: String

    abstract fun run()

    object CreateAction : RecoverableActions() {
        override fun run() {
            //do create
        }
        override val actionName = CreateAction::class.java.simpleName
        override val undoActionName = DeleteAction::class.java.simpleName
    }

    object DeleteAction : RecoverableActions() {
        override fun run() {
            //do create
        }
        override val actionName = DeleteAction::class.java.simpleName
        override val undoActionName = CreateAction::class.java.simpleName
    }

    object CopyAction : RecoverableActions() {
        override fun run() {
            //do create
        }
        override val actionName = CopyAction::class.java.simpleName
        override val undoActionName = CopyAction::class.java.simpleName // ?
    }
}


RecoverableActions.CreateAction.run()

07-24 09:49
查看更多