NET Centric Computing (BSc CSIT, CSC367): the questions likely to come

MVC Design Pattern

MVC (Model-View-Controller) is an architectural pattern that separates an application into three interconnected components, achieving separation of concerns, testability and parallel development.

• Model — represents the application's data and business logic (e.g. domain classes, validation, database access). It is independent of the UI.
• View — the presentation layer that renders the model as UI (HTML in web apps). It is passive and contains no business logic.
• Controller — handles incoming requests, processes user input, interacts with the model, selects a view and returns a response. It acts as the coordinator.

Flow / Diagram (described)

        (1) HTTP Request
User ───────────────────────▶ Controller
  ▲                              │  (2) updates / queries
  │                              ▼
  │                            Model  ◀──▶ Database
  │                              │  (3) returns data
  │  (5) rendered response       ▼
  └──────────  View  ◀──────────┘ (4) controller selects view + passes model

The controller receives the request, asks the model for data, passes it to a view, and the view renders the output back to the user.

ASP.NET Core Architecture

ASP.NET Core is a cross-platform, open-source, high-performance framework for building web apps and APIs. Its architecture is centred on:

• Kestrel web server — a lightweight cross-platform HTTP server hosting the app, often behind a reverse proxy (IIS/Nginx).
• Middleware pipeline — request processing is a chain of middleware components (authentication, routing, static files, MVC, error handling). Each can short-circuit or pass to the next, configured in Program.cs.
• Dependency Injection (DI) — a built-in IoC container registers services and injects them into controllers/components.
• Routing — maps incoming URLs to controller actions (attribute or conventional routing).
• Configuration — layered providers (appsettings.json, environment variables, command line).

Request pipeline (described)

Request ▶ [Kestrel] ▶ [Exception/HSTS] ▶ [Static Files] ▶ [Routing]
        ▶ [Authentication] ▶ [Authorization] ▶ [Endpoint/MVC] ▶ Response

Design Principles of ASP.NET Core

1. Modularity — features come as small NuGet packages added only as needed.
2. Dependency Injection first-class — loose coupling and testability.
3. Middleware-based, composable pipeline — each concern is a separate component.
4. Cross-platform & cloud-ready — runs on Windows, Linux, macOS, containers.
5. Convention over configuration with the option to override.
6. Unified MVC + Web API + Razor Pages programming model.

Summary

MVC cleanly separates data (Model), presentation (View) and request handling (Controller). ASP.NET Core implements this on a modular, DI-driven, middleware pipeline hosted by Kestrel, giving a cross-platform, testable and high-performance web framework.