Controllers

Learning objectives#

• Create controllers that MVC can discover
• Use the properties the Controller base class gives you
• Read query string values through action parameters
• Keep controllers thin by delegating to services

Explanation#

A controller is a public class whose name ends in Controller and which inherits System.Web.Mvc.Controller. MVC finds it by name: /Orders/... looks for OrdersController in any namespace of the app.

Every public, non-static method is an action that can be called from a URL. Make helper methods private (or mark them [NonAction]) so nobody can call them from the browser.

The base class gives you the current request through properties: Request (URL, query string, headers, HttpMethod), Response, RouteData, Session, TempData, User (the signed-in user) and ModelState.

You rarely need Request.QueryString directly: an action parameter with the same name as the query string key is filled automatically by model binding, already converted to the right type.

A new controller instance is created for every request and disposed afterwards. Keep it stateless, and move business rules and data access into services that the controller calls.

Syntax#

1public class OrdersController : Controller
2{
3    // GET /Orders?status=open&page=2
4    public ActionResult Index(string status, int page = 1) { ... }
5}

Code example: A thin controller that uses request data#

1// Models/OrderService.cs
2using System.Collections.Generic;
3using System.Linq;
4

5namespace ShopSite.Models
6{
7    public class Order
8    {
9        public int Id { get; set; }
10        public string Customer { get; set; }
11        public string Status { get; set; }
12    }
13

14    public class OrderService
15    {
16        private static readonly List<Order> Orders = new List<Order>
17        {
18            new Order { Id = 101, Customer = "Asha", Status = "open" },
19            new Order { Id = 102, Customer = "Ravi", Status = "shipped" },
20            new Order { Id = 103, Customer = "Meera", Status = "open" },
21        };
22

23        public List<Order> Find(string status)
24        {
25            return string.IsNullOrEmpty(status)
26                ? Orders.ToList()
27                : Orders.Where(o => o.Status == status).ToList();
28        }
29    }
30}
31

32// Controllers/OrdersController.cs
33using System.Linq;
34using System.Web.Mvc;
35using ShopSite.Models;
36

37namespace ShopSite.Controllers
38{
39    public class OrdersController : Controller
40    {
41        private readonly OrderService _orders = new OrderService();
42

43        // GET /Orders  or  /Orders?status=open
44        public ActionResult Index(string status)
45        {
46            var found = _orders.Find(status);
47            var lines = found.Select(o => 
quot;#{o.Id} {o.Customer} ({o.Status})");
48            var info = 
quot;{Request.HttpMethod} {Request.Url.PathAndQuery} handled by {RouteData.Values["controller"]}.{RouteData.Values["action"]}";
49            return Content(info + "\n" + string.Join("\n", lines), "text/plain");
50        }
51

52        // Not reachable from a URL
53        [NonAction]
54        public string Secret() => "hidden";
55    }
56}

GET /Orders
200 OK
GET /Orders handled by Orders.Index
#101 Asha (open)
#102 Ravi (shipped)
#103 Meera (open)

GET /Orders?status=open
200 OK
GET /Orders?status=open handled by Orders.Index
#101 Asha (open)
#103 Meera (open)

GET /Orders/Secret
404 Not Found

This example is illustrative. Copy or download it and run it in your own environment; the expected output is shown above.

Step-by-step explanation#

1. GET /Orders matches the Default route; MVC creates OrdersController and calls Index with status = null.
2. With ?status=open, model binding copies the query string value into the status parameter — no Request.QueryString code needed.
3. Request.HttpMethod, Request.Url and RouteData are available from the Controller base class.
4. The OrderService does the filtering, so the controller stays a few lines long.
5. [NonAction] hides Secret from routing, so /Orders/Secret returns 404.

Real-world use case#

Common mistakes#

Best practices#

• One controller per resource or feature
• Receive input as action parameters, not Request.QueryString
• Delegate work to services and keep actions under ~20 lines
• Mark non-action public methods with [NonAction]

Remember this#

Practice exercise#

1// Controllers/OrdersController.cs
2using System;
3using System.Linq;
4using System.Web.Mvc;
5

6namespace ShopSite.Controllers
7{
8    public class OrdersController : Controller
9    {
10        private static readonly (int Id, string Customer)[] Orders = { (101, "Asha"), (102, "Ravi"), (103, "Arjun") };
11

12        // GET /Orders/Search?customer=a
13        public ActionResult Search(string customer)
14        {
15            var ids = Orders
16                .Where(o => !string.IsNullOrEmpty(customer) && o.Customer.StartsWith(customer, StringComparison.OrdinalIgnoreCase))
17                .Select(o => "#" + o.Id)
18                .ToList();
19            return Content(ids.Any() ? string.Join(", ", ids) : "No orders", "text/plain");
20        }
21    }
22}

GET /Orders/Search?customer=a
200 OK
#101, #103

GET /Orders/Search?customer=zed
200 OK
No orders

Mini quiz#

Want more? Practise all ASP.NET MVC MCQs · ASP.NET MVC interview questions

Related topics#

My notes#

Saved in this browser.