ASP.NET Core Fundamentals
ASP.NET Core is Microsoft's cross-platform framework for building web applications and APIs on .NET. It provides a modular HTTP pipeline, dependency injection, routing, and tooling for creating server-side applications that run on Windows, Linux, or macOS.
itWeb development | OpenSkills.info
Intro
ASP.NET Core Fundamentals
ASP.NET Core is the web framework in .NET. You use it to build HTTP APIs, server-rendered web applications, real-time services, and backends for other clients.
The framework gives you a web server, a request pipeline, routing, dependency injection, configuration, logging, security integration, and several endpoint models. You choose which parts your application needs.
ASP.NET Core is open source and cross-platform. It runs on Windows, Linux, and macOS. It works well when your team uses C# and .NET, needs one framework for APIs and web interfaces, or wants explicit control over the HTTP pipeline.
It may be a poor fit when your team has no .NET expertise, a static site is enough, or another platform already owns the application's operational model. ASP.NET Core supplies web infrastructure. It does not choose your domain model, database design, deployment topology, or security policy.
Start with the host
Every ASP.NET Core application starts by building a host. The host owns the resources needed to run the application:
- The HTTP server accepts connections.
- The middleware pipeline processes requests and responses.
- The service container creates registered dependencies.
- Configuration provides settings.
- Logging providers receive log events.
- Application lifetime signals coordinate startup and shutdown.
Current application templates use WebApplicationBuilder and WebApplication for this setup.
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddProblemDetails();
var app = builder.Build();
app.UseExceptionHandler();
app.MapGet("/", () => "Hello from ASP.NET Core");
app.Run();
Read this file in two phases. Calls on builder.Services register capabilities before the host is built. Calls on app assemble the request pipeline and map endpoints after the build.
Kestrel is the default cross-platform web server. It can serve Internet traffic directly. Many production deployments place it behind IIS, Nginx, Apache, a load balancer, or an ingress controller. The proxy and application must agree about the original client address, scheme, host, and request limits.
Follow one request through the pipeline
Continue the course
This section is part of the paid course.
See pricing to subscribe, or log in if you already have access.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://dotnet.microsoft.com/en-us/apps/aspnet
Supports
- ASP.NET as the .NET web platform
- Official product-level application types and learning entry points
- https://learn.microsoft.com/en-us/aspnet/core/overview?view=aspnetcore-10.0
Supports
- ASP.NET Core as an open-source cross-platform .NET web framework
- Kestrel, integrated dependency injection, configuration, logging, tracing, and metrics
- Web apps, APIs, real-time apps, and supported deployment contexts
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/?view=aspnetcore-10.0
Supports
- Host ownership of server, middleware, logging, dependency injection, and configuration
- Kestrel and reverse-proxy deployment
- Default configuration sources, environments, logging, routing, errors, and static files
- WebApplication and WebApplicationBuilder as the modern hosting model
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/middleware/?view=aspnetcore-10.0
Supports
- Middleware request and response behavior
- Calling the next component and short-circuiting
- Run, Map, Use, branching, and ordering guidance
- Exception handling, routing, authentication, and authorization order
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/routing?view=aspnetcore-10.0
Supports
- Routes as patterns mapped to handlers
- Endpoint selection and endpoint metadata
- Parameters, constraints, catch-all patterns, names, groups, and link generation
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/apis?view=aspnetcore-10.0
Supports
- Minimal APIs and controller-based APIs as the two HTTP API approaches
- Minimal APIs as Microsoft's recommendation for new HTTP API projects
- Controllers as a class-based alternative
- https://learn.microsoft.com/en-us/aspnet/core/tutorials/min-web-api?view=aspnetcore-10.0
Supports
- Minimal API project structure and route mapping
- Minimal APIs as a low-dependency fit for HTTP APIs and microservices
- Official executable beginner progression used in the links path
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis/responses?view=aspnetcore-10.0
Supports
- Minimal API return-value and result choices
- Status codes and response body behavior
- https://learn.microsoft.com/en-us/aspnet/core/mvc/overview?view=aspnetcore-10.0
Supports
- MVC separation among models, views, and controllers
- Controllers, actions, views, and related MVC conventions
- https://learn.microsoft.com/en-us/aspnet/core/razor-pages/?view=aspnetcore-10.0
Supports
- Razor Pages as a page-focused server-rendered application model
- Shared MVC primitives such as model binding, validation, and action results
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-10.0
Supports
- Built-in service container, registration, injection, object graphs, and disposal
- Transient, scoped, and singleton registration
- Middleware injection and risks of resolving scoped services from longer-lived objects
- https://learn.microsoft.com/en-us/dotnet/core/extensions/dependency-injection/service-lifetimes
Supports
- Transient instances per resolution
- Scoped instances per web request
- Singleton instances for the application lifetime and thread-safety requirements
- Scoped service ownership and lifetime mismatch guidance
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?view=aspnetcore-10.0
Supports
- Ordered configuration providers and override behavior
- JSON, environment variable, command-line, and development secret sources
- Configuration key structure and deployment override behavior
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration/options?view=aspnetcore-10.0
Supports
- Typed options binding and separation of configuration concerns
- Options validation and startup validation
- IOptions, IOptionsSnapshot, and IOptionsMonitor behavior
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/environments?view=aspnetcore-10.0
Supports
- Development, Staging, and Production environment behavior
- Environment selection at application startup
- Environment-specific diagnostics and configuration
- https://learn.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-10.0
Supports
- ILogger categories, levels, providers, filters, message templates, and scopes
- Structured log arguments and exception logging
- Security guidance for sensitive log data
- https://learn.microsoft.com/en-us/aspnet/core/mvc/models/model-binding?view=aspnetcore-10.0
Supports
- Binding request data to action, handler, and model values
- Binding sources and conversion failures
- Model state as the record of binding and validation errors
- https://learn.microsoft.com/en-us/aspnet/core/mvc/models/validation?view=aspnetcore-10.0
Supports
- Validation after model binding
- ModelState handling in MVC and Razor Pages
- Automatic HTTP 400 behavior for API controllers with ApiController
- Distinction between conversion errors and validation rules
- https://learn.microsoft.com/en-us/aspnet/core/security/authentication/?view=aspnetcore-10.0
Supports
- Authentication as identity determination
- Authentication services, handlers, schemes, challenge, and forbid behavior
- https://learn.microsoft.com/en-us/aspnet/core/security/authorization/introduction?view=aspnetcore-10.0
Supports
- Authorization as a separate access decision after authentication
- Role-based and policy-based authorization
- Requirements, handlers, claims, and resource-aware checks
- https://learn.microsoft.com/en-us/aspnet/core/test/integration-tests?view=aspnetcore-10.0
Supports
- WebApplicationFactory and TestServer for hosted integration tests
- Controlled test configuration and service replacement
- HTTP testing through the application framework boundary
- https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/?view=aspnetcore-10.0
Supports
- Published output and supported hosting paths
- Reverse proxies, process management, containers, web farms, and health checks
- Deployment concerns beyond application compilation
- https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/proxy-load-balancer?view=aspnetcore-10.0
Supports
- Forwarded client address, scheme, and host headers
- Known proxy and network trust configuration
- HTTPS redirection failures behind incorrectly configured proxies
- https://learn.microsoft.com/en-us/aspnet/core/host-and-deploy/health-checks?view=aspnetcore-10.0
Supports
- Health Check Middleware and mapped health endpoints
- External monitoring, load balancer, and orchestrator use
- Dependency checks and health status responses
