¿Por qué todos ponen controladores en una carpeta y vistas en otra?

Me estoy preparando para tomar la curva de asp y en un marco de mvc, asp.net mvc o nancy. Donde quiera que vaya, veo carpetas para controladores / módulos y carpetas para vistas. ¿Es esto solo un reflejo pavloviano de ordenar las cosas por tipo, o hay alguna sabiduría más profunda operando? Tengo un pequeño proyecto de prueba de concepto donde almaceno juntos los archivos que es probable que abra juntos, un consuelo considerable. Dado que es probable que estos archivos también se llamen entre sí, pueden hacerlo con enlaces relativos más cortos, menos frágiles. Este patrón es desafiado por mvc, porque la ruta de la carpeta ya no se corresponde automáticamente con la ruta de la url y, en asp.net mvc, las plantillas y el enrutamiento del proyecto imponen las vistas \ controladores \ cisma.

Esta página de Microsoft presenta el concepto de áreas. Puede leerse como una admisión de cuán difíciles de manejar se vuelven las aplicaciones grandes debido a esta separación artificial.

La gente objetará la "separación de preocupaciones", pero la separación de preocupaciones ya se logra al tener archivos fuente separados. Me parece que no hay ganancia concreta al tomar estos archivos de origen que están estrechamente acoplados y enviarlos a extremos opuestos de la estructura de carpetas.

¿Alguien más está luchando contra esto? ¿Algun consejo?

Me gustaría decir que es programación de culto de carga , pero hay razones técnicas para esta estructura. Asp.Net MVC tomó una convención sobre el enfoque de configuración para casi todo. Por defecto, el motor de vista Razor busca en el Viewsdirectorio para resolver qué vista volver desde el controlador. Sin embargo, existen algunos trucos para obtener una estructura de proyecto diferente y Microsoft incluso proporciona una función MVC llamada Áreas para permitirnos crear una estructura de proyecto más sensata. También puede implementar su propio motor de vista para especificar dónde buscar vistas.

¿Por qué digo que es programación de culto de carga y que tienes razón al respecto? El tío Bob me convenció de que la estructura de directorios del proyecto no debería decirme que es una aplicación MVC. Debería decirme que es un escaparate, o un sistema de solicitud de tiempo libre, o lo que sea. La estructura y la arquitectura de alto nivel deberían decirnos qué es esto, no cómo se implementó.

En resumen, creo que tiene razón sobre esto, pero cualquier otra estructura de directorio simplemente estaría luchando contra el marco y confía en mí cuando digo que no desea tratar de hacer que el marco Asp.Net MVC haga algo que no era Está diseñado para hacer. Es una pena que no sea más configurable realmente.

Para abordar rápidamente las inquietudes arquitectónicas, sigo creyendo que los modelos de negocio (negocio, no vista) y el DAL deberían vivir en un proyecto / biblioteca separado que se llama desde su aplicación MVC.

Es solo que el controlador realmente está muy unido a la vista y es probable que se modifiquen juntos. Todos debemos recordar la diferencia entre el acoplamiento a través de la dependencia y el acoplamiento lógico. El hecho de que el código haya tenido sus dependencias desacopladas no lo hace menos lógicamente acoplado.

Cualquiera sea la razón, esta es una mala práctica. Es muy anti-OO porque los paquetes o carpetas (como quiera llamarlos) deberían tener interdependencias débiles. Las clases (o archivos) dentro de ellos deberían tener fuertes interdependencias.

Al lanzar todas las vistas en una carpeta y todos los controladores en otra carpeta, está creando dos paquetes con un acoplamiento muy muy estrecho. Esto va en contra del principio de tener dependencias débiles entre paquetes.

Una vista y un controlador son dos mitades de un todo y deben pertenecer el uno al otro. No tendría un sorteo de armario para los calcetines del lado izquierdo, y otro sorteo para los calcetines del lado derecho.

Para responder a tu '¿Por qué todos ...?' pregunta: Aquí hay algunas razones potenciales, aunque no estoy completamente seguro de qué combinación de ellas es una causa real, ya que en realidad es una pregunta subjetiva

• Para replicar la arquitectura lógica (modelo, vista, controlador) con una carpeta coincidente y una estructura de espacio de nombres

• Por conveniencia y conveniencia de seguir la plantilla de proyecto ASP.net MVC

• Para agrupar por espacio de nombres, ya que la Controllers/carpeta conducirá a un .Controllersespacio de nombres

• Podría habilitar algunos escenarios en DI / IoC donde las clases de controlador solo se consultan / escanean desde un espacio de nombres que contiene / termina con 'Controladores' (esto podría ser incorrecto)

• Para permitir que las plantillas T4 escaneen y andamien modelos y controladores para generar vistas

Siempre puede crear y seguir su propia convención si tiene sentido para su proyecto, nadie puede / lo detendrá. Pero tenga en cuenta que si trabaja en un proyecto grande y / o un equipo grande, entonces la convención predeterminada que todos conocen podría ser una mejor opción (¡aunque no necesariamente la correcta!)

Si su convención es más fácil de seguir y no obstaculiza la productividad, ¡hágalo! y tal vez incluso escribir sobre él una publicación de blog o dos para socializarlo con la comunidad de desarrolladores y obtener comentarios

