A Simple Example: The Home Controller

Before writing any real code, let's start by looking at what's included by default in a new project. Projects created using the MVC template with Individual User Accounts include two controller classes:

• HomeController: Responsible for the “home page” at the root of the website, as well as an “about page” and a “contact 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.

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 happens when you browse to the homepage of the website. Follow these steps to make a simple edit and run the application:

1. Replace “Your application description page.” in the About method with the phrase of your choice—perhaps, “I like cake!:

   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()
           {
               return View();
           }
           public ActionResult About()
           {
                        ViewBag.Message = "I like cake!";
               return View();
           }
           public ActionResult Contact()
           {
               ViewBag.Message = "Your contact page.";
               return View();
           }
       }
   }
   

2. Run the application by pressing the F5 key (or by using the Debug Start Debugging menu item, if you prefer). Visual Studio compiles the application and launches the site running under IIS Express.

   

3. A browser window opens and the home page of the site appears, as shown in Figure 2.8.
4. Navigate to the About page by browsing to /Home/About (or by clicking the About link in the header). Your updated message displays, as shown in 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 Controller

In this section, you'll create 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 the music albums in a particular genre.
• Clicking an album leads to a details page that shows information about a specific music album.

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:

1. Change the signature of the Index method to return a string (rather than an ActionResult) and change the return value to "Hello from Store.Index()" as follows:

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

2. Add a Store.Browse action that returns “Hello from Store.Browse()” and a Store.Details action that returns “Hello from Store.Details()”, as shown in the complete code for the StoreController that follows:

   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()";
          }
      }
   }

3. Run the project again and browse the following URLs:
   • /Store
   • /Store/Browse
   • /Store/Details

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

Parameters in Controller Actions

The previous examples have been of 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 of type string 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;
   }

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

   

3. This shows that your controller actions can read a query string value by accepting it as a parameter on the action method.
4. Change the Details action to read and display an input parameter named ID. Unlike the previous method, you won't be embedding the ID value as a query string parameter. Instead you'll embed it directly within the URL itself. For example: /Store/Details/5.

   ASP.NET MVC lets you easily do this without having to configure anything extra. ASP.NET MVC's default routing convention is to treat the segment of a URL after the action method name as a parameter named ID. If your action method has a parameter named ID, then ASP.NET MVC automatically passes the URL segment to you as a parameter.

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

5. Run the application and browse to /Store/Details/5, as shown in Figure 2.15.

   

As the preceding examples indicate, you can look at controller actions as if the web browser were 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 such as:

• The way routing maps the 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 such as 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 fact. 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 can find those, with other advanced topics, discussed in Chapter 15. You've learned enough about the basics of how controllers work to throw views into the mix, and we cover those in Chapter 3.