ASP.NET Core is the part of .NET you use to build a web application or an HTTP API. It is a request pipeline, a dependency injection container and a hosting model, and almost everything else is a library you plug into those three.

The sections below run roughly in the order the problems arrive: getting a response out of a controller, binding what came in, documenting it, calling somebody else’s API, then the pipeline, caching, configuration and how the thing runs in production.

A note on the two hosting styles. Controllers and minimal APIs are not competing religions. Controllers give you a class per resource and a lot of convention; minimal APIs give you a delegate and almost none. Both are in here, usually in the same section, because the underlying question is normally the same one.

If you are starting from nothing, the Web API tutorial series at the top builds a complete application over several parts. Everything after it answers one question at a time.

The Web API Tutorial Series

One application, built up part by part, so the shape of a Web API arrives before the details do.

Web API Design and Best Practices

What a good API looks like before any of it is code. Worth twenty minutes at the start of a project and nearly useless at the end.

MVC, Razor and Views

Server-rendered pages: views, layouts, tag helpers and the bits of MVC that have no equivalent in a Web API.

Swagger and API Documentation

Swagger is the first thing most teams turn on and the first thing that starts showing more than it should.

Real-Time: SignalR, WebSockets and Server-Sent Events

Three ways to push rather than wait to be asked, and the reasons to pick one over another.

Consuming APIs With HttpClient

Calling somebody else’s API is where most of the sharp edges are: lifetimes, timeouts, headers, cancellation and the socket exhaustion that follows from getting the first one wrong.

Returning Data From a Web API

What actually goes back down the wire, and how to say “this went wrong” in a way the caller can act on.

File Uploads and Transfer

Accepting a file is easy. Accepting it safely, at size, and rejecting the ones you should is the part these cover.

Model Binding, Validation and Request Data

Everything between the request arriving and your method running.

Routing, Controllers and Minimal APIs

How a URL finds your code, in both hosting styles.

JSON and Serialization

The serializer settings that bite once and then never again, usually after an afternoon.

Middleware, Filters and the Pipeline

The pipeline is the part of ASP.NET Core that rewards being understood properly, because almost every cross-cutting concern belongs in it.

Caching, Rate Limiting and Performance

Doing less work, and refusing work you do not want.

Paging, Filtering, Searching and Sorting

The four things every list endpoint grows, in roughly this order and about one release apart.

Generating Files and Documents

Producing something the caller downloads rather than reads.

Configuration, Options and Environments

Where settings come from, how to validate them, and how to keep the ones that matter out of source control.

Dependency Injection

The container is built in, so the questions are about lifetime and registration rather than about which library to pick.

Background Work and Hosting

Work that outlives a request, and the ways an ASP.NET Core process actually gets hosted.

Architecture

Shapes for a whole application. These are the hardest to change later, so the articles spend time on when not to.

More ASP.NET Core

The rest, filed where it did not fit anywhere above.

Where to Go Next

The two things an ASP.NET Core application almost always needs next:

When something behaves oddly, work out where in the request it happens before you go looking for the feature that owns it. A surprising number of ASP.NET Core problems turn out to be about pipeline order.