.NET Models

Introduction

Models are a fundamental component in .NET web development that represent the data structure of your application. They serve as a blueprint for the data that your application will manipulate, store, and display. In the Model-View-Controller (MVC) architectural pattern, models are the 'M' component, representing the application's data and business logic.

In this article, we'll explore what models are in .NET, how to create them, and how they fit into the broader context of web application development. We'll cover both simple models and more complex ones using Entity Framework, Microsoft's object-relational mapping (ORM) framework.

What Are Models in .NET?

In .NET web applications, models are typically C# classes that define the structure of your data. They can range from simple Plain Old CLR Objects (POCOs) to more complex entities that include validation logic, data annotations, and relationships with other models.

Models serve several purposes:

Data Structure Definition: They define the shape of your data
Data Validation: They can include validation rules
Data Mapping: They facilitate mapping between different data representations
Business Logic: They can encapsulate business rules and behavior

Creating Basic Models

Let's start by creating a simple model for a blog post:

csharp
// Simple model without any dependencies
public class BlogPost
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime PublishedDate { get; set; }
    public string Author { get; set; }
}

This model has five properties representing different aspects of a blog post. It's a simple POCO without any specific .NET dependencies.

Adding Data Annotations

Data annotations allow you to add metadata to your model classes, which can be used for validation, formatting, and other purposes:

csharp
using System.ComponentModel.DataAnnotations;

public class BlogPost
{
    public int Id { get; set; }
    
    [Required(ErrorMessage = "Title is required")]
    [StringLength(100, MinimumLength = 5, ErrorMessage = "Title must be between 5 and 100 characters")]
    public string Title { get; set; }
    
    [Required(ErrorMessage = "Content is required")]
    public string Content { get; set; }
    
    [DataType(DataType.Date)]
    [Display(Name = "Published Date")]
    public DateTime PublishedDate { get; set; }
    
    [Required]
    public string Author { get; set; }
}

With these annotations:

The Title is required and must be between 5 and 100 characters
The Content is required
The PublishedDate is displayed as a date (without time)
The Author is required

Models with Relationships

Most real-world applications have related data. Let's see how to represent relationships between models:

csharp
public class Author
{
    public int Id { get; set; }
    
    [Required]
    public string Name { get; set; }
    
    [EmailAddress]
    public string Email { get; set; }
    
    // Navigation property for one-to-many relationship
    public virtual ICollection<BlogPost> BlogPosts { get; set; }
}

public class BlogPost
{
    public int Id { get; set; }
    
    [Required]
    public string Title { get; set; }
    
    [Required]
    public string Content { get; set; }
    
    public DateTime PublishedDate { get; set; }
    
    // Foreign key property
    public int AuthorId { get; set; }
    
    // Navigation property for many-to-one relationship
    public virtual Author Author { get; set; }
    
    // Navigation property for one-to-many relationship
    public virtual ICollection<Comment> Comments { get; set; }
}

public class Comment
{
    public int Id { get; set; }
    
    [Required]
    public string Text { get; set; }
    
    public DateTime CommentDate { get; set; }
    
    // Foreign key property
    public int BlogPostId { get; set; }
    
    // Navigation property for many-to-one relationship
    public virtual BlogPost BlogPost { get; set; }
}

In this example:

An Author can have many BlogPosts (one-to-many)
A BlogPost belongs to one Author (many-to-one)
A BlogPost can have many Comments (one-to-many)
A Comment belongs to one BlogPost (many-to-one)

View Models

View models are specialized models designed specifically for views. They allow you to shape data exactly as needed for a particular view:

csharp
public class BlogPostViewModel
{
    public string Title { get; set; }
    public string Excerpt { get; set; }
    public string AuthorName { get; set; }
    public DateTime PublishedDate { get; set; }
    public int CommentCount { get; set; }
}

This view model contains only the information needed for a blog post listing, not the full content or all related data.

