Basics of ASP.NET MVC

A complete MVC pipeline with routes, models, views, and controllers.

In an ASP.NET MVC application, we have three crucial components: Model, View, Controller. The pattern is popular across many other ecosystems, and ASP.NET MVC is a particular flavor developed for .NET developers.

To get started, we first need to make sure that we register ASP.NET MVC in our Startup class. In our ConfigureServices method, we find a registration call to AddControllersWithViews. In our Configure method, we find route registration in the form of a call to endpoints.MapControllers(). These calls ensure that the MVC pipeline will handle the incoming HTTP requests.

All new endpoints will start with a Controller class. In our case, we're starting with a WidgetsController. After creating the controller, we can decorate it with a Route attribute. Adding a Route attribute to the controller allows us to prefix all actions with the controller name of Widget.

We follow up on the creation of our controller with a nested action of Index. This endpoint will return our view to be rendered by the client. Additionally, we can back this view with anIndexModel. The model allows us to pass information to the view for display purposes.

Next, we need to create a view called Index under the /Views/Widgets folder. The view will contain a form that will allow us to pass information from our browser client to a yet to be written endpoint of Create. Those of us familiar with HTML should find it very similar to our previous experiences building HTML forms.

Finally, we can create the Create endpoint in our WidgetsController. We need to remember to decorate our endpoints with a Route attribute. In this case, we want the path /widgets/create. This endpoint takes in a CreateModel that allows ASP.NET to bind our form data to our C# object. We can see the data comes from the form by using the parameter attribute of FromForm. For this basic demo, we'll store our form data in a static variable so it can survive past a single request.

We also need to update our IndexModel to display the results of our Name on our original Index view.

Running our sample, we can retrieve our index view, fill in our form, submit our data, and display the result in our HTML view. We've stepped through the basics of creating a request/response path in ASP.NET MVC. From here, many folks should have a decent foundation to build a functional ASP.NET MVC application.

Code Snippets

All snippets are included in their final form.

WidgetsController.cs

The following controller is located under /Controllers/WidgetsController.cs.

[Route("[controller]")]
public class WidgetsController : Controller
{
// GET
[HttpGet, Route("")]
public IActionResult Index()
{
var model = new IndexModel() { Name = Name };
return View(model);
}
// for demo purposes,
// we'll store our value here
private static string Name { get; set; }
[HttpPost, Route("create")]
public IActionResult Create([FromForm] CreateModel request)
{
Name = request.Name;
return RedirectToAction("Index");
}
}

Index.cshtml

The following view is located under /Views/Widgets/Index.cshtml.

@model IndexModel
@{
ViewBag.Title = "title";
Layout = "_Layout";
}
<h2>Widgets</h2>
@if (Model.HasName)
{
<p class="alert alert-info">
Hello, @Model.Name!
</p>
}
<form method="post" asp-action="Create">
<div class="form-group">
<label asp-for="Name"></label>
<input type="text" asp-for="Name">
</div>
<button type="submit" class="btn btn-primary">Save</button>
</form>

Models

The following C# objects are located under /Models/IndexModel.cs and /Models/CreateModel.cs.

public class IndexModel
{
public bool HasName => !string.IsNullOrEmpty(Name);
public string Name { get; set; }
}
public class CreateModel
{
public string Name { get; set; }
}

See Also