Vista adecuada del modelo -_____ diseño

He estado leyendo sobre Model View Controller, Model View Presenter, Model View ViewModel, y así sucesivamente, y en general, el concepto subyacente parece bastante simple de entender: mantenga las visuales bonitas y las agallas científicas tan separadas e ignorantes entre sí como posible. No conseguir la lógica mantequilla de maní en el chocolate de diseño; genial, me gusta eso.

El problema es que todavía estoy un poco confuso en cuanto a esa tercera parte ... la que no es modelo o vista. Todo el mundo parece tener su propia idea de cómo llamarlo, qué debería hacer, qué es lo correcto, qué es lo que está mal ... y me estoy volviendo loco tratando de descubrir cuándo un presentador se convierte en un modelo de vista y cuándo una vista no debería t haciendo eso porque ese es el trabajo del presentador y--

Estoy divagando.

En lugar de pedirle a alguien que explique la diferencia entre ellos, porque eso ya se ha hecho una y otra vez (lo sé; he leído más artículos de los que puedo contar), tendría curiosidad por escuchar los pensamientos de un pocos programadores en el modelo que yo mismo he improvisado.

Dicho esto, ¿cómo clasificaría este diseño y, quizás lo más importante, ve algo de esto que obviamente apesta? Claro, me encantaría saber que me está yendo bien si este es realmente un diseño sólido, pero preferiría recibir consejos sólidos sobre elogios.

Nota: ¿Usaré "the Bridge" para la misteriosa tercera parte de Model-View-? para evitar cualquier sugerencia subconsciente de lo que "debería" ser.

Modelo

• Es la autoridad en datos.
• Recibe información sobre los cambios solicitados desde el puente.
• Contiene y realiza toda la lógica de cómo los datos se relacionan con otros datos.
• Informa al Bridge cuando los datos cambian (para los datos en los que el Bridge ha expresado interés). Edición de redacción: permite a los suscriptores externos (sobre los cuales no sabe nada) monitorear su estado o resultados de cálculo.
• Tiene cero conocimiento de la Vista.

Ver

• Se preocupa por proporcionar al usuario una forma de ver y manipular datos.
• Recibe información sobre actualizaciones de datos del Bridge.
• Contiene y realiza toda la lógica sobre cómo presentar datos y controles al usuario.
• Informa al Puente cuando el usuario ha realizado una acción que (posiblemente) afecta al Modelo.
• Informa al Puente qué información le interesa.
• Tiene cero conocimiento del modelo.

Puente

• Es el coordinador y traductor entre el Modelo y la Vista.
• Realiza los cambios de formato apropiados en la información que se pasa entre el Modelo y la Vista.
• Conserva información sobre "quién necesita saber qué".
• Tiene conocimiento tanto del modelo como de la vista.

Notas adicionales

• En programas más complicados, es común que haya múltiples Modelos. En esta situación, el Bridge generalmente se encarga de coordinar / traducir entre los múltiples Modelos y, por lo tanto, se convierte en la autoridad sobre qué modelos de protocolo de llamada / API / diseño deben construirse. (por ejemplo, si está creando un programa de juego de cartas y desea construir un modelo alternativo de barajado de barajas, debe usar el Puente para determinar qué funciones son necesarias para una comunicación adecuada con el Puente).
• En pequeños programas simples con una sola Vista y Modelo, es común que el Puente "asuma" qué funcionalidad está disponible en ambos lados. Sin embargo, a medida que los programas se vuelven más complejos, se recomienda que las Vistas y los Modelos reporten su funcionalidad al Puente para que pueda evitar ineficiencias y suposiciones erróneas.

Creo que eso casi lo cubre. Por supuesto, agradezco cualquier pregunta que pueda tener sobre el diseño que tiendo a usar, y también animo cualquier sugerencia.

Y como siempre, gracias por tu tiempo.

Tu frase

"Es el coordinador y traductor entre el Modelo y la Vista".

indica que su Bridge es el presentador en una arquitectura MVP.

MVP y MVC son muy similares, excepto que en MVP solo el presentador observa el modelo, mientras que en MVC la vista también puede observar directamente el modelo (sin el presentador como un "puente").

Su responsabilidad modelo

"Informa al Bridge cuando los datos cambian (para los datos en los que el Bridge ha expresado interés)".

quizás esté mal redactado o sea un error: no desea que el Modelo dependa ni del Puente / Presentador / Controlador ni de la Vista. En su lugar, se utiliza ya sea un patrón Observer, Eventos, o de programación reactiva para permitir que el puente a suscribirse a los cambios en el modelo. Y luego puede reformular su responsabilidad como:

"Permite a los suscriptores externos (de los cuales no sabe nada) monitorear su estado o resultados de cálculo".

