12

I have recently learned about the MVC design pattern. I'm learning from the Head First Design Pattern book.

According to this book (if I understand correctly):

The Model is most of the application logic and data.

The View is basically the GUI that represents the Model visually to the user.

The Controller is responsible to 'mediate', and act as a 'middleman' between the View and the Model. The View reports to the Controller that the user made an action, and the Controller translates it to method calls on the Model.

However, a lot of places on the web contradict what I understand from that book. They claim that generally the user interacts with the Controller, not the View.

Which one is true or more common? Does the user interact with the Controller directly, or with the View directly? Are both approaches acceptable? Which is more common?

closed as unclear what you're asking by Robert Harvey, gnat, user40980, Michael Kohne, Dynamic Mar 30 '14 at 14:39

Please clarify your specific problem or add additional details to highlight exactly what you need. As it's currently written, it’s hard to tell exactly what you're asking. See the How to Ask page for help clarifying this question. If this question can be reworded to fit the rules in the help center, please edit the question.

  • 4
    This question is not meaningfully answerable the way you have written it. Give us an example of one of the places on the web that contradicts the book, and we will try to explain it. Be specific with your example. – Robert Harvey Mar 29 '14 at 0:49
  • 1
    2 answers, both upvoted, one says "interact with the view" the other says "interact with the controller".... makes me think MVC is not quite good an architecture if its this confused at such a fundamental level! – gbjbaanb Mar 29 '14 at 19:55
  • See also, on StackOverflow, Should sorting logic be placed in the model, the view, or the controller? – Izkata Mar 30 '14 at 0:09
  • Do you click on the controls of the application or on the database queries? The interaction is directly with the user interface, which itself is a view. The view usually invokes requests to the server (in case of web apps) or calls the hooks registered on them (in case of client apps). Beside that the whole MVC is just crap. – spectre Mar 30 '14 at 11:07
  • @spectre It's not useful to dismiss MVC without providing an explanation and, ideally, an alternative. Otherwise that dismissal contributes nothing and should've just been left out of your comment. Besides, even with that, it would still be off-topic. – underscore_d Dec 11 '18 at 12:55
17

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.

  • What if you don't have GUI for all the actions? What if you have only API implemented for some specific parts? Does that mean user sometimes interacts with the View and sometimes with the Controller directly? – Mahdi Mar 29 '14 at 9:29
  • 1
    From my perspective, no. The API takes the place of the view. – Adam Zuckerman Mar 29 '14 at 9:39
  • but the API could be a simple url-routes, placed in the Controller. I mean no View at all ... – Mahdi Mar 29 '14 at 10:58
  • 1
    @AdamZuckerman Thanks for answering. In the next comment I'll describe how I think a common MVC implementation works, please confirm if it's correct or not. Thanks – Aviv Cohn Mar 29 '14 at 13:48
  • 2
    @Mahdi An API, by definition, is there as a programming interface, not a user interface. Programs interact with the API, users interact with the View. – Eric King Mar 29 '14 at 21:27
4

The user interacts with the Controller. From the technical point-of-view you're not interacting with the View, you're just using it to interact with the Controller.

On the surface it seems that the user is interacting with the GUI -- also to a non-programmer this makes more sense, however by clicking on a button you're basically talking to the Controller not the View.

Also not all the applications -- even MVC web-applications, does have a GUI. You might interact with the Controller via an API -- just simple url-routes for example, placed in the Controller itself.

The Controller should be the place that Receives and Handles the user requests. So if you're somehow accessing the Model directly from View -- doesn't matter how, then it's not MVC anymore.

  • 2
    +1 This is correct. Things like menus and toolbars are part of the GUI but not part of the view, and go straight to the controller. Keystrokes likewise. – david.pfx Mar 29 '14 at 13:45
  • 1
    The reason views exist as an abstraction is so we can substitute them easily when necessary. A controller for an app on various platforms can be the same, but the views have to recognize user gestures differently and translate them into controller operations. I disagree, therefore, that users interact directly with controllers. – Fuhrmanator Mar 29 '14 at 18:06
  • 1
    @Mahdi I would say that in that case, there's no user interaction at all, it's the view communicating with the controller programmatically. The only interactions that are initiated by the user are via the view. – Eric King Mar 29 '14 at 21:25
  • 1
    @david.pfx Keystrokes can't go directly from a browser window to a Controller. – Adam Zuckerman Mar 29 '14 at 23:41
  • 1
    @Izkata "The View is the part of the code that requests are sent to" -- Sorry but this is the worst thing I heard here. How is that even possible? Can you back it up by providing a reference in an article or book? – Mahdi Mar 30 '14 at 8:44
1

Let's use a concrete example of why users interact directly with views and not controllers.

In the music app on the iPhone, a high level feature is to play a playlist. "Play a playlist" is a function of a controller to the app.

There is more than one way to activate that function. I can click on the playlist inside of the app, or I can ask Siri (voice interface) to perform the same function. Those are two different gestures that are recognized by the various views.

The feedback in each view is also different. Siri will tell you that it is playing the music you requested. The music app will show you a visual feedback that it is playing the playlist.

Not the answer you're looking for? Browse other questions tagged or ask your own question.