Controller Basics

Getting started with MVC presents something of a chicken and egg problem: there are three parts (model, view, and controller) to understand, and it's difficult to really dig into one of those parts without understanding the others. In order to get started, you'll first learn about controllers at a very high level, ignoring models and views for a bit.

After learning the basics of how controllers work, you'll be ready to learn about views, models, and other ASP.NET MVC development topics at a deeper level. Then you'll be ready to circle back to advanced controllers topics in Chapter 14.

A Simple Example: The Home Controller

Before writing any real code, we'll start by looking at what's included by default in a new project. Projects created using the Internet Application template include two controller classes:

• HomeController: Responsible for the “home page” at the root of the website and an “about page”
• AccountController: Responsible for account-related requests, such as login and account registration

In the Visual Studio project, expand the /Controllers folder and open HomeController.cs as shown in Figure 2.7.

Figure 2.7

Notice that this is a pretty simple class that inherits from the Controller base class. The Index method of the HomeController class is responsible for deciding what will happen when you browse to the homepage of the website. Follow these steps to make a simple edit and run the application:

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using System.Web.Mvc;
  
 namespace MvcMusicStore.Controllers
 {
     Public class HomeController : Controller
     {
         public ActionResult Index()
         {
             ViewBag.Message = "I like cake!";
  
             return View();
         }
  
         public ActionResult About()
         {
             return View();
         }
     }
 }

Figure 2.8

Next, a browser window opens and displays the message you just typed, as shown in Figure 2.9.

Figure 2.9

Great, you created a new project and put some words on the screen! Now let's get to work on building an actual application by creating a new controller.

Writing Your First (Outrageously Simple) Controller

Start by creating a controller to handle URLs related to browsing through the music catalog. This controller will support three scenarios:

• The index page lists the music genres that your store carries.
• Clicking a genre leads to a browse page that lists all of the music albums in a particular genre.
• Clicking an album leads to a details page that shows information about a specific music album.

Creating the New Controller

Start by adding a new StoreController class. Right-click the Controllers folder within the Solution Explorer and select the Add ⇒ Controller menu item as shown in Figure 2.10.

Figure 2.10

Name the controller StoreController and leave the checkbox labeled Add Action Methods for Create, Update, Delete, and Details Scenarios unchecked as shown in Figure 2.11.

Figure 2.11

Writing Your Action Methods

Your new StoreController already has an Index method. You'll use this Index method to implement your listing page that lists all genres in your music store. You'll also add two additional methods to implement the two other scenarios you want your StoreController to handle: Browse and Details.

These methods (Index, Browse, and Details) within your controller are called controller actions. As you've already seen with the HomeController.Index() action method, their job is to respond to URL requests, perform the appropriate actions, and return a response back to the browser or user that invoked the URL.

To get an idea of how a controller action works, follow these steps:

        //
        // GET: /Store/
        public string Index()
        {
            return "Hello from Store.Index()";
        }

  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Web;
  using System.Web.Mvc;

namespace MvcMusicStore.Controllers
{
    public class StoreController : Controller
    {
        //
        // GET: /Store/
        public string Index()
        {
            return "Hello from Store.Index()";
        }
        //
        // GET: /Store/Browse
        public string Browse()
        {
            return "Hello from Store.Browse()";
        }
        //
        // GET: /Store/Details
        public string Details()
        {
            return "Hello from Store.Details()";
        }
    }
}

Accessing these URLs invokes the action methods within your controller and returns string responses, as shown in Figure 2.12.

Figure 2.12

A Few Quick Observations

Let's draw some conclusions from this quick experiment:

Parameters in Controller Actions

The previous examples have been writing out constant strings. The next step is to make them dynamic actions by reacting to parameters that are passed in via the URL. You can do so by following these steps:

1. Change the Browse action method to retrieve a query string value from the URL. You can do this by adding a “genre” parameter to your action method. When you do this, ASP.NET MVC automatically passes any query string or form post parameters named “genre” to your action method when it is invoked.

//
// GET: /Store/Browse?genre=?Disco
public string Browse(string genre)
 {
    string message = 
       HttpUtility.HtmlEncode("Store.Browse, Genre = " + genre);

    return message;
 }

HTML Encoding User Input

We're using the HttpUtility.HtmlEncode utility method to sanitize the user input. This prevents users from injecting JavaScript code or HTML markup into our view with a link like /Store/Browse?Genre=<script>window.location=‘http://hacker.example.com’</script>.

2. Browse to /Store/Browse?Genre=Disco, as shown in Figure 2.13.

Figure 2.13

This shows that your controller actions can read a query string value by accepting it as a parameter on the action method.

//
// GET: /Store/Details/5
public string Details(int id)
 {
    string message = "Store.Details, ID = " + id;

    return message;
 }

Figure 2.14

As the preceding examples indicate, you can look at controller actions as if the web browser was directly calling methods on your controller class. The class, method, and parameters are all specified as path segments or query strings in the URL, and the result is a string that's returned to the browser. That's a huge oversimplification, ignoring things like:

• The way routing maps URL to actions
• The fact that you'll almost always use views as templates to generate the strings (usually HTML) to be returned to the browser
• The fact that actions rarely return raw strings; they usually return the appropriate ActionResult, which handles things like HTTP status codes, calling the View templating system, and so on

Controllers offer a lot of opportunities for customization and extensibility, but you'll probably find that you rarely—if ever—need to take advantage of that. In general use, controllers are called via a URL, they execute your custom code, and they return a view. With that in mind, we'll defer our look at the gory details behind how controllers are defined, invoked, and extended. You'll find those, with other advanced topics, in Chapter 14. You've learned enough about the basics of how controllers work to throw views into the mix, and we'll cover those in Chapter 3.