Si su Modelo no depende de su Controlador o Vista, es más fácil de probar y mucho más portátil.

Sospecho que una de las cosas que te confunde es que hay dos patrones completamente diferentes que comúnmente se llaman modelo-vista-controlador.

Existe el original, implementado en smalltalk y que es útil para los sistemas de interfaz de usuario locales, y es lo que tiendo a pensar como web-mvc, que intercambia algunas de las responsabilidades de las vistas y los controladores para que los controladores puedan sentarse en el servidor con las vistas están en el cliente (tal vez como html procesado, o tal vez a través de ajax).

Su descripción me parece que se ubicaría dentro de la mayoría de las definiciones de web-mvc.

Hay mucha discusión en la comunidad de programación sobre esta nomenclatura exacta. Nadie parece estar de acuerdo sobre mucho de nada.

Para mí, la forma en que el puente está conectado a la vista determina principalmente el nombre.

• Si puede haber una colección de vistas por puente, entonces el puente es un controlador.
• Si siempre hay una vista por puente, entonces el puente es un presentador.
• Si puede haber una colección de puentes por vista, entonces el puente es un modelo de vista.

A veces las cosas no son tan claras. Por ejemplo, un presentador podría conectarse a una vista compuesta hecha de múltiples subvistas o podría crearse un controlador sin ningún conocimiento de sus vistas. A pesar de esto, creo que mis reglas son un buen comienzo.

Como nota al margen, me gusta emparejar las responsabilidades de esta manera:

Modelo

Responsabilidad primaria: datos persistentes
Roles secundarios: validar actualizaciones, notificar a los observadores las actualizaciones

Ver

Responsabilidad primaria: datos actuales
Roles secundarios: aceptar entrada, presentar UX

Puente

Responsabilidad principal: actualizar datos
Roles secundarios: entrada limpia, sincronización de datos y vistas

Si bien su patrón sugerido parece correcto en la superficie, y sin duda funcionará para instancias pequeñas, a medida que su aplicación se vuelva más compleja, enfrentará problemas donde no está seguro de qué actualizaciones, quién escucha dónde y por qué estoy intentando para controlar tantos Modelos desde tantas Vistas, todos los que necesitan acceso entre sí, etc.

Recomiendo extender sus ideas usando el siguiente patrón (tomado de la charla Enemy of the State de Amy Palamountain ):

Modelos

• Sincronizar estado con el almacén de datos
• Manejar la validación de datos nuevos / actualizados
• Generar eventos cuando cambian de estado

Puntos de vista

• Renderizar plantillas
• Manejar eventos del modelo
• Manejar eventos DOM
• Media la interacción entre Modelo y DOM

Controladores

• Administra a lo sumo un par de Modelos y Vistas
• Realiza un seguimiento de las vistas dentro de un contenedor

Módulos

• La agrupación lógica de un controlador y sus vistas y modelos
• Comprobable
• Pequeño y mantenible (responsabilidad única)
• Coordina (a través del controlador) el estado y los eventos de las vistas y modelos que contiene
• Libre de presentar sus propias vistas
• No es libre de elegir dónde presentar sus Vistas

Gerente de diseño

• Responsable de la composición del diseño.
• Define un shell de aplicación en el DOM con áreas en las que los módulos pueden presentar su contenido

Despachador

• Escucha eventos (a través de la transmisión global de PubSub)
• Responsable de cargar nuevos módulos basados ​​en eventos
• Manos fuera de los módulos cargados al Administrador de diseño
• Gestiona la vida útil completa del módulo (creación, limpieza, almacenamiento en caché, etc.)
• Ejemplos de eventos:
  • Cambios de ruta (incluida la ruta de carga inicial)
  • La interacción del usuario
  • El evento de módulo burbujeó de un evento de Modelo debido a un cambio de estado del lado del servidor, etc.

Solicitud

• Responsable de la configuración general, crea instancias de cosas como:
  • Despachador
  • Enrutador
  • Corriente de PubSub
  • Madereros
  • etc.

Este tipo de patrón permite que su aplicación sea componible, probada por unidad, elimina la complejidad que un puente se acumularía con el tiempo, mantiene las preocupaciones bien separadas, etc.

Como señala Amy: tenga cuidado de no construir un servidor en el cliente. Y tenga cuidado de no caer en la doctrina de "Estoy haciendo un marco MV *, ¡por lo tanto debo ___!" En cambio, tome todas estas ideas (y las otras respuestas aquí), y encuentre lo que funciona mejor para su aplicación y equipo.

Recomiendo ver la charla de Amy Palamountain Enemy of the State (de donde surgieron estas ideas), o al menos mirar las diapositivas de la charla .