ASP.NET Core Architecture
Understand the architecture and components of ASP.NET Core applications
Module Overview & Professional Context
Data persistence is at the heart of virtually every real-world application, and .NET Core provides a world-class Object-Relational Mapping (ORM) tool for working with relational databases: Entity Framework Core. EF Core is an open-source, lightweight, extensible version of Microsoft's Entity Framework data access technology. It enables .NET developers to work with databases using .NET objects, eliminating most of the data-access code that developers usually need to write. EF Core supports SQL Server, PostgreSQL, MySQL, SQLite, Oracle, and more through a provider model that keeps your core codebase database-agnostic. The foundation of EF Core is the DbContext class, which represents a session with the database and serves as the unit of work and repository pattern implementation. A DbContext subclass contains DbSet<T> properties — one for each entity type (table). DbSet<T> exposes LINQ-based querying that translates C# expressions into efficient SQL queries at runtime. Because queries are built as expression trees rather than strings, they are type-safe (IntelliSense and compile-time checking), composable (you can chain conditions, projections, and joins), and automatically parameterized (preventing SQL injection). The same C# code works against any supported database engine with only a provider change in configuration. EF Core offers two approaches to defining the database schema. The Code-First approach starts with C# entity classes and derives the database schema from them using migrations — version-controlled, incremental scripts that evolve the schema as your model changes. Each migration is a pair of C# methods (Up and Down) that apply and reverse the change. The Database-First approach starts from an existing database and scaffolds C# entity classes from it using the Scaffold-DbContext command. In practice, greenfield projects almost always use Code-First, while projects integrating with legacy systems often begin with Database-First and then switch to Code-First migrations going forward. Performance-critical applications sometimes need more control than an ORM provides. EF Core supports raw SQL queries via FromSqlRaw() for reading and ExecuteSqlRaw() for commands, allowing hand-optimized SQL while still mapping results to C# objects. Dapper — a lightweight micro-ORM by the Stack Overflow team — is a popular complement to EF Core for performance-critical hot paths where the overhead of the full ORM is undesirable. A common architecture uses EF Core for CRUD operations and complex domain logic while using Dapper for high-volume read queries in reporting and search features.
Skills & Outcomes in This Module
- Deep conceptual understanding with the 'why' behind each feature
- Practical code patterns used in real enterprise codebases
- Common pitfalls, debugging strategies, and professional best practices
- Integration with adjacent technologies and architectural patterns
- Interview preparation: key questions on this topic with detailed answers
- Industry context: where and how these skills are applied professionally
Application Startup
// Program.cs (Minimal Hosting Model)
var builder = WebApplication.CreateBuilder(args);
// Add services to the container
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
var app = builder.Build();
// Configure the HTTP request pipeline
if (app.Environment.IsDevelopment())
{
app.UseSwagger();
app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();Request Pipeline
The ASP.NET Core request pipeline is a series of middleware components that process HTTP requests and responses. Each middleware can perform operations before and after the next middleware in the pipeline.