在R中实现标准软件设计模式(专注于MVC)

Question

目前,我正在阅读很多关于软件工程,软件设计,设计模式等的内容.来自完全不同的背景,这对我来说都是新的迷人的东西,所以如果我没有使用正确的技术术语,请耐心等待我描述某些方面;-)

我最终在大部分时间都使用了引用类(R中的OOP方法),因为面向对象似乎是我正在做的很多东西的正确选择.

现在,我想知道是否有人在R中实现MVC(模型视图控制器;也称为MVP:模型视图展示器)模式方面有一些好的建议或经验,最好使用参考类.

我也对其他"标准"设计模式(如观察者,黑板等)的信息非常感兴趣,但我不想让这个问题过于宽泛.我想最酷的事情是看到一些最小的示例代码,但任何指针,"架构",图表或任何其他想法也将非常感谢!

对于那些对类似内容感兴趣的人,我真的可以推荐以下书籍:

1. 务实的程序员
2. 设计模式

更新2012-03-12

我最终想出了一个我对MVC的解释的一个小例子(可能不完全正确;-)).

包依赖性

require("digest")

类定义观察者

setRefClass(
    "Observer",
    fields=list(
        .X="environment"
    ),
    methods=list(
        notify=function(uid, ...) {
            message(paste("Notifying subscribers of model uid: ", uid, sep=""))
            temp <- get(uid, .self$.X)
            if (length(temp$subscribers)) {
                # Call method updateView() for each subscriber reference
                sapply(temp$subscribers, function(x) {
                    x$updateView()        
                })
            }    
            return(TRUE)
        }
    )
)

类定义模型

setRefClass(
    "Model",
    fields=list(
        .X="data.frame",
        state="character",
        uid="character",
        observer="Observer"
    ),
    methods=list(
        initialize=function(...) {
            # Make sure all inputs are used ('...')
            .self <- callSuper(...)
            # Ensure uid
            .self$uid <- digest(c(.self, Sys.time()))
            # Ensure hash key of initial state
            .self$state <- digest(.self$.X)
            # Register uid in observer
            assign(.self$uid, list(state=.self$state), .self$observer$.X)
            .self
        },
        multiply=function(x, ...) {
            .self$.X <- .X * x 
            # Handle state change
            statechangeDetect()
            return(TRUE)
        },
        publish=function(...) {
            message(paste("Publishing state change for model uid: ", 
                .self$uid, sep=""))
            # Publish current state to observer
            if (!exists(.self$uid, .self$observer$.X)) {
                assign(.self$uid, list(state=.self$state), .self$observer$.X)
            } else {
                temp <- get(.self$uid, envir=.self$observer$.X)
                temp$state <- .self$state
                assign(.self$uid, temp, .self$observer$.X)    
            }
            # Make observer notify all subscribers
            .self$observer$notify(uid=.self$uid)
            return(TRUE)
        },
        statechangeDetect=function(...) {
            out <- TRUE
            # Hash key of current state
            state <- digest(.self$.X)
            if (length(.self$state)) {
                out <- .self$state != state
                if (out) {
                # Update state if it has changed
                    .self$state <- state
                }
            }    
            if (out) {
                message(paste("State change detected for model uid: ", 
                   .self$uid, sep=""))
                # Publish state change to observer
                .self$publish()
            }    
            return(out)
        }
    )
)

类定义控制器和视图

setRefClass(
    "Controller",
    fields=list(
        model="Model",
        views="list"
    ),
    methods=list(
        multiply=function(x, ...) {
            # Call respective method of model
            .self$model$multiply(x) 
        },
        subscribe=function(...) {
            uid     <- .self$model$uid
            envir   <- .self$model$observer$.X 
            temp <- get(uid, envir)
            # Add itself to subscribers of underlying model
            temp$subscribers <- c(temp$subscribers, .self)
            assign(uid, temp, envir)    
        },
        updateView=function(...) {
            # Call display method of each registered view
            sapply(.self$views, function(x) {
                x$display(.self$model)    
            })
            return(TRUE)
        }
    )
)
setRefClass(
    "View1",
    methods=list(
        display=function(model, x=1, y=2, ...) {
            plot(x=model$.X[,x], y=model$.X[,y])
        }
    )
)
setRefClass(
    "View2",
    methods=list(
        display=function(model, ...) {
            print(model$.X)
        }
    )
)

