No MVC, várias visualizações podem ter o mesmo controlador ou uma visualização deve ter um controlador exclusivo?

Estou tendo algumas dúvidas ao projetar uma arquitetura para um projeto em torno do MVC. (É um projeto SDK em C ++ / Marmalade, não estou usando nenhuma estrutura MVC específica, estou criando uma.)

Em vários artigos (como no artigo original de Steve Burbek ), continuo lendo o conceito "tríade MVC", que me incomoda desde que tomei esse conceito literalmente. Quando o li pela primeira vez, parecia que um aplicativo é construído em torno de unidades "tríade MVC" - uma para cada peça de interface do usuário que eu supunha -, mas acho isso pouco flexível e acho que não é assim que o MVC se destina a ser usado. Depois, pesquisando mais sobre o assunto, encontrei vários exemplos de acoplamento rígido do controlador e da visualização, a saber, relacionamento 1 para 1 - o TextEditView possui o TextEditController.

Mas, quando volto ao meu projeto, acho que pode ser útil ter um controlador (por 'unidade lógica', como AddElementController) e várias visualizações para esse controlador em particular.

Estou claramente pensando em algo como um AddElementController que deve ter algum tipo de interface do usuário da guia. Devo ter um AddElementController que tenha um AddElementTabView e vários AddImageView, AddSoundView, etc. para as guias? Ou devo ter um 'sub-controlador' diferente para cada visualização de guia?

Em suma, e com relação ao padrão MVC (não a compreensão / implementação específica desse framework X), é correto ter várias visualizações para um controlador ou cada visualização deve ter seu controlador específico?

Além disso, é correto manter algumas informações de estado no controlador ou deve ser sem estado (o que significa que o estado deve ser colocado em algum modelo de estado que não seja de domínio)?

Obrigado a todos antecipadamente.

O problema é que o padrão MVC foi projetado em um sistema que realmente não existe mais. Foi inventado no Smalltalk em um momento em que as bibliotecas da interface do usuário não existiam. Para criar uma caixa de diálogo da janela, você desenhou todas as caixas, destacou os quadrados apropriados, certificou-se de que o texto que você estava desenhando acabasse no lugar certo ... etc ...

Imagine como seria escrever um aplicativo de diálogo usando apenas uma tela grande. É desse mundo que o MVC vem.

Uma "visão" neste sistema era uma caixa de texto e era uma classe responsável por desenhar a caixa, o texto, desenhar áreas selecionadas, responder a alterações no texto, etc.

Um "controlador" era outra classe que recebia eventos de mouse que ocorriam dentro desta caixa, como movimento do mouse, tecla pressionada, tecla acima, cliques, etc ... e decidia o que acontecia. Devemos mudar o texto? Devemos mudar a seleção? Coisas assim.

Um "modelo" era outra classe que representava os dados básicos e o estado do componente. Um modelo de caixa de texto teria o texto, é claro, a fonte, a seleção etc.

Como você pode ver, em uma situação como essa, os três componentes estão muito envolvidos na representação de uma única idéia. Faz sentido, neste contexto, falar de uma "tríade".

Hoje, se você estiver trabalhando na criação de uma biblioteca de interface do usuário e usando comandos de desenho brutos, poderá fazer algo semelhante. Mas a aplicação do padrão "MVC" se espalhou além de seu objetivo inicial. Hoje em dia, você tem uma "visualização" que pode realmente ser uma caixa de diálogo completa e um controlador que está respondendo a eventos como "textChanged" ou "buttonClicked". O modelo no MVC de hoje é normalmente algo bastante desconectado do sistema (mas geralmente vinculado à visualização ao fornecer uma interface de observação de algum tipo) e pode haver muitas visualizações associadas ao modelo único.

Em um sistema que recentemente arquitetei, por exemplo, tivemos cerca de 10 visualizações, todas observando um único "titular" de documento e seu documento ativo. Uma interface principal de desenho interagia com o layout do documento, várias visualizações de propriedades que observavam o item selecionado e forneciam uma interface de registro e uma representação em escala menor da vista principal que mostrava o documento inteiro em vez de apenas a janela visível. Algumas dessas visualizações tinham controladores de complexidade variável que transformavam eventos da GUI em alterações no documento, que por sua vez notificavam suas várias visualizações.

Você ainda pode chamar esse relacionamento de "tríade"? Talvez, mas acho que isso implica muito do aplicativo antigo e mais antigo do MVC.

Você poderia compartilhar controladores com visões diferentes? Depende de como as visualizações são semelhantes. Descobri que, de um modo geral, esse tipo de objeto tem comportamento específico para a visão que está controlando E o modelo que está manipulando para ser muito reutilizável ... mas sempre há exceções.

Depende. Existem várias variantes do MVC, algumas em que apenas um relacionamento 1: 1 faz sentido (como "a humilde caixa de diálogo"), outras em que esse não é o caso. Eu recomendaria ler a série de artigos " Crie seu próprio CAB ", explicando as variantes mais importantes do MVC.

O Views não possui controladores no MVC. Controller é o chefe, portanto, um Controller decide qual View será renderizada e o Views não se importa com o Controller que solicitou o View.

Você pode / terá absolutamente várias visualizações de um controlador. Pense em criar um modelo para cada visualização, se você quiser manter o padrão MVC.

O objetivo do controlador é controlar as interações do usuário com seu modelo de domínio - ou seja, é um nível de indireção entre o que o usuário vê (a visualização) e o estado de seus aplicativos (o modelo).

Quando o usuário faz uma solicitação, ela é direcionada para um controlador. O controlador decide como retransmitir essa solicitação para o aplicativo, geralmente através de algum tipo de classe de serviço. Em seguida, interpreta a resposta dessa classe de serviço e decide qual exibição enviar de volta ao usuário.

Um controlador sempre pode retornar a mesma visualização (1: 1) se houver apenas um tipo de solicitação que o usuário possa fazer do controlador e sempre exigir o mesmo tipo de resposta. Por exemplo, HelloWorldControllersempre retornará uma HelloWorldViewexibição "Olá, mundo!"

Por outro lado, um controlador geralmente precisa decidir sobre diferentes visualizações, dependendo do que o modelo diz. O TeamRosterControllerpode retornar um RugbyTeamRosterViewou um FootbalTeamRosterView, dependendo do tipo de equipe solicitado.

Geralmente é preferível que os controladores não tenham estado, embora possa ser necessário ou desejável algum acesso ao estado da sessão do usuário. Você deve gerenciar o acesso a esse estado separadamente, se possível.

Eu recomendo olhar para uma estrutura MVC real para ver o que faz e como funciona. Você não precisa usá-lo, mas com certeza entenderia melhor antes de criar o seu.