ASP.NET MVC Architecture | .NET

MVC (Model-View-Controller) is a design pattern that is frequently employed in web applications to enhance the organization of code and distinct concerns. This pattern is effectively implemented by ASP.NET MVC, which enables developers to create scalable, robust web applications. We will examine the operation of an ASP.NET MVC controller and provide a comprehensive example.

Key Components of MVC Model: Defines the data and business logic. It is accountable for the retrieval, storage, and validation of data.
View: The user interface that presents the data from the model to the user. It is typically composed of server-side code (such as Razor) and HTML.
Controller: Serves as a mediator between the Model and the View. It processes user input, engages with the model, and returns the appropriate view.

The Role of the Controller

The controller is crucial in the MVC framework. It processes incoming requests, manipulates the model, and selects the view to render. Here’s a step-by-step explanation of how the controller works:

1. Routing: When a user makes a request to an ASP.NET MVC application, the request is routed to the appropriate controller based on the URL pattern defined in the routing configuration (typically found in RouteConfig.cs).
2. Action Methods: The controller contains action methods that correspond to different user actions. Each method typically returns an ActionResult, which could be a view, JSON data, or a redirect.
3. Interacting with Models: The controller interacts with the model to retrieve or manipulate data. It then prepares this data for the view.
4. Selecting a View: After processing the request and preparing the data, the controller selects a view to render and passes the model data to that view.
5. Returning the Response: Finally, the controller returns the view (or other response) to the user.

Example Application: Bookstore Management

Let’s build a simple bookstore management application to illustrate how a controller works in ASP.NET MVC. This example will cover a scenario where users can view a list of books, add new books, and view details about a specific book.

Step 1: Set Up the Model

First, we define a Book model that represents the data structure of a book.

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Author { get; set; }
    public decimal Price { get; set; }
}

Next, we’ll create a data context to manage the list of books. For simplicity, we will use an in-memory list.

public class BookStoreContext
{
    public List<Book> Books { get; set; }

    public BookStoreContext()
    {
        Books = new List<Book>
        {
            new Book { Id = 1, Title = "1984", Author = "George Orwell", Price = 9.99m },
            new Book { Id = 2, Title = "To Kill a Mockingbird", Author = "Harper Lee", Price = 14.99m }
        };
    }
}

Step 2: Create the Controller

Now, let’s create a BooksController that will handle requests related to books.

using System.Linq;
using System.Web.Mvc;

public class BooksController : Controller
{
    private BookStoreContext db = new BookStoreContext();

    // GET: Books
    public ActionResult Index()
    {
        var books = db.Books;
        return View(books);
    }

    // GET: Books/Details/5
    public ActionResult Details(int id)
    {
        var book = db.Books.FirstOrDefault(b => b.Id == id);
        if (book == null)
        {
            return HttpNotFound();
        }
        return View(book);
    }

    // GET: Books/Create
    public ActionResult Create()
    {
        return View();
    }

    // POST: Books/Create
    [HttpPost]
    [ValidateAntiForgeryToken]
    public ActionResult Create(Book book)
    {
        if (ModelState.IsValid)
        {
            book.Id = db.Books.Max(b => b.Id) + 1; // Simple ID generation
            db.Books.Add(book);
            return RedirectToAction("Index");
        }
        return View(book);
    }
}

Step 3: Create Views

Now, we will create the corresponding views for our actions.

1. Index.cshtml: Displays a list of books.

@model IEnumerable<Book>

<h2>Books</h2>
<table>
    <tr>
        <th>Title</th>
        <th>Author</th>
        <th>Price</th>
        <th></th>
    </tr>
    @foreach (var book in Model)
    {
        <tr>
            <td>@book.Title</td>
            <td>@book.Author</td>
            <td>@book.Price.ToString("C")</td>
            <td>
                @Html.ActionLink("Details", "Details", new { id = book.Id })
            </td>
        </tr>
    }
</table>

@Html.ActionLink("Create New", "Create")

2. Details.cshtml: Displays details of a specific book.

@model Book

<h2>@Model.Title</h2>
<p>Author: @Model.Author</p>
<p>Price: @Model.Price.ToString("C")</p>
@Html.ActionLink("Edit", "Edit", new { id = Model.Id }) |
@Html.ActionLink("Back to List", "Index")

3. Create.cshtml: A form to add a new book.

@model Book

<h2>Create New Book</h2>

@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()

    <div>
        @Html.LabelFor(m => m.Title)
        @Html.TextBoxFor(m => m.Title)
    </div>
    <div>
        @Html.LabelFor(m => m.Author)
        @Html.TextBoxFor(m => m.Author)
    </div>
    <div>
        @Html.LabelFor(m => m.Price)
        @Html.TextBoxFor(m => m.Price)
    </div>
    <input type="submit" value="Create" />
}
@Html.ActionLink("Back to List", "Index")

Step 4: Configure Routing

Ensure that your routing is set up correctly in RouteConfig.cs:

public class RouteConfig
{
    public static void RegisterRoutes(RouteCollection routes)
    {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
        routes.MapRoute(
            name: "Default",
            url: "{controller}/{action}/{id}",
            defaults: new { controller = "Books", action = "Index", id = UrlParameter.Optional }
        );
    }
}

In this example, we explored how an ASP.NET MVC controller interacts with models and views. The BooksController facilitated user interactions by:

• Displaying a list of books.
• Showing details for a specific book.
• Handling the creation of new books.

It is simpler to maintain and test applications due to the separation of concerns that MVC provides, which promotes organized code. Developers can guarantee that their web applications are both user-friendly and functional by utilizing controllers effectively. Entity Framework enables the extension of this methodology to more intricate applications that incorporate a variety of features, including authentication, validation, and database interaction.