用于表示虚拟数据的类定义

setRefClass(
    "MyData",
    fields=list(
        .X="data.frame"
    ),
    methods=list(
        modelMake=function(...){
            new("Model", .X=.self$.X)
        }
    )
)

创建实例

x <- new("MyData", .X=data.frame(a=1:3, b=10:12))

研究模型特征和观察者状态

mod <- x$modelMake()
mod$.X

> mod$uid
[1] "fdf47649f4c25d99efe5d061b1655193"
# Field value automatically set when initializing object.
# See 'initialize()' method of class 'Model'.

> mod$state
[1] "6d95a520d4e3416bac93fbae88dfe02f"
# Field value automatically set when initializing object.
# See 'initialize()' method of class 'Model'.

> ls(mod$observer$.X)
[1] "fdf47649f4c25d99efe5d061b1655193"

> get(mod$uid, mod$observer$.X)
$state
[1] "6d95a520d4e3416bac93fbae88dfe02f"

请注意,初始化时,对象的uid已在观察者中自动注册.这样,控制器/视图可以订阅通知,我们有1:n的关系.

实例化视图和控制器

view1 <- new("View1")
view2 <- new("View2")
cont  <- new("Controller", model=mod, views=list(view1, view2))

订阅

Controller订阅基础模型的通知

cont$subscribe()

请注意,订阅已记录在观察者中

get(mod$uid, mod$observer$.X)

显示注册视图

> cont$updateView()
  a  b
1 1 10
2 2 11
3 3 12
[1] TRUE

还有一个打开的情节窗口.

修改模型

> cont$model$multiply(x=10)
State change detected for model uid: fdf47649f4c25d99efe5d061b1655193
Publishing state change for model uid: fdf47649f4c25d99efe5d061b1655193
Notifying subscribers of model uid: fdf47649f4c25d99efe5d061b1655193
   a   b
1 10 100
2 20 110
3 30 120
[1] TRUE

请注意,两个注册视图都会自动更新,因为基础模型将其状态更改发布给观察者,观察者又通知所有订阅者(即控制器).

打开问题

这就是我觉得我还没有完全理解的东西:

1. 这是MVC模式的某种正确实现吗？如果没有,我做错了什么？
2. 应该为模型"处理"方法(例如聚合数据,获取子集等)"属于"模型或控制器类.到目前为止,我总是将特定对象可以"做"的所有内容定义为此对象的方法.
3. 控制器应该是控制模型和视图之间的每个交互("两种方式")的"代理",还是仅负责将用户输入传播到模型(某种"单向"？

Answer 1

1. 它看起来相当不错，但我不太确定为什么除了其他类之外还有一个观察者（也许你可以告诉我）通常控制器是一个观察者。在 R 中执行此操作确实是个好主意，因为当我在 Java 中学习它时，它并不那么容易理解（Java 隐藏了一些好的部分）

2. 是和否。这种模式有许多不同的解释。我喜欢在对象中拥有方法，我想说它属于模型。一个简单的例子是数独求解器，它在 GUI 中显示求解步骤。让我们把它分成一些可以分成 M、V 和 C 的部分：原始数据（可能是二维数组）、数独函数（下一步计算，...）、GUI、告诉 GUI 一个新的人步骤是计算的我会这样说：M：原始数据+数独函数，C：谁告诉GUI关于GUI输入的更改/模型，V：没有任何逻辑的GUI其他人将数独函数放入控制器中，是也是正确的，并且可能会更好地解决某些问题

3. 可以有一个像您所说的“单向”控制器，而视图是模型的观察者。也可以让控制器做所有事情，而模型和视图彼此不认识（看看模型视图呈现器） ，就是这样）