ASP.NET Core (Blazor)

Getting Started with ASP.NET Core — what ASP.NET Core is, the .NET 10 LTS release cadence, the SDK and dotnet CLI, the project layout, the minimal hosting model, and how to choose an app model.

Request Pipeline and Middleware — the pipeline as an ordered chain of RequestDelegate`s, `Use / Run / Map, the recommended order, the built-in middleware, writing custom middleware, and HttpContext.

Hosting, Servers, and Environments — WebApplication vs. the Generic Host, background services, Kestrel / IIS / HTTP.sys, reverse proxies and forwarded headers, and environment-based configuration.

Configuration and the Options Pattern — configuration providers and precedence, reading IConfiguration, binding to typed options, IOptions vs. IOptionsSnapshot vs. IOptionsMonitor, named options, and options validation.

Dependency Injection — the built-in container, service lifetimes and the captive-dependency pitfall, registration techniques including keyed services, consuming services across the framework, and replacing the container.

Routing — the match/execute model, route templates and constraints, the Map methods and route groups, attribute vs. conventional routing, URL generation, and short-circuit routes.

Filters and the MVC Pipeline — the MVC/Razor Pages filter pipeline (authorization, resource, action, exception, result, and page filters), order and scope, short-circuiting, DI in filters, and filters vs. middleware vs. endpoint filters.

Static Files and Asset Delivery — UseStaticFiles vs. MapStaticAssets, static web assets, fingerprinting and compression, ImportMap, wwwroot conventions, and CDN/cache-control strategy.

HTTP Client and Resilience — IHttpClientFactory, named and typed clients, message handler chains, the resilience/Polly standard handler, timeouts, retries, circuit breakers, HttpClient pitfalls, and Refit/Kiota-generated clients.

Minimal APIs — Map methods and route groups, parameter binding, IResult and TypedResults, endpoint filters, validation, error handling, and a full worked CRUD example.

MVC Controllers and Views — controllers and action results, conventional vs. attribute routing, ViewData/ViewBag/TempData, areas, and view discovery.

Razor Syntax and Tag Helpers — Razor syntax, _ViewImports/_ViewStart, layouts, sections, partial views, view components, built-in and custom Tag Helpers, and HTML encoding.

Razor Pages — PageModel, handler selection and naming, @page route templates, [BindProperty], page conventions, filters, and when to prefer it over MVC.

Model Binding and Validation — binding sources and order, binding attributes, custom model binders, DataAnnotations and custom validation, and client-side validation.

Web API Controllers — ApiController conventions, action return types, content negotiation and System.Text.Json options, ProblemDetails, DTOs, CORS, and the minimal-API-vs-controller trade-off.

OpenAPI and API Versioning — the built-in Microsoft.AspNetCore.OpenApi package, OpenAPI 3.1 and JSON Schema 2020-12 defaults, YAML output, XML-doc integration, document/operation/schema transformers, Scalar/Swagger UI, client generation, and Asp.Versioning.*.

Blazor Overview and Render Modes — what Blazor is, the Blazor Web App project layout, Static/streaming SSR, Interactive Server/WebAssembly/Auto, per-component interactivity, standalone Blazor WebAssembly, prerendering, and choosing a mode.

Blazor Components and Lifecycle — .razor components, parameters and cascading values, RenderFragment, the full lifecycle, StateHasChanged, @key, built-in components, and CSS isolation.

Blazor Data Binding, Forms, and Validation — @bind and its modifiers, EventCallback, EditForm/EditContext, the Input* components, DataAnnotationsValidator, [ValidatableType], and SSR form handling.

Blazor Routing and Navigation — @page route templates, the Router, NavigationManager, [SupplyParameterFromQuery], NavLink, navigation locks, NotFoundPage, enhanced navigation, and layouts.

Blazor State Management — state per render mode, PersistentComponentState and [PersistentState], circuit state persistence across reconnects, DI-scoped state containers, browser storage, state in the URL, and state-management libraries.

Blazor JavaScript Interop — IJSRuntime, JS modules and collocated JS, JS-to-.NET calls with [JSInvokable], InvokeConstructorAsync/GetValue/SetValue, synchronous WebAssembly interop, and ElementReference.

Blazor Security — AuthenticationStateProvider, AuthorizeView/[Authorize], why WebAssembly auth is never a trust boundary, ASP.NET Core Identity, OIDC, token handling, passkeys, and reconnection UI.

Blazor WebAssembly, Hybrid, and Deployment — the WebAssembly runtime, trimming/AOT/SIMD, lazy loading, fingerprinted assets, PWAs, hosting standalone vs. hosted WASM, Blazor Hybrid with .NET MAUI, and Razor class libraries.

Blazor Testing and Diagnostics — bUnit, Playwright end-to-end testing, debugging Server vs. WebAssembly, Hot Reload, metrics/tracing diagnostics, and common production issues.

SignalR — hubs, strongly typed hubs, clients and transports, groups and users, streaming, authentication, and scale-out with Redis/Azure SignalR.

gRPC — contract-first .proto definitions, the four call types, interceptors, gRPC-Web, JSON transcoding, deadlines/cancellation, the client factory, and gRPC vs. REST.

Data Access with EF Core — registering a DbContext, querying and change tracking, saving and concurrency, modelling with the Fluent API, migrations, resiliency, and Dapper as an alternative.

Authentication and ASP.NET Core Identity — authentication schemes and handlers, cookie and JWT bearer authentication, OAuth 2.0 / OpenID Connect, ASP.NET Core Identity for local accounts, and the Identity API endpoints.

Authorization — the Authorize attribute, role and claims checks, policy-based authorization with requirements and handlers, resource-based authorization, and advanced policy features.

Security Hardening — the Data Protection API, HTTPS and HSTS, secret management, CORS, antiforgery / CSRF, XSS and Content Security Policy, open-redirect and SQL-injection avoidance, and an OWASP Top 10 map.

Error Handling, Logging, and Observability — UseExceptionHandler and IExceptionHandler, the Operation Result pattern, structured logging with ILogger, HTTP logging, health checks, and metrics and tracing with OpenTelemetry.

Performance and Caching — response vs. output caching, IMemoryCache / IDistributedCache / HybridCache, rate limiting, request timeouts and compression, outbound-call resilience, and an EF Core and runtime checklist.

Architecture and Patterns — SOLID and design principles, layering and Clean Architecture, DTO mapping, cross-cutting patterns in DI, CQRS and the mediator pattern, and vertical slices vs. modular monoliths.

Testing — the xUnit test project and test doubles, unit-testing controllers, handlers, middleware and validators, integration testing with WebApplicationFactory, test infrastructure, and end-to-end and load testing.

Deployment — dotnet publish options, IIS, Linux with Nginx and systemd, containers, running behind a proxy or load balancer, production config and secrets, and a CI/CD pipeline.

.NET Aspire and Cloud-Native Development — the AppHost and ServiceDefaults projects, resources and references, service discovery, the dashboard, integrations, local orchestration vs. deployment, and how Aspire relates to Docker Compose/Kubernetes.

UI Component Libraries — styling an ASP.NET Core UI (Bootstrap, Tailwind, Sass, Blazor CSS isolation) and the main Blazor component libraries, free and open-source first (MudBlazor, Radzen, Blazorise, Fluent UI, Ant Design, HAVIT, Blazor Bootstrap, MatBlazor), commercial suites last, plus accessibility.

Globalization and Localization — IStringLocalizer/IViewLocalizer, .resx conventions, RequestLocalizationMiddleware and culture providers, route/query/cookie culture selection, data annotations localization, and Blazor localization.