ASP.NET MVC Tutorialprovides basic and advanced concepts of C# for beginners and professionals.

  1. Home
  2. ASP.NET MVC Tutorial

ASP.NET MVC Controllers

Back to: ASP.NET MVC Tutorial

In ASP.NET MVC (Model-View-Controller), Controllers play a central role in handling user requests, processing data, and returning responses. They manage the flow of the application by interacting with both the View (user interface) and Model (business logic or data).

Here’s a detailed breakdown of Controllers in ASP.NET MVC:

1. Purpose of Controllers

  • Handle incoming HTTP requests: Controllers respond to requests made by a browser or other client.
  • Coordinate data between the model and view: They retrieve data from models, pass it to views, and ensure the user interface reflects the correct data.
  • Control the logic flow: Based on the request, controllers can invoke appropriate models, handle business logic, and determine the response (e.g., HTML, JSON, XML).

2. Structure of a Controller

  • Class: Controllers are typically C# classes that inherit from the Controller base class (System.Web.Mvc.Controller).
  • Naming convention: By convention, controller names must end with the word Controller. For example, a controller for products might be named ProductController.
  • Action methods: Controllers contain methods known as action methods, which respond to specific HTTP requests.

3. Action Methods

Action methods in a controller handle requests and return responses. Each method corresponds to an HTTP request, such as:

  • GET: Retrieve data (e.g., display a web page).
  • POST: Submit data (e.g., form submission).
  • PUT: Update data.
  • DELETE: Remove data.

Example of an action method:

csharp
public class HomeController : Controller
{
  public ActionResult Index()
 {
 // Fetch data (optional)
 // Return a view to display data
  return View();
 }
  [HttpPost]
public ActionResult SubmitForm(MyModel model)
 {
  // Process the submitted data
  if (ModelState.IsValid)
 {
  // Save or process the model
 }
  return RedirectToAction("Index");
 }
}
  • ActionResult: Action methods return an ActionResult, which determines the type of response. Examples include:
    • View(): Returns an HTML view.
    • Json(): Returns JSON data.
    • RedirectToAction(): Redirects to another action.
    • File(): Returns a file to be downloaded.
    • Content(): Returns raw content (text, HTML).

4. Controller Routing

Routing is the mechanism that maps URLs to controller action methods. ASP.NET MVC uses route configuration to define how URLs correspond to specific actions and controllers.

  • Default route configuration (defined in RouteConfig.cs):
    routes.MapRoute
    (
    name: "Default",
    url: "{controller}/{action}/{id}",
    defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
    );

This configuration maps URLs like /Home/Index/1 to HomeController’s Index action with an ID of 1.

5. Passing Data to the View

Controllers can pass data to views using several methods:

  • ViewBag: A dynamic object for passing data from the controller to the view.
    ViewBag.Message = "Hello World";
  • ViewData: A dictionary for passing key-value pairs.
    ViewData["Message"] = "Hello World";
  • Strongly Typed Model: The recommended way to pass data, where a model is passed directly to the view.
    return View(model);

6. Action Filters

Action filters allow code to run before or after a controller action. They are used for:

  • Authentication/Authorization (e.g., [Authorize]).
  • Logging.
  • Error handling.

Examples:

  • [Authorize]: Ensures that only authenticated users can access the action.
  • [HandleError]: Handles exceptions thrown by an action.

7. Types of Controllers

  • Base Controllers: Can be used to create reusable controller logic that multiple controllers can inherit from.

    public class BaseController : Controller
    {
    // Shared functionality here
    }
    public class HomeController : BaseController
    {
    // Inherits from BaseController
    }

  • API Controllers: Used for handling RESTful API requests. They are typically used in ASP.NET Web API (which can also be used with ASP.NET MVC).

    public class ApiProductController : ApiController
    {
     public IHttpActionResult GetProduct(int id)
     {
      // Fetch and return product as JSON
     }
    }

8. Controller Dependencies

To ensure controllers remain testable and adhere to clean coding practices, dependencies should be injected into controllers rather than instantiated inside them. This is typically done using Dependency Injection (DI).

Example using constructor injection:

public class ProductController : Controller
{
 private readonly IProductService _productService;
 public ProductController(IProductService productService)
 {
 _productService = productService;
 }
 public ActionResult List()
 {
  var products = _productService.GetProducts();
  return View(products);
 }
}

9. TempData

TempData is used to pass data between actions that only needs to be available for a single request. Unlike ViewBag or ViewData, TempData persists across redirects:

TempData["Message"] = "This is a temporary message";
return RedirectToAction("AnotherAction");

10. Common Controller Attributes

  • [HttpGet], [HttpPost], [HttpPut], [HttpDelete]: Define the HTTP verb an action method responds to.
  • [Authorize]: Restricts access to authenticated users.
  • [ValidateAntiForgeryToken]: Ensures that POST requests are secure by validating anti-forgery tokens.

Conclusion

Controllers are the backbone of ASP.NET MVC applications, handling incoming requests, orchestrating data flow, and determining the appropriate responses. By adhering to best practices, such as separation of concerns and using dependency injection, developers can create modular, maintainable, and testable controllers.

Scroll to Top