Pro ASP.NET Core by Adam Freeman: Review and Study Guide

What this book is

Pro ASP.NET Core by Adam Freeman is one of the most popular books for learning how to build web apps with ASP.NET Core. It is big. It is thorough. And it is built around one idea: you learn by building a real app, page by page, from the first chapter to the last.

The newest version is the tenth edition, Pro ASP.NET Core 7. Don't let the version number scare you. The core ideas it teaches barely change from one .NET release to the next. The patterns you learn here still work great on .NET 10, which is the current Long-Term Support (LTS) release shipped in November 2025 with C# 14.

A quick analogy

Think about learning to cook from a recipe book.

One kind of book just lists facts: "salt makes food taste salty." Useful, but boring, and you forget it fast.

The other kind says: "Tonight we cook a real dinner together. First chop the onion. Now I'll explain why onions go in first." By the end you have a full meal on the table, and the lessons stuck because you did them.

Pro ASP.NET Core is the second kind. You cook a whole "meal" (a working sports-store web app called SportsStore), and Adam Freeman explains each ingredient as you add it. That hands-on, build-along style is the heart of the book.

What it covers

The book walks through the whole ASP.NET Core toolbox. Here are the big topics.

Let's look at the most important ideas with tiny code examples.

Middleware: the request pipeline

Every web request travels through a line of steps. Each step can look at the request, change it, or stop it. We call this the pipeline, and each step is a piece of middleware.

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
 
// Each "Use..." adds one step to the line.
app.UseHttpsRedirection();   // step 1: force https
app.UseStaticFiles();        // step 2: serve images, css
app.UseRouting();            // step 3: pick the right endpoint
app.MapGet("/", () => "Hello!"); // the final handler
 
app.Run();

Here is the same idea as a picture.

The order matters a lot. If you put a step too early or too late, things break in confusing ways. The book spends real time on this, because getting the pipeline right is half of ASP.NET Core.

Dependency Injection: don't build your own tools

Imagine a chef who has to mine the metal and forge a knife before chopping a carrot. Silly, right? A good kitchen just hands the chef a knife.

Dependency Injection works the same way. Your code says "I need a greeting service," and the framework hands one over. You never write new yourself.

// 1. Register the tool once, at startup.
builder.Services.AddScoped<IGreetingService, GreetingService>();
 
// 2. Ask for it in a constructor. The framework fills it in.
public class HomeController : Controller
{
    private readonly IGreetingService _greeting;
 
    public HomeController(IGreetingService greeting)
    {
        _greeting = greeting; // handed to you, ready to use
    }
}

This keeps code loose and easy to test. You can swap the real tool for a fake one in tests without touching the controller.

A quick note for 2026: some popular helper libraries changed their license. MediatR, MassTransit, and AutoMapper are now commercially licensed for many uses. The book teaches the built-in DI container, which is free and ships with .NET, so you are not forced into any paid tool to follow along.

MVC: Model, View, Controller

MVC splits a screen into three jobs. It keeps big apps tidy.

public class ProductController : Controller
{
    private readonly IProductRepository _repo;
    public ProductController(IProductRepository repo) => _repo = repo;
 
    // Controller gets data (the Model) and picks a View.
    public IActionResult Index()
    {
        var products = _repo.GetAll(); // the Model
        return View(products);         // the View
    }
}

The Controller decides what happens. The Model is the data. The View turns data into HTML. Each part has one job, so you always know where to look.

Razor Pages: simpler screens

MVC is great for big apps, but sometimes it feels like a lot of files for one form. Razor Pages is the lighter option. Each page is a .cshtml file plus a small code file next to it.

public class ContactModel : PageModel
{
    [BindProperty]
    public string Name { get; set; } = "";
 
    public void OnGet() { }          // runs when page loads
    public IActionResult OnPost()    // runs when form is sent
    {
        // save the contact, then redirect
        return RedirectToPage("Thanks");
    }
}

The book shows both MVC and Razor Pages and, just as usefully, when to pick which. Short version: Razor Pages for page-focused screens, MVC for larger apps with lots of shared logic.

Web APIs: returning data, not HTML

Not every endpoint returns a web page. Phone apps and other sites want raw data, usually as JSON. That is what a Web API does.