Using Models with Entity Framework

Entity Framework (EF) is Microsoft's ORM that allows you to work with your database using .NET objects. Here's how to set up your models for use with EF:

First, define your DbContext:

csharp
using Microsoft.EntityFrameworkCore;

public class BlogDbContext : DbContext
{
    public BlogDbContext(DbContextOptions<BlogDbContext> options)
        : base(options)
    {
    }
    
    public DbSet<Author> Authors { get; set; }
    public DbSet<BlogPost> BlogPosts { get; set; }
    public DbSet<Comment> Comments { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Configure the relationships
        modelBuilder.Entity<BlogPost>()
            .HasOne(b => b.Author)
            .WithMany(a => a.BlogPosts)
            .HasForeignKey(b => b.AuthorId);
            
        modelBuilder.Entity<Comment>()
            .HasOne(c => c.BlogPost)
            .WithMany(b => b.Comments)
            .HasForeignKey(c => c.BlogPostId);
    }
}

csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContext<BlogDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
        
    services.AddControllersWithViews();
}

Now you can use your models in controllers:

csharp
public class BlogController : Controller
{
    private readonly BlogDbContext _context;
    
    public BlogController(BlogDbContext context)
    {
        _context = context;
    }
    
    public async Task<IActionResult> Index()
    {
        var blogPosts = await _context.BlogPosts
            .Include(b => b.Author)
            .Include(b => b.Comments)
            .ToListAsync();
            
        return View(blogPosts);
    }
    
    public async Task<IActionResult> Details(int id)
    {
        var blogPost = await _context.BlogPosts
            .Include(b => b.Author)
            .Include(b => b.Comments)
            .FirstOrDefaultAsync(m => m.Id == id);
            
        if (blogPost == null)
        {
            return NotFound();
        }
        
        return View(blogPost);
    }
    
    // More action methods...
}

Data Transfer Objects (DTOs)

DTOs are special kinds of models used to transfer data between different layers of your application or between your application and external systems:

csharp
public class BlogPostDto
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime PublishedDate { get; set; }
    public AuthorDto Author { get; set; }
}

public class AuthorDto
{
    public int Id { get; set; }
    public string Name { get; set; }
}

DTOs are particularly useful in API controllers:

csharp
[ApiController]
[Route("api/[controller]")]
public class BlogPostsController : ControllerBase
{
    private readonly BlogDbContext _context;
    
    public BlogPostsController(BlogDbContext context)
    {
        _context = context;
    }
    
    [HttpGet]
    public async Task<ActionResult<IEnumerable<BlogPostDto>>> GetBlogPosts()
    {
        var posts = await _context.BlogPosts
            .Include(b => b.Author)
            .ToListAsync();
            
        var dtos = posts.Select(p => new BlogPostDto
        {
            Id = p.Id,
            Title = p.Title,
            Content = p.Content,
            PublishedDate = p.PublishedDate,
            Author = new AuthorDto 
            {
                Id = p.Author.Id,
                Name = p.Author.Name
            }
        });
        
        return Ok(dtos);
    }
    
    // More action methods...
}

Real-World Example: E-Commerce Product Catalog

Let's build a more comprehensive example of models for an e-commerce product catalog:

