Microsoft Learn

Understanding Models in ASP.NET Core MVC

In the Model-View-Controller (MVC) architectural pattern, the Model represents the application's data and the business logic that operates on that data. It's responsible for managing the state and behavior of the application's core information.

The Role of Models

  • Data Representation: Models define the structure of your data. This could be simple data types, complex objects, or collections.
  • Business Logic: Models encapsulate the rules and operations related to your data. This includes data validation, calculations, data manipulation, and interactions with data sources (like databases).
  • Independence: Models are designed to be independent of the View and Controller. They shouldn't contain any UI-specific code or direct knowledge of how the data will be displayed or handled by the user interface.
  • Data Source Interaction: While models manage data, they often delegate the actual retrieval and storage of data to repositories or other data access services. This separation of concerns keeps the model focused on data logic rather than the specifics of persistence.

Creating Models

Models in ASP.NET Core MVC are typically represented by Plain Old CLR Objects (POCOs). You can create a model by defining a C# class.

Example: A Simple Product Model


public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Description { get; set; }
}

Data Annotations for Validation

ASP.NET Core provides a rich set of data annotations that can be applied to model properties to define validation rules. These annotations are often used in conjunction with the System.ComponentModel.DataAnnotations namespace.

Tip:

Data annotations are a powerful way to declaratively define validation rules directly within your model classes, making your code cleaner and more maintainable.

Example: Product Model with Validation


using System.ComponentModel.DataAnnotations;

public class Product
{
    public int Id { get; set; }

    [Required(ErrorMessage = "Product name is required.")]
    [StringLength(100, ErrorMessage = "Product name cannot exceed 100 characters.")]
    public string Name { get; set; }

    [Required(ErrorMessage = "Price is required.")]
    [Range(0.01, double.MaxValue, ErrorMessage = "Price must be greater than zero.")]
    public decimal Price { get; set; }

    public string Description { get; set; }
}

ViewModel vs. Domain Model

It's common to differentiate between Domain Models (representing core business entities) and ViewModels (designed specifically for a particular View). ViewModels can aggregate data from multiple domain models or adapt domain models for display purposes.

Note:

Using ViewModels helps decouple your views from your core business logic and can simplify data transfer to the view.

Example: ProductViewModel


public class ProductViewModel
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public string FormattedPrice { get; set; }
    public string ShortDescription { get; set; }
}

Interacting with Models in Controllers

Controllers are responsible for retrieving data from models, processing it, and passing it to the views for display. They also handle user input that might modify the model's state.

Example: Controller Action


using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using YourApp.Models; // Assuming Product and ProductViewModel are here

public class ProductController : Controller
{
    // Assume a service to get products
    private readonly IProductService _productService;

    public ProductController(IProductService productService)
    {
        _productService = productService;
    }

    public IActionResult Index()
    {
        var products = _productService.GetAllProducts();
        var productViewModels = products.Select(p => new ProductViewModel
        {
            ProductId = p.Id,
            ProductName = p.Name,
            FormattedPrice = p.Price.ToString("C"), // Format as currency
            ShortDescription = p.Description.Length > 50 ? p.Description.Substring(0, 50) + "..." : p.Description
        }).ToList();

        return View(productViewModels);
    }
}

Summary

Models are the foundation of your ASP.NET Core MVC application, housing your data and business logic. By effectively designing and implementing your models, you can build robust, maintainable, and scalable web applications.