Una razón para mantener las vistas y los controladores en directorios separados es cuando tienes desarrolladores front-end y back-end trabajando en un proyecto. Puede evitar que los desarrolladores front-end accedan al código de back-end (por ejemplo, para ayudar con el cumplimiento de PCI, restringiendo quién tiene acceso a código confidencial).

Otra razón es hacer que sea más fácil tener "temas" y cambiar todas las plantillas haciendo un pequeño cambio en la ruta de visualización.

Una tercera razón es tener un patrón de directorio simple al especificar vistas en el marco MVC. Es más fácil especificar el subdirectorio y el archivo en lugar de una gran ruta larga a cada vista.

El único "acoplamiento apretado" debe ser:

1. Variables enviadas a la vista por el controlador.
2. Forme campos o acciones en la vista, devueltos al controlador.

Uso un controlador genérico e intento mantener los nombres de las variables en la vista genérica, de modo que muchas vistas puedan usar el mismo controlador y muchos controladores puedan usar la misma vista. Por esta razón, prefiero mantener las vistas completamente separadas. El modelo es donde puede diferenciar cada "cosa" en su aplicación: pueden ser objetos con una lista de propiedades y métodos para acceder / modificar estas propiedades.

Para un código estrechamente acoplado, un enfoque que podría funcionar para usted es mantener todos los archivos que forman parte de un paquete o "módulo" juntos en un directorio con espacio de nombres. Luego puede usar un script para copiar o "compilar" sus plantillas en bruto en el directorio principal de "vistas". Por ejemplo:

    lib/my-namespace/my-package/
        -> controllers/
        -> models/
        -> views/
            -> theme/
               -> template-name1
    app/compiled_views/theme/
        -> url/path/template-name1

Desafortunadamente, si desea cambiar la estructura de un tema existente, hay más entradas y salidas de directorios de paquetes para actualizar las vistas.

Tenga en cuenta que las vistas son solo una forma de formatear datos, ya sea json, xml, csv o html. Esto ayuda especialmente si desea que su aplicación también funcione como API. Intente desacoplar la vista de los datos, utilizando nombres de variables genéricos, para que pueda usar la misma plantilla para muchos controladores o modelos (o use incluye para minimizar la cantidad de código que necesita mantener).

No necesariamente todos hacen esto. Por ejemplo, el framework Django de python tiene el concepto de una aplicación, donde los submódulos de su aplicación viven en sus propios directorios con sus propios modelos y vistas y plantillas (las vistas son lo que Django llama esencialmente controladores). Prefiero esa forma de hacer las cosas porque eso significa que puedo empaquetar fácilmente una "aplicación" y reutilizarla en proyectos simplemente incluyéndola en la lista de aplicaciones en la configuración de mis proyectos. También es más fácil averiguar dónde están las diferentes partes. Si miro el archivo urls.py y veo algo así url(r'^users/', include('my_site.users.urls')), sé que el módulo my_site.userscontiene todo el código que maneja a los usuarios. Sé mirar los módulos my_site.users.viewsy my_site.users.modelscuándo quiero ver cómo se crean y autentican los usuarios. Sé que todas mis rutas están definidas en my_site.users.url.

Además, si es lo suficientemente genérico, probablemente pueda usar ese módulo en otros sitios simplemente cambiando la configuración o empaquetarlo como una biblioteca y publicarlo como OSS.

Recuerde que es la forma recomendada por Microsoft de mantener los controladores y las vistas en una carpeta diferente, por lo que muchos seguirían la estructura recomendada,

1. Una razón por la que los controladores pueden ser siempre no tiene una relación uno a uno con las vistas, especialmente las vistas parciales se pueden compartir entre los controladores.
2. Otra razón podría ser que cuando su proyecto crezca, es posible que desee extraer los controladores y las pruebas unitarias a otro (s) proyecto (s), pero es bastante difícil hacer lo mismo para que las vistas más las vistas / js / css estén juntas, ya que se refieren entre sí.

Dicho esto, hay muchas publicaciones sobre cómo hacerlo a tu manera, como esta .

Para el registro

¿Por qué digo que es programación de culto de carga y que tienes razón al respecto? El tío Bob me convenció de que la estructura de directorios del proyecto no debería decirme que es una aplicación MVC. Debería decirme que es un escaparate, o un sistema de solicitud de tiempo libre, o lo que sea. La estructura y la arquitectura de alto nivel deberían decirnos qué es esta cosa, no cómo se implementó.

Pregunta: ¿Quién tiene acceso al código? Programadores. ¿A los usuarios finales les importa el código? No. Y, lo que hace un programador, codifica. O más específicamente, clases basadas en tipos (controladores, servicio, modelo, etc.). Por lo tanto, tiene sentido y es fácil depurar un código, si puede encontrar un código basado en el tipo de código, en lugar de en el comportamiento del código. Además, digamos un proyecto de equipo, uno está a cargo del controlador, otro del modelo, otro del dao y otro de la vista. Es fácil separar el proyecto en partes. Un buen código es un código fácil de depurar, no un código de sintaxis de azúcar. El tío Bob se equivoca de nuevo.

Intentar imitar el comportamiento del proyecto (el frente de una tienda) es culto a la carga.