csharp
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace ECommerce.Models
{
    public class Category
    {
        public int Id { get; set; }
        
        [Required]
        [StringLength(100)]
        public string Name { get; set; }
        
        public string Description { get; set; }
        
        // Self-referencing relationship for hierarchical categories
        public int? ParentCategoryId { get; set; }
        public virtual Category ParentCategory { get; set; }
        public virtual ICollection<Category> ChildCategories { get; set; }
        
        public virtual ICollection<Product> Products { get; set; }
    }
    
    public class Product
    {
        public int Id { get; set; }
        
        [Required]
        [StringLength(200)]
        public string Name { get; set; }
        
        public string Description { get; set; }
        
        [Required]
        [Column(TypeName = "decimal(18,2)")]
        public decimal Price { get; set; }
        
        public int StockQuantity { get; set; }
        
        [StringLength(50)]
        public string SKU { get; set; }
        
        public bool IsAvailable { get; set; }
        
        public DateTime CreatedAt { get; set; }
        public DateTime? UpdatedAt { get; set; }
        
        // Category relationship
        public int CategoryId { get; set; }
        public virtual Category Category { get; set; }
        
        // Many-to-many relationship with tags
        public virtual ICollection<ProductTag> ProductTags { get; set; }
        
        // One-to-many relationship with images
        public virtual ICollection<ProductImage> Images { get; set; }
        
        // One-to-many relationship with reviews
        public virtual ICollection<ProductReview> Reviews { get; set; }
    }
    
    public class ProductTag
    {
        // Composite key
        public int ProductId { get; set; }
        public int TagId { get; set; }
        
        // Navigation properties
        public virtual Product Product { get; set; }
        public virtual Tag Tag { get; set; }
    }
    
    public class Tag
    {
        public int Id { get; set; }
        
        [Required]
        [StringLength(50)]
        public string Name { get; set; }
        
        public virtual ICollection<ProductTag> ProductTags { get; set; }
    }
    
    public class ProductImage
    {
        public int Id { get; set; }
        
        [Required]
        public string ImageUrl { get; set; }
        
        public bool IsMain { get; set; }
        
        public string AltText { get; set; }
        
        // Foreign key
        public int ProductId { get; set; }
        public virtual Product Product { get; set; }
    }
    
    public class ProductReview
    {
        public int Id { get; set; }
        
        [Required]
        public string Title { get; set; }
        
        public string Content { get; set; }
        
        [Range(1, 5)]
        public int Rating { get; set; }
        
        public DateTime CreatedAt { get; set; }
        
        // Foreign keys
        public int ProductId { get; set; }
        public virtual Product Product { get; set; }
        
        public string UserId { get; set; }
        public virtual ApplicationUser User { get; set; }
    }
}

This example demonstrates:

Hierarchical data (categories)
One-to-many relationships (products to images, products to reviews)
Many-to-many relationships (products to tags)
Custom data types and validation

Summary

Models in .NET provide a way to structure your application's data and enforce consistency through validation rules and relationships. They serve as a crucial part of the MVC pattern, representing the data layer of your application.

In this guide, we've covered:

Basic model creation
Data annotations for validation
Relationship between models
View models for specific view requirements
Using models with Entity Framework
Data Transfer Objects for API communication
A comprehensive real-world example

As you develop more complex .NET applications, you'll find that well-designed models are essential for maintainable, scalable code. They provide a clear representation of your data structure and help enforce business rules throughout your application.

Additional Resources and Exercises

Resources

Exercises

Basic Model Creation: Create a Customer model with properties for Name, Email, Phone, and Address. Add appropriate data annotations for validation.
Relationships: Extend the Customer model by adding an Order model with a one-to-many relationship. Each order should have an OrderDate, Status, and Total.
View Models: Create a view model for a customer dashboard that includes customer information and a summary of their recent orders.
Complex Relationships: Build a school management system with models for Students, Courses, and Instructors with appropriate many-to-many relationships.
API DTOs: Create DTOs for the blog post example that would be suitable for different API endpoints (listing, details, create/update).

By working through these exercises, you'll gain practical experience in designing and implementing models for .NET web applications.

If you spot any mistakes on this website, please let me know at [email protected]. I’d greatly appreciate your feedback! :)

Introduction​

What Are Models in .NET?​

Creating Basic Models​

Adding Data Annotations​

Models with Relationships​

View Models​

Using Models with Entity Framework​

Data Transfer Objects (DTOs)​

Real-World Example: E-Commerce Product Catalog​

Summary​

Additional Resources and Exercises​

Resources​

Exercises​