What Makes a Method an Action
An action method is any public, non-static method on a controller class that the routing system can invoke to handle a matched request; by default every public method qualifies, though attributes like [NonAction] exclude a method, and [HttpGet], [HttpPost], [HttpPut], and [HttpDelete] restrict which HTTP verbs may invoke it. The action selector process, run after routing matches the {controller}/{action} template, uses the method name (or an [ActionName] override), the HTTP verb, and any [ActionMethodSelectorAttribute] rules such as authorization or route constraints to pick exactly one matching action, throwing an AmbiguousActionException if more than one candidate qualifies.
Cricket analogy: It is like how only players named on the official team sheet submitted before the toss are eligible to bat or bowl in that match, while a reserve sitting in the dugout is excluded until formally listed.
The IActionResult Family
Rather than writing directly to the response stream, action methods return an object implementing IActionResult, and the framework's action invoker executes that result to produce the final HTTP response, which cleanly separates 'what to return' from 'how to write it.' Common built-in results include ViewResult (renders a Razor view), JsonResult (serializes an object to JSON), ContentResult (writes raw text with a given content type), RedirectToActionResult (issues a 302/301 to another action), StatusCodeResult and its typed variants like NotFoundResult and BadRequestResult, and FileResult for streaming binary content, all of which the helper methods View(), Json(), Content(), RedirectToAction(), NotFound(), and File() construct for you.
Cricket analogy: It is like how a bowler's delivery is judged by the umpire's specific signal rather than the ball itself: a raised finger, a wide signal, or a no-ball call are distinct 'results' that determine what the scoreboard does next.
public class OrdersController : Controller
{
private readonly IOrderService _orders;
public OrdersController(IOrderService orders) => _orders = orders;
[HttpGet("orders/{id:int}")]
public IActionResult Details(int id)
{
var order = _orders.Find(id);
if (order == null)
return NotFound(); // 404 result
return View(order); // ViewResult
}
[HttpPost("orders")]
public IActionResult Create(OrderDto dto)
{
if (!ModelState.IsValid)
return BadRequest(ModelState); // 400 result
var created = _orders.Create(dto);
return RedirectToAction(nameof(Details), new { id = created.Id }); // 302 result
}
}Returning JSON and Content Directly
For API-style endpoints, actions frequently return Json(payload) or, in ASP.NET Core, simply return the model directly with an [ApiController]-decorated controller (which wraps it as ObjectResult and negotiates content type automatically), while Content(text, mimeType) writes a raw string body for cases like returning a plain text health check or a pre-serialized XML document. It is important to choose the correct result type deliberately: returning View() from an endpoint an SPA calls via fetch will attempt Razor rendering and fail, while returning Json() from a page meant to render HTML will send raw JSON to the browser instead of a page.
Cricket analogy: It is like a stadium's PA system choosing between announcing a wicket in English commentary or displaying it as a numeric scoreboard update; using the wrong channel for the audience causes confusion even though the underlying event is the same.
In ASP.NET Core, decorating a controller with [ApiController] enables automatic HTTP 400 responses on invalid model state and lets you return the model type directly (e.g., return order;) instead of always wrapping it in Json(), since the framework negotiates JSON serialization for you.
Testing Action Results
Because actions return IActionResult rather than writing directly to the response, unit tests can assert on the returned type and its properties without spinning up a real HTTP pipeline: a test can call controller.Details(5) and assert the result is a ViewResult with a specific Model, or that Details(999) returns a NotFoundResult. This testability is one of the main reasons the framework favors typed results over methods like Response.Write(), since asserting against a concrete Response stream would require a full integration test host rather than a plain unit test.
Cricket analogy: It is like a coach reviewing a player's shot selection purely from the scorecard and match footage in isolation, without needing to run an entire live match to verify the technique worked.
Returning the wrong IActionResult type for the calling context is a common bug: an [ApiController] endpoint that returns View() when no Razor view exists will throw an InvalidOperationException at runtime, and a page-rendering action that accidentally returns Json() will send raw JSON text to a browser expecting HTML.
- Any public, non-static controller method is an action by default; [NonAction] excludes one, and Http-verb attributes restrict which verbs invoke it.
- Actions return IActionResult so the framework, not the developer, controls how the response is finally written.
- ViewResult, JsonResult, ContentResult, RedirectToActionResult, and NotFoundResult are common built-in result types.
- [ApiController] enables automatic model validation responses and direct return of model objects, which get JSON-serialized automatically.
- Choosing the wrong result type (View vs Json) for the calling client is a frequent source of runtime errors.
- Because actions return typed results, they can be unit tested by asserting on the returned object rather than a raw HTTP response.
- AmbiguousActionException is thrown when more than one action method matches a request after action selection.
Practice what you learned
1. What attribute excludes an otherwise public controller method from being treated as an action?
2. Why do action methods return IActionResult instead of writing directly to the response?
3. What happens if two action methods both match a request after action selection?
4. What does decorating a controller with [ApiController] enable?
5. What is a common bug related to action results?
Was this page helpful?
You May Also Like
Controllers Basics
Learn what a controller is in ASP.NET MVC, how it is discovered and instantiated, and how it coordinates models and views to handle a request.
Action Filters
Learn how filters let you run cross-cutting logic before and after action execution, and how the different filter types fit into the MVC pipeline.
Attribute Routing
Learn how to declare routes directly on controllers and actions with attributes, and how this approach complements or replaces convention-based routing.
Related Reading
Related Study Notes in Microsoft Technologies
Browse all study notesWindows 10 / UWP Development Study Notes
.NET · 30 topics
Microsoft TechnologiesWindows Batch Scripting Study Notes
Batch · 30 topics
Microsoft TechnologiesMFC (Microsoft Foundation Classes) Study Notes
C++ · 30 topics
Microsoft TechnologiesSilverlight Study Notes
.NET · 30 topics
Microsoft TechnologiesXAML Study Notes
.NET · 30 topics
Microsoft TechnologiesWPF (Windows Presentation Foundation) Study Notes
.NET · 30 topics