MVC Architecture – Should the Controller Pass Data to a View in the MVC Pattern?

The controller controls the flow of activity. The user performs this action, the controller passes the view data to the domain which does whatever it needs to do then, based on the response(s), the controller tells the framework which view to show next (and gives it enough data to do so).

The controller must thus be coupled to the domain model, to some extent. ie. You could put a service layer in between but, by strict definition, that becomes part of the domain.

It is also coupled to the view data but not the view itself. ie. it simply says "show the customer view using this customer detail." The framework then decides where it should find that view.

Now this should allow you to decouple the domain model from the view, by using a view model of the same data. Some developers do this, some don't, and I do think it's largely a matter of personal preference.

In Rails, you are very much encouraged to push the domain objects (ActiveRecord) to the view and trust that the view doesn't take advantage of that access (eg. you shouldn't call customer.save from the view, even though it would be available).

In the .NET world, we tend to reduce risk by not allowing things that shouldn't happen and, possibly for that reason, it seems to me that the detached view model is more popular.

The user interacts with the View, but the View must communicate the actions to the Controller. The Controller may update the Model, but it isn't required with every/any change.

The description I am providing is based on my personal experience with the .NET implementation of MVC. Your implementation can be different.

The Controller is where actions are processed, basically a business layer. A simple controller will do nothing more than get the data from the Model to feed to the View. A complicated Controller will perform all sorts of actions, up to security management, authentication, authorization, registration, and possibly many other things.

The View should only be responsible for displaying the information in a fashion that the user can understand. There can be some cross over here with both the Controller and the Model as things like Single Page Applications (SPAs) will have data validation feedback for the user. Any other cross overs are heavily frowned upon.

The Model deals with data. This includes validation of data (where applicable). Data storage and retrieval is also handled in this layer.

UPDATE

There seems to be some confusion surrounding who does what when. I included two different overviews of the MVC architectures because they are similar, but not the same. There is room for either interpretation. Possibly, many more. The descriptions above are my interpretation of MVC from multiple sources, including my own experience building applications using this methodology. Hopefully, this update will help to clear up some of this confusion.

MVC is an attempt to build a Separation of Concerns design pattern for software development. It has primarily been implemented in web based applications (to my knowledge).

The View handles all of the user interaction. If your user clicks on a button, the View determines if the click is a user interface interaction or something that is beyond its concern (a Controller interaction). If the button does something like copy values from one field to another, your implementation will determine if that is a View concern or a Controller concern. You will most likely only have this blurring of concerns when dealing with a Single Page Application (SPA).

The Controller is where your actions are processed. The View has communicated the user decided to change values for some fields. The Controller may perform validation on that data or it may be handled by the Model. Again this is implementation dependent. If the Controller has security features, it may determine that the user doesn't have sufficient privileges to perform the action. It would reject the changes and update the View accordingly. The Controller also determines what data to retrieve from the Model, how to package it, and update the View with that data.

The Model determines how and where to store data. It may also perform validation of that data before storing it (it should do this because people will bypass the View on occasion).

Wikipedia has an article on MVC.

• A model notifies its associated view/views and controllers when there has been a change in its state. This notification allows views to update their presentation, and the controllers to change the available set of commands. In some cases an MVC implementation might instead be "passive," so that other components must poll the model for updates rather than being notified.
• A view is told by the controller all the information it needs for generating an output representation to the user. It can also provide generic mechanisms to inform the controller of user input.
• A controller can send commands to the model to update the model's state (e.g., editing a document). It can also send commands to its associated view to change the view's presentation of the model (e.g., by scrolling through a document).

From Microsoft's Overview of MVC.

• Models. Model objects are the parts of the application that implement the logic for the application's data domain. Often, model objects retrieve and store model state in a database. For example, a Product object might retrieve information from a database, operate on it, and then write updated information back to a Products table in a SQL Server database.

  In small applications, the model is often a conceptual separation instead of a physical one. For example, if the application only reads a dataset and sends it to the view, the application does not have a physical model layer and associated classes. In that case, the dataset takes on the role of a model object.

• Views. Views are the components that display the application's user interface (UI). Typically, this UI is created from the model data. An example would be an edit view of a Products table that displays text boxes, drop-down lists, and check boxes based on the current state of a Product object.

• Controllers. Controllers are the components that handle user interaction, work with the model, and ultimately select a view to render that displays UI. In an MVC application, the view only displays information; the controller handles and responds to user input and interaction. For example, the controller handles query-string values, and passes these values to the model, which in turn might use these values to query the database.