Data Transfer and Model Binding Between Controllers and Views in ASP.NET Core

In our previous article, we discussed how to create and use views. In this chapter, we’ll delve deeper into how to pass data between controllers and views—and how model binding works. These concepts are essential for building dynamic web applications, as they enable seamless integration between user-submitted data and your backend logic.

Data Passing

1. Passing Data to Views

In ASP.NET Core MVC, controllers are the primary components responsible for handling user requests. You can pass data from a controller to a view using several approaches:

• ViewData
  Using ViewData is one of the simplest ways to pass data. ViewData is a dictionary—you can add data to it in the controller and then retrieve those values in the view.

  public class HomeController : Controller
  {
      public IActionResult Index()
      {
          ViewData["Message"] = "Welcome to my website!";
          return View();
      }
  }
  

  In the view, you can access this value like so:

  <h1>@ViewData["Message"]</h1>
  

• ViewModel
  Using a dedicated ViewModel class is another recommended approach. A ViewModel is a class specifically designed to encapsulate the data required by a view.

  public class MyViewModel
  {
      public string Message { get; set; }
      public int Count { get; set; }
  }
  
  public class HomeController : Controller
  {
      public IActionResult Index()
      {
          var model = new MyViewModel
          {
              Message = "Welcome to my website!",
              Count = 10
          };
          return View(model);
      }
  }
  

  In the view, you can access the data via a strongly-typed ViewModel:

  @model MyViewModel
  
  <h1>@Model.Message</h1>
  <p>Count: @Model.Count</p>
  

2. Receiving Data from Views

User input—typically submitted via HTML forms—is received by controller actions. ASP.NET Core MVC handles this automatically through model binding, which maps form-submitted data to action method parameters.

Model Binding

Model binding is a powerful built-in mechanism. Here’s a basic example:

public class User
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class HomeController : Controller
{
    [HttpPost]
    public IActionResult Submit(User user)
    {
        if (ModelState.IsValid)
        {
            // Process user data
            return RedirectToAction("Success");
        }
        
        return View(user);
    }
}

In the view, you can use Tag Helpers to generate a simple form:

@model User

<form asp-action="Submit" method="post">
    <label asp-for="Name"></label>
    <input asp-for="Name" />
    
    <label asp-for="Age"></label>
    <input asp-for="Age" />
    
    <button type="submit">Submit</button>
</form>

3. Handling Complex Models

Sometimes your models may be more complex—for example, containing nested objects or collections. Model binding supports these scenarios seamlessly:

public class Order
{
    public int Id { get; set; }
    public List<Item> Items { get; set; }
}

public class Item
{
    public string ProductName { get; set; }
    public int Quantity { get; set; }
}

Your view can render a form with multiple items:

@model Order

<form asp-action="SubmitOrder" method="post">
    <input type="hidden" asp-for="Id" />
    
    @for (int i = 0; i < Model.Items.Count; i++)
    {
        <div>
            <label asp-for="Items[i].ProductName"></label>
            <input asp-for="Items[i].ProductName" />
            
            <label asp-for="Items[i].Quantity"></label>
            <input asp-for="Items[i].Quantity" />
        </div>
    }
    
    <button type="submit">Submit Order</button>
</form>

In the controller, model binding lets you easily receive the submitted data:

[HttpPost]
public IActionResult SubmitOrder(Order order)
{
    if (ModelState.IsValid)
    {
        // Process order data
    }
    
    return View(order);
}

Conclusion

In this section, we covered data passing and model binding in ASP.NET Core MVC. By leveraging ViewData, ViewModels, and HTML forms, we can efficiently pass data from controllers to views—and reliably submit user input back to controllers. These capabilities form the foundation for building dynamic, interactive web applications.

In the next chapter, we’ll explore dependency injection—a core feature of the ASP.NET Core framework that helps you build loosely coupled, testable applications.