ASP.NET Core is where .NET meets the web. It is a full web framework: it listens for HTTP requests, runs them through a configurable pipeline, routes them to code you wrote, and turns the result into responses — HTML pages for browsers, JSON for clients, files, or streams. Everything else in this guide, including MVC, is built on this foundation.
What ASP.NET Core is
ASP.NET Core is the web framework that ships as part of modern .NET. It is open source, cross-platform, and designed for containers and cloud hosting. Unlike the older ASP.NET, it is not a component installed into Windows; a web application is a normal .NET application that happens to listen for HTTP. The built-in web server, Kestrel, is fast enough to face the internet directly, and when the application runs behind IIS, Nginx, or a cloud load balancer, ASP.NET Core integrates with them through well-defined hosting features such as forwarded headers.
The framework also includes, out of the box, the things every web application needs and older platforms left to third-party libraries or the machine:
- Dependency injection. Services are registered once and injected where needed, with explicit lifetimes.
- Configuration. JSON files, environment variables, user secrets, and command-line arguments combine into one typed configuration tree.
- Logging. A logging abstraction with structured providers, plus health checks and metrics hooks.
- Middleware. An explicit, ordered request pipeline you compose in code instead of configuring in XML.
- Routing and endpoint metadata. Every handler — MVC action, Razor Page, or Minimal API endpoint — is an endpoint with filters, authorization, and rate-limiting policies attached.
The four application styles
ASP.NET Core deliberately supports more than one way to build a web application. They share the same host and pipeline, and they can coexist inside one project:
- MVC — controllers and Razor views. The Model-View-Controller pattern with routes such as
/Todo/Edit/{id}, built for server-rendered applications with many screens. This is the focus of the rest of this guide. - Razor Pages — one page file paired with a page model, convenient for page-centric scenarios such as forms and content pages.
- Minimal APIs — small, focused HTTP endpoints defined in a few lines, ideal for JSON operations and internal services.
- Blazor — interactive user interfaces written in C# that run either on the server or in the browser via WebAssembly.
The styles are not competing products. A single business application can render screens with MVC, expose data operations with Minimal APIs, and add an internal dashboard with Razor Pages — one project, one deployment, one dependency container.
How a minimal ASP.NET Core application is shaped
Modern .NET replaced the old global application configuration with a single Program.cs. This small program registers services, composes the pipeline, and maps endpoints:
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.UseStaticFiles();
app.UseRouting();
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
app.MapGet("/api/health", () => Results.Ok(new { status = "ok" }));
app.Run();Everything is explicit: which services exist, in which order middleware runs, and which endpoints are reachable. There is no hidden HTTP module list and no web.config ceremony. That explicitness is why a request path can be traced by reading a single file — a property that pays off again when features are added later.
ASP.NET Core vs the older ASP.NET
If you have seen both names, here is the short comparison:
- Platform: ASP.NET Core runs on modern .NET across Windows, Linux, and macOS. ASP.NET (without Core) runs only on .NET Framework and Windows.
- Source: ASP.NET Core is open source; classic ASP.NET is not.
- Configuration: ASP.NET Core uses code and environment-based configuration; classic ASP.NET relies heavily on
web.config. - Composition: ASP.NET Core unifies MVC and Web API in one framework; in classic ASP.NET they were separate products.
- Performance: ASP.NET Core is a different performance class, which matters as request volume and cloud costs grow.
- Deployment: ASP.NET Core supports framework-dependent, self-contained, single-file, and container deployments; multiple runtime versions can coexist on one machine.
What you can build with ASP.NET Core
The framework scales from a five-line JSON endpoint to a large business application:
- Server-rendered business software — CRM, inventory, HR, projects — with MVC pages and Razor views.
- REST APIs for mobile apps, partners, and internal services, with OpenAPI documentation.
- Real-time features such as dashboards and notifications with SignalR.
- Service communication with gRPC when binary contracts and streaming matter.
- Background processing with hosted services or a scheduler such as Hangfire.
For the official tour, see Microsoft Learn: ASP.NET Core overview. To go deeper on the pattern this guide is built around, see Microsoft Learn: ASP.NET Core MVC overview.
Why this guide focuses on MVC
ASP.NET Core can do many things, but most business applications are still collections of screens: a list, a form, a detail page, a report. MVC is the ASP.NET Core style designed for exactly that, and it remains the most documented, most hireable knowledge in the .NET web ecosystem. The next part explains the pattern itself: What Is MVC? Model-View-Controller Explained.
Key Takeaways
- ASP.NET Core is the open-source, cross-platform web framework of modern .NET, hosted by Kestrel and composed in
Program.cs. - Four application styles — MVC, Razor Pages, Minimal APIs, Blazor — share one pipeline and can coexist in one project.
- Dependency injection, configuration, logging, routing, and health checks are built in, not bolted on.
- MVC remains the standard choice for server-rendered business applications.
FAQ
Is ASP.NET Core the same as ASP.NET?
No. ASP.NET Core is a cross-platform rewrite that runs on modern .NET; ASP.NET (without Core) is the older framework that runs only on .NET Framework and Windows.
Is MVC required to build an ASP.NET Core application?
No. You can build with Razor Pages, Minimal APIs, Blazor, or a mix. MVC is one supported style — the one best suited to large server-rendered applications.
Do I need IIS to host ASP.NET Core?
No. The built-in Kestrel server can host the application directly, on any supported operating system, and it can sit behind IIS, Nginx, or a cloud load balancer when required.
Can MVC and Minimal APIs share the same project?
Yes, and that combination is the architectural theme of the later parts of this guide: MVC for page routing and Minimal APIs for focused data operations, both backed by the same handlers.
