tag - devexpress tutorial c#

MVP y múltiples controles de usuario (4)

Cada Vista no tiene que implementar la misma interfaz ... ¿Por qué no definir las interfaces para cada control y tener un Presenter para toda la pantalla que contiene todos los controles? El presentador puede "conectar" los eventos en cada vista de acuerdo con la interfaz que los eventos requieren cada vista, a los controladores de eventos apropiados en el presentador (y en un controlador si está haciendo MVPC). También puede necesitar otra interfaz para representar la funcionalidad de Presenter a la que TODAS las vistas necesitan acceso en común ...

Si está haciendo MVPC, los eventos de vista que afectan al modelo se "manejarán" en el controlador, mientras que los eventos de vista que solo afectan a otras partes de la vista se manejarán en el presentador.

Estoy tratando de usar el patrón MVP y estoy teniendo un problema de diseño. Estoy desarrollando una aplicación que tendrá varios UserControls. Los UserControls no tienen nada que ver entre sí y solo representan un subconjunto del modelo real. Por lo que he leído, la gente tiende a decir que debes usar un Presenter por Vista. Esto parece tener sentido, pero si tengo 30 controles de usuario, ¿realmente quiero 30 presentadores? Por otro lado, si tengo 1 Presenter y 1 View que representan la vista completa de la "aplicación", tendré interfaces hinchadas de View y Presenter. Entonces cada Vista tendría que implementar métodos que no tienen nada que ver con eso. Mi pregunta es, ¿hay una mejor manera de manejar múltiples UserControls, o debo crear 1 Presenter para cada Vista?

Debería estar haciendo un presentador por un control debido a:

Eso le permitiría tener pruebas unitarias enfocadas que abordan solo ese control
mayor capacidad de mantenimiento debido al hecho de que no tendrá que admitir un presentador gigantesco que contenga la unión de la lógica de presentación de todos los controles
eso evitaría la redundancia en casos de tener el mismo control en varias páginas
Aumenta el SRP al tener controles que se centran en su lógica específica, mientras que la página realiza funciones específicas del contenedor:

Normalmente se mencionan dos problemas relacionados con la decisión "presentador por control":

El contexto compartido es un problema donde, debido al hecho de que todos los controles solo muestran partes diferentes del mismo contexto de datos de la página, esa situación puede parecer un caso de uso problemático que conduce a una gran cantidad de código redundante de recuperación de datos en cada uno de los controles. Esto se puede resolver fácilmente mediante la inyección de dependencia donde la página (o el controlador) realiza la recuperación de datos individuales y luego inyecta el objeto de contexto de datos en cada uno de los presentadores / vistas (generalmente implementando alguna interfaz que lo permita). En el caso del patrón MV-VM (Silverlight, WPF), se puede lograr el mismo efecto a través del límite de datos donde la página establecería su DataContext que luego se usaría desde las vistas.
La comunicación entre vistas en la misma página es un segundo problema que puede resolverse fácilmente mediante un par de enfoques:
Los controles son eventos de publicación a los que la página se suscribe y luego realiza llamadas directas a los métodos apropiados en otros controles (la página contiene todos los controles, lo que significa que conoce a todos sus miembros)
Patrón de diseño del observador
Patrón agregador de eventos

En cada uno de estos enfoques, los controles se comunican entre sí sin ser conscientes de los demás.

Pregunta antigua, pero voy a irme y tengo que estar en desacuerdo con las otras respuestas: no desea un presentador por UserControl, como tampoco quiere una prueba de unidad en cada UserControl, lo que sería un uso indebido ciego de un patrón de diseño.

Un UserControl no es una vista.

Cada área lógica de su aplicación debe tener un presentador; cómo se divide cada uno, cuántos controles, qué muestra qué, es únicamente una preocupación de la composición .

Tendría más sentido agrupar el código que está relacionado en un objeto. Entonces, en este caso, si las vistas son agrupaciones específicas de código relacionado, entonces el presentador también imitará estas agrupaciones. Tener un presentador "global" para diferentes vistas agruparía el código no relacionado en un objeto. Definitivamente, también influiría en la interfaz para el presentador. Echa un vistazo al principio de responsabilidad única .

Ahora, podría tener una clase de Gerente de presentadores que quizás le dé acceso a cada interfaz de presentador, como los estados del Principio de Segregación de Interfaz , por cualquiera de las dos herencias (tenga un presentador global concreto que implemente muchas interfaces de presentador ... el cual viola la responsabilidad única) ) o agregación (tener presentadores individuales para cada interfaz y obtener funciones ... por lo tanto, la interfaz global sería las funciones de obtención) o una combinación de ambas (el presentador global es algo así como un adaptador).

Creo que la mejor solución sería tener 30 presentadores diferentes.