[ApiController]
[Route("api/products")]
public class ProductsApi : ControllerBase
{
    private readonly IProductRepository _repo;
    public ProductsApi(IProductRepository repo) => _repo = repo;
 
    [HttpGet("{id}")]   // route with an id, like api/products/5
    public IActionResult GetById(int id)
    {
        var product = _repo.Find(id);
        return product is null ? NotFound() : Ok(product);
    }
}

Note the route api/products/{id} uses a placeholder in the attribute. The book covers status codes, model binding, validation, and how to keep APIs clean and predictable.

Entity Framework Core: talking to the database

Writing raw SQL by hand is slow and easy to get wrong. Entity Framework Core lets you work with C# objects, and it talks to the database for you. You describe your data as classes, and EF Core handles the rest.

public class StoreDbContext : DbContext
{
    public StoreDbContext(DbContextOptions<StoreDbContext> opts)
        : base(opts) { }
 
    // One DbSet per table. This is your "Products" table.
    public DbSet<Product> Products => Set<Product>();
}
 
// Reading data feels like normal C#.
var cheapItems = dbContext.Products
    .Where(p => p.Price < 20)
    .OrderBy(p => p.Name)
    .ToList();

The book shows how to set up the database connection, run migrations (which keep the database shape in sync with your classes), and load related data without slow queries. It is one of the most useful chapters, because almost every real app needs a database.

Who this book is for

This book is best if you already know a little C#. You do not need to be an expert, but if you have never seen a variable or a loop, learn those first. After that, this book is a strong path from "I can write C#" to "I can build and ship a real web app."

A study plan

The book is huge (well over a thousand pages). Don't try to read it like a novel. Use a plan.

• Week 1. Set up your tools (the .NET SDK and an editor like VS Code or Visual Studio). Start the SportsStore app. Just get it running.
• Week 2. Slow down on middleware, DI, and configuration. These are the foundations. If they feel fuzzy, re-read.
• Week 3. Build pages with MVC and Razor Pages. Make forms work. Show data on screen.
• Week 4. Add a Web API, connect a database with EF Core, and add logins with Identity.
• After the book. Build a tiny app of your own with no help. A to-do list or a notes app is perfect. This is where it all clicks.

How to get the most from the build-along style

The book only works if you actually build along. Here is how to do it well.

1. Type the code by hand. Do not copy-paste. Typing forces you to read every line.
2. Run it after each section. See the result with your own eyes.
3. Break it on purpose. Change a route, delete a line, watch the error. Errors are great teachers.
4. Keep a notebook. Write one sentence per chapter: "Middleware is a line of steps." Your own words stick best.
5. Use a fresh project to experiment. When an idea is unclear, spin up a tiny app just for that idea.

In .NET 10 you can even test a quick idea in a single file. C# 14 supports file-based apps, so one .cs file runs with dotnet run, no project file needed.

// hello.cs  ->  run with:  dotnet run hello.cs
Console.WriteLine("Trying an idea fast!");

Pros and cons

No book is perfect. Here is the honest picture.

Alternatives

If this book is not the right match, here are other good paths.

• Microsoft Learn (free). Official, up to date, and matches the newest .NET. Great for quick, focused lessons.
• The official ASP.NET Core docs. The most current source of truth. Pair them with any book.
• Shorter video courses. Good if you learn better by watching first, then reading.
• "C# in a Nutshell" by Joseph Albahari. A language reference, not a web book, but a perfect companion for the C# parts.

A smart combo: read Pro ASP.NET Core for the mental model, then keep Microsoft Learn open for the newest .NET 10 details.

Quick recap

• Pro ASP.NET Core by Adam Freeman teaches web apps by building a real app with you.
• It covers middleware, dependency injection, MVC, Razor Pages, Web APIs, EF Core, and Identity.
• It suits people who already know a little C# and want to build real web apps.
• The newest edition targets ASP.NET Core 7, but the ideas still apply on .NET 10 (LTS) and C# 14.
• Get the most from it by typing code by hand, running it often, and breaking it on purpose.
• Pair it with Microsoft Learn and the official docs to stay current.

References and further reading

• Pro ASP.NET Core 7, Tenth Edition (Manning)
• Pro ASP.NET Core (Apress)
• What's new in .NET 10 (Microsoft Learn)
• Announcing .NET 10 (.NET Blog)
• What's New for C# 14 and F# 10 (Visual Studio Magazine)