liveBookmanning.com

What you will learn in ASP.NET Core in Action, 3e

by Andrew Lock

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• middlewareMiddleware is a request-processing component that can inspect, modify, or handle HTTP requests and responses within an ASP.NET Core pipeline.
• model bindingA model binder is the framework component that locates request values, converts them to appropriate types, and assigns them to bound objects or parameters.
• controllerA web API controller is an ASP.NET Core controller that handles HTTP API requests through action methods and produces machine-readable responses.
• handlerA handler is an application component that receives a framework-dispatched request or event and performs the corresponding processing.
• Razor PagesA Razor Page is an independently addressable ASP.NET Core page endpoint typically composed of a .cshtml view file and an associated PageModel class.
• Razor syntaxA Razor view is a server-rendered template that combines markup with embedded C# expressions and accesses data supplied by an application component.
• servlet filterIActionFilter is an ASP.NET Core interface for synchronous MVC filters that run before and after action-method execution.
• authorizationAuthorization is the process of determining whether an authenticated subject has permission to perform an operation or access a resource.
• endpoint middlewareEndpoint middleware is the ASP.NET Core middleware component that executes the endpoint selected for an incoming request.
• dependency injection containerThe built-in dependency injection container is the default service container provided by ASP.NET Core for registering and resolving application services.
• claimA claim is a statement about an authenticated subject, represented as a type and value, that can support authorization decisions.
• ASP.NET Core IdentityASP.NET Core Identity is an ASP.NET Core membership system that provides user accounts, authentication, authorization integration, and related identity-management services.
• policyAn authorization policy is a named set of requirements that determines whether an authenticated subject may access a protected resource or operation.
• ASP.NET CoreASP.NET Core is Microsoft's cross-platform, open-source web framework for building web applications and services on .NET.
• PageModelA PageModel code-behind file is the C# source file containing the handler methods and state for a Razor Page.
• web API action methodAn API controller action is a method on a web API controller that handles a request and produces an HTTP result.
• Tag HelpersTag Helpers are ASP.NET Core components that add server-side processing behavior to HTML-like elements in Razor files.
• routingRouting is the mechanism that maps incoming requests to application endpoints or handlers.
• route templateA route template is a URL pattern containing fixed values and optional placeholders that determines which request URLs an endpoint matches.
• dependency injectionDependency injection is a design pattern in which an object receives its dependencies from an external provider rather than creating them itself.
• identity providerA third-party identity service is an externally operated identity provider that supplies authentication and identity-management capabilities to applications.
• validationValidation is the application framework process that checks model data against rules to determine whether it is acceptable.
• razor pages filter pipelineAn MVC filter pipeline is the ordered sequence of filters that surrounds and participates in request processing within the ASP.NET Core MVC and Razor Pages frameworks.
• minimal APIA minimal API endpoint is an addressable operation in a minimal API application that handles a request with minimal surrounding framework structure.
• ILoggerProviderILoggerProvider is a logging abstraction that creates logger instances configured to write messages to a particular destination or system.
• endpointAn endpoint is an addressable application operation associated with a URL pattern that receives a dispatched request and returns a response.
• scopeA scope is a named permission describing an operation or resource that a client or user has been granted or consented to access.
• Entity Framework CoreEntity Framework Core is a cross-platform .NET object-relational mapper for working with relational and some nonrelational databases through .NET types and queries.
• routing middlewareUseRouting is an ASP.NET Core extension method that adds routing middleware to a web application's request pipeline.
• explicit routingAttribute routing is ASP.NET Core routing in which route templates are declared directly on controller classes and action methods through attributes.
• reverse proxyA reverse proxy is a server that receives client requests and forwards them to backend applications or services on the clients' behalf.
• Model–view–controllerModel-View-Controller is an application architecture pattern that separates domain data, presentation, and request-handling control logic.
• testA test is an automated program method that evaluates whether application behavior matches an expected result.
• configuration providerA configuration provider is a component that reads application configuration values from a particular source and contributes them to the configuration system.
• ApiControllerApiController is an ASP.NET Core attribute that enables conventions for web API controllers, including attribute routing, automatic validation responses, binding-source inference, and Problem Details responses.
• IHostThe generic host is .NET infrastructure for configuring application services, hosting, configuration, logging, and lifetime management independently of a specific application protocol.
• cookieAn authentication cookie is a client-side HTTP cookie containing serialized authentication state used to recognize a signed-in user across requests.
• BindProperty attributeThe BindProperty attribute marks a Razor PageModel property for binding from incoming request data.
• API keyAn API key is a secret credential used to authenticate an application or request to a remote service.
• authorization requirementAn authorization requirement is a condition that must be satisfied for an authorization policy to succeed.
• authorization handlerAuthorizationHandler is an ASP.NET Core base class for implementing logic that evaluates authorization requirements, optionally against a resource.
• application modelAn application model is an architectural component that encapsulates the non-user-interface parts of an application, including domain models, services, and data-access interactions.
• authenticationAuthentication is the process of determining the identity of the subject that made a request.
• .NET CLIThe .NET CLI is a command-line interface for creating, building, running, and managing .NET applications and projects.
• .NET.NET 5+ is the unified generation of the .NET platform comprising .NET 5, .NET 6, and later releases.
• Identity Razor PagesASP.NET Core Identity UI is the built-in Razor Pages library that provides standard user-account and authentication interfaces for ASP.NET Core Identity.
• ModelStateModelState is the ASP.NET Core request-state dictionary that stores bound values and validation errors associated with properties or the model.
• authorize attributeThe ASP.NET Core Authorize attribute marks an endpoint, controller, action, or Razor Page as requiring an authenticated user or satisfying specified authorization requirements.
• migrationA database migration is a versioned change that updates a database schema to match changes in an application's data model.
• JSON Web TokenA JSON Web Token, or JWT, is a compact, signed token format for representing claims between parties.
• binding sourceA binding source is a category of request or application data from which a handler parameter or object property can be populated.
• integration testAn integration test evaluates the interaction of multiple application components or a substantial vertical slice of an application.
• OpenAPI specificationAn OpenAPI document is a structured document that describes an HTTP API's available URLs, operations, parameters, and data types according to the OpenAPI standard.
• Startup classA Startup class is an ASP.NET Core class that defines application service configuration and request-pipeline configuration during startup.
• bean scopeA scoped lifetime reuses one service instance within a dependency-injection scope and creates different instances for different scopes.
• dbcontextDbContext is the Entity Framework Core base class that coordinates database connections, entity tracking, querying, and persistence for a data model.
• ClaimsPrincipalClaimsPrincipal is a .NET security object that represents an authenticated user through a collection of claims and identities.
• pipelineA handler pipeline is an ordered chain of HTTP message handlers that can modify requests and inspect responses around a final transport handler.
• logging levelThe Information log level records normal application flow and contextual events that help explain subsequent behavior.
• openid connectOpenID Connect is an authentication protocol built on OAuth 2.0 that adds conventions, discovery, and user-identity authentication to delegated authorization flows.
• bearer authenticationA bearer token is a credential string that conveys authentication information to a service, typically relying on a signature to detect tampering rather than requiring possession-based proof.
• dataannotations attributeDataAnnotations is the .NET attribute-based framework for declaring metadata and validation rules on types and their members.
• form tag helperThe Form Tag Helper is an ASP.NET Core Tag Helper that generates and configures HTML form elements from Razor attributes and routing data.
• monitoringLogging is the recording of diagnostic or operational messages generated by an application.
• client-side validationClient-side validation is validation performed in client software, typically a browser, before submitted data reaches the server.
• claims-based approachClaims-based authorization is an authorization approach that evaluates claims associated with an authenticated identity to decide whether access is permitted.
• strongly typed optionsAn options object is a strongly typed object whose properties represent a set of related application settings.
• logA structured log is a log record whose message details are represented as named fields, commonly as key-value pairs.
• WebApplicationWebApplication is the ASP.NET Core type that represents a configured web application and exposes its request-processing pipeline and endpoint-registration capabilities.
• content negotiationContent negotiation is the process by which an HTTP client and server select a representation format for a response based on supported media types and request preferences.
• Singleton patternA singleton pattern is a creational design pattern that ensures a service or object has one shared instance for the relevant application lifetime.
• IHttpClientFactoryIHttpClientFactory is the .NET dependency-injection service for creating configured HttpClient instances and managing their underlying handlers.
• background serviceBackgroundService is a .NET abstract base class that provides a standard implementation pattern for long-running hosted background work.
• ConfigurationManagerConfigurationManager is the .NET configuration type that builds and exposes application configuration while implementing IConfigurationBuilder and IConfigurationRoot.
• dotnet publishdotnet publish is a .NET CLI command that prepares an application and its dependencies for deployment to a target environment.
• view modelA view model is an object or data structure containing the information a user-interface view requires to render a response.
• hosting modelA hosting model is the architecture and configuration that determines how an application is started, managed, and exposed by its host environment.
• HttpContextHttpContext is the ASP.NET Core object that represents the information and state associated with a single HTTP request and its response.
• KestrelKestrel is the cross-platform web server included with ASP.NET Core for receiving and sending HTTP traffic.
• cross-site request forgeryCross-site request forgery (CSRF) is an attack in which a victim's authenticated browser is induced to submit an unintended request to a trusted application.
• generated clientClient code generation is the automatic production of source code for calling an API from an API description.
• Internet Information ServicesInternet Information Services is Microsoft's extensible web server platform for hosting web applications and services on Windows.
• result resourceActionResult<T> is an ASP.NET Core MVC result type that allows an action method to return either a typed value or an arbitrary HTTP action result.
• service lifetimeA service lifetime is the dependency-injection rule that determines how long a registered service instance is retained and when it is disposed.
• configurationConfiguration is the set of external settings and secrets that control an application's runtime behavior.
• serviceA service is a class that provides a discrete piece of functionality to an application and can be registered with its dependency-injection container.
• IHostedServiceIHostedService is a .NET interface for components that start and stop with an application host and perform managed background work.
• IOptions<T>IOptions<T> is a .NET options abstraction that provides access to a single strongly typed configuration object created on first use.
• projectA project is a .NET unit of deployment containing the source files and configuration needed to build an application or library.
• view componentViewComponent is the ASP.NET Core base class from which custom view component classes can derive.
• service registrationService registration is the configuration that maps a requested service or interface to the implementation the dependency-injection container should provide.
• Quartz.NETQuartz.NET is an open-source .NET job-scheduling library that runs tasks according to configured triggers and supports clustered execution.
• uriA URL is a standardized identifier that specifies the location of a resource and may include a hostname and path.
• IAuthorizationServiceIAuthorizationService is the ASP.NET Core service interface for evaluating whether a user is authorized to perform an operation, optionally in the context of a resource.
• certificateAn HTTPS certificate is a digital certificate used to authenticate a server and enable encrypted HTTPS communication.
• SwashbuckleSwashbuckle is a .NET library that generates OpenAPI documents and provides middleware for serving and visualizing them in ASP.NET Core applications.
• workerA worker service is a headless .NET application whose primary function is to run hosted background tasks rather than serve user-facing web endpoints.
• minimal hostingMinimal hosting is an ASP.NET Core application-hosting style that consolidates bootstrapping in an imperative application entry point with reduced convention and builder ceremony.
• web serviceAn HTTP API application exposes application functionality through endpoints that communicate using the HTTP protocol.
• CORSCross-origin resource sharing is a browser and server mechanism that controls whether a web application may make requests across origins and which parts of those requests and responses are permitted.
• Host.CreateDefaultBuilder()Host.CreateDefaultBuilder() is a .NET factory method that creates an application host builder with default configuration, logging, environment, and dependency-injection settings.
• FormatterA formatter is an ASP.NET Core component that serializes or deserializes HTTP content in a particular representation format.
• result filterIResultFilter is an ASP.NET Core interface for synchronous MVC filters that run before and after result execution.
• WebApplicationBuilderWebApplicationBuilder is the ASP.NET Core builder type that configures application services, logging, and other hosting concerns before constructing a web application.
• HTTP response codeAn HTTP status code is a three-digit code in an HTTP response that indicates the result of processing the corresponding request.
• layoutA Razor layout is a shared Razor template that defines common page structure and renders the content of individual pages within it.
• multifactor authenticationMultifactor authentication is authentication that requires evidence from multiple independent credential or verification factors.
• authorization filterIAuthorizationFilter is an ASP.NET Core MVC interface for synchronous filters that perform authorization checks.
• subtemplateA partial Razor view is a reusable Razor view fragment that can be rendered within another view or layout.
• couplingLoose coupling is a software design property in which components have limited knowledge of and dependence on one another.
• NSwagNSwag is a .NET library and toolset for generating OpenAPI documents and generating clients from API descriptions.
• viewA view is an MVC presentation component that transforms supplied application data into rendered user-interface output such as HTML.
• DbSet<T>DbSet<T> is the Entity Framework Core API representing a set of entities of type T and exposing query and persistence operations.
• RunRun is an ASP.NET Core application method that starts the web server and blocks while it processes requests.
• IActionResultIActionResult is an ASP.NET Core interface representing instructions for producing an HTTP response from request-handling code.
• DeveloperExceptionPageMiddlewareA developer exception page is an ASP.NET Core diagnostic page that displays detailed information about an unhandled exception during development.
• environmentA hosting environment is the runtime context that identifies where an application is running and determines environment-specific configuration and behavior.
• route dataRoute data is a collection of named values supplied to an endpoint route during URL generation.
• HTTP 404 errorThe HTTP 404 status code indicates that the server cannot find the resource or endpoint identified by the request path.
• WebApplicationFactoryWebApplicationFactory is an ASP.NET Core testing API that bootstraps an application for in-memory functional and integration testing and permits test-specific customization.
• entityAn entity is an application object whose structure and identity are mapped by an object-relational mapper to a database record.
• FromBody attributeThe FromBody attribute is an ASP.NET Core parameter-binding attribute that specifies binding a parameter from the deserialized HTTP request body.
• resource filterA resource filter is an ASP.NET Core MVC filter that runs early in request processing, before model binding, and can also run after the result executes.
• ExceptionHandlerMiddlewareError-handling middleware is middleware that intercepts application errors and modifies the HTTP response before it is returned to the client.
• dependency graphA dependency graph is a directed graph representing objects or components and the dependencies required to construct or operate them.
• IdentityUserIdentityUser is the standard ASP.NET Core Identity entity type representing a user account and its core account properties.
• LinkGeneratorLinkGenerator is the ASP.NET Core service that generates URL paths and URLs from route information.
• web applicationA web application is software that provides functionality to users through web technologies and a browser or other web client.
• HTTPSHTTPS is HTTP secured with Transport Layer Security to provide encrypted and authenticated communication.
• user-jwtsdotnet user-jwts create is a .NET CLI command that generates a JWT for local API testing.
• socket exhaustionSocket exhaustion is a condition in which excessive undisposed or unavailable network sockets prevent an application from establishing further connections.
• overlapping route templateAn overlapping route template is a route template whose matching rules also match one or more other route templates for at least one URL.
• validation attributeA custom validation attribute is an application-defined attribute that implements a specialized validation rule, typically by deriving from ValidationAttribute.
• Microsoft.AspNetCore.TestHostMicrosoft.AspNetCore.TestHost is an ASP.NET Core library that provides infrastructure for hosting and testing applications in memory.
• StatusCodePagesMiddlewareStatusCodePagesMiddleware is ASP.NET Core middleware that generates or modifies responses for HTTP status codes, including adding a body to error responses that lack one.
• FluentValidationFluentValidation is a .NET validation library that defines object validation rules with a fluent programming interface.
• LoggerILogger is a .NET logging abstraction whose methods record application diagnostic messages through configured providers.
• validation summaryValidation Tag Helpers are ASP.NET Core Tag Helpers that render model-validation errors in Razor forms.
• input tag helperThe Input Tag Helper is an ASP.NET Core Tag Helper that generates and formats HTML input elements from a bound property and its metadata.
• triggerA Quartz.NET trigger is a scheduling definition that specifies when and under what repetition rules a job executes.
• Microsoft.EntityFrameworkCore.SQLiteMicrosoft.EntityFrameworkCore.SQLite is the NuGet package that supplies SQLite database-provider integration for Entity Framework Core.
• System.Text.JsonSystem.Text.Json is the .NET library for reading and writing JSON data.
• schemaA database schema is the structural definition of a database's tables, columns, keys, relationships, and related objects.
• database providerA database provider model is an abstraction that allows an object-relational mapper to target different database systems through provider-specific implementations.
• password hashingA password hash is a one-way derived value stored instead of the plaintext password for later password verification.
• exception filterAn exception filter is an ASP.NET Core MVC filter that handles exceptions raised during action processing and can provide an action result.
• transient lifetimeA transient lifetime is a dependency-injection lifetime policy that creates a new service instance each time the service is requested.
• UseUse is an ASP.NET Core extension method that adds inline middleware to an application's request-processing pipeline.
• business logicBusiness logic is the application behavior that implements domain rules, decisions, and processes independently of presentation or infrastructure concerns.
• computer clusterClustering is a coordination technique in which multiple application instances distribute work so that a task is executed by only one instance.
• route parameterA route parameter is a named variable embedded in a URL pattern whose value is extracted from a matching request path.
• NuGetA NuGet package is a distributable package containing a .NET library or other reusable assets together with metadata and dependency information.
• endpoint filterAn endpoint filter is an ASP.NET Core component that runs processing around the execution of an associated endpoint and can alter or short-circuit its result.
• FromHeader attributeThe FromHeader attribute is an ASP.NET Core parameter-binding attribute that specifies binding a parameter from an HTTP header value.
• RESTA RESTful API is a web API designed around REST constraints and resource-oriented HTTP interactions.
• log categoryA log category is a string identifier associated with a logger that identifies the component or type creating a log message.
• RequireAuthorizationRequireAuthorization is an ASP.NET Core endpoint-mapping method that attaches an authorization policy requiring an authenticated or otherwise authorized request.
• SaveChangesAsyncSaveChangesAsync is an Entity Framework Core database-context method that asynchronously persists tracked changes to the database.
• 400 bad requestA 400 status code is an HTTP response status indicating that the server could not process the request because of invalid client input.
• HTTP clientHttpClient is the .NET class for sending HTTP requests and receiving HTTP responses.
• IHostBuilderIHostBuilder is a .NET hosting abstraction for configuring an application host before it is built.
• CSRF tokenAn antiforgery token is a value paired between a form or request and a browser cookie to verify that a state-changing request originated from the legitimate application.
• IFormFileIFormFile is an ASP.NET Core interface representing a file uploaded through an HTTP form, including its metadata and content access.
• direct dependencyAn explicit dependency is a dependency declared by a component's public construction or method interface and supplied from outside the component.
• framework-dependent deploymentA framework-dependent deployment publishes an application without bundling the .NET runtime, which must already be installed on the target machine.
• server-side renderingServer-side rendering is the process of generating HTML on the server before sending it to a client.
• typed clientA typed client is an application-specific wrapper around HttpClient that exposes remote-service operations through a strongly typed class.
• RedirectToPageResultRedirectToPageResult is an ASP.NET Core Razor Pages result that instructs the client to navigate to a different page.
• cachingA cache is local storage of previously retrieved data that allows subsequent requests to reuse the stored response without contacting the origin server.
• test automation frameworkA testing framework is a software framework that provides conventions, APIs, and execution support for automated tests.
• source generatorA source generator is a compiler extension that inspects program code during compilation and emits additional source files included in that compilation.
• HTML escapingHTML encoding is the transformation of characters in text into representations that browsers treat as literal content rather than markup or executable code.
• testing SDK.NET Test SDK is the .NET SDK component that provides the test-running infrastructure and integration required by .NET test projects.
• SSL/TLS offloadingSSL/TLS offloading is a deployment pattern in which a proxy or other intermediary terminates encrypted client connections before forwarding requests to an application.
• serverA web server is software or a host system that receives HTTP requests and returns HTTP responses containing web resources.
• contractA web API is an HTTP-accessible application interface that exposes operations or data to clients.
• CRUDA CRUD operation is an operation that creates, reads, updates, or deletes persistent data.
• in-memory databaseAn in-memory database provider is a database-provider implementation that stores test data in process memory instead of persistent database storage.
• dotnet rundotnet run is a .NET CLI command that builds and runs a .NET application from its project directory.
• FromQuery attributeThe FromQuery attribute is an ASP.NET Core parameter-binding attribute that specifies binding a parameter from query-string data and can name the query target.
• User SecretsThe User Secrets manager is an ASP.NET Core development tool and configuration provider for storing sensitive settings outside a project directory.
• cross-origin policyThe same-origin policy is a browser security restriction that limits scripts' access to resources from a different origin unless that access is explicitly permitted.
• HostBuilderHostBuilder is a .NET hosting API type that configures application services, hosting, configuration, and middleware before creating an application host.
• Problem DetailsProblem Details is a standardized structured format for representing HTTP error information in a response body, commonly serialized as JSON.
• log filteringA logging filter is a configuration rule that selects log messages for output according to criteria such as severity and namespace.
• environment variableAn environment variable is an operating-system-provided name-value setting that applications can read at runtime.
• OptionsBuilder<T>OptionsBuilder<T> is a .NET options API type that fluently composes configuration and validation for an options type and can resolve dependencies for configuration actions.
• Windows serviceA Windows Service is an operating-system-managed application process that can run in the background without an interactive user session.
• static-file serverStatic-file middleware is middleware that returns files directly from storage without generating their contents for each request.
• DNS problemA DNS rotation problem occurs when a long-lived client connection fails to recognize that a hostname now resolves to a different service address.
• TryParse methodA TryParse method is a parsing method that converts text to a typed value and reports success through a Boolean return value and an output result.
• ASPNETCORE_URLSASPNETCORE_URLS is an environment variable that specifies the URL or URLs on which an ASP.NET Core application listens.
• ConfigureServicesConfigureServices is an ASP.NET Core Startup method that registers and configures application services in the dependency-injection container.
• wwwroot folderThe wwwroot folder is the conventional ASP.NET Core application directory whose files are publicly served as static content.
• test projectA unit test app is a .NET console application project that contains automated tests and their test dependencies.
• Common Language Runtime.NET Runtime is the execution environment that runs compiled .NET applications without providing the development and build tooling of the SDK.
• static fileA static asset is a web resource such as an image, stylesheet, or script file that is served without being dynamically generated for each request.
• OAuthOAuth 2.0 is an authorization protocol that lets a resource owner delegate controlled access to protected resources without revealing credentials to the accessing service.
• cross-site scripting attackCross-site scripting is a web security vulnerability in which attacker-controlled content is injected into pages and executed in a victim's browser.
• route conventionA Razor Pages convention is a framework rule that derives or configures page behavior and routes from application structure or centralized settings.
• code generationCode generation is the automated production of source code or related artifacts from a higher-level description or specification.
• ASP.NET Core ModuleThe ASP.NET Core Module is an IIS integration component that hosts ASP.NET Core applications and forwards requests between IIS and the application.
• IEndpointRouteBuilderIEndpointRouteBuilder is the ASP.NET Core interface for registering route endpoints and creating endpoint-specific application builders.
• IResultIResult is an ASP.NET Core interface representing the result produced by an HTTP endpoint for an HTTP response.
• _ViewImports.cshtml_ViewImports.cshtml is a conventionally named Razor file whose directives and imports are implicitly applied to Razor views and pages in its directory and descendant directories.
• url generationURL generation is the process of constructing endpoint URLs from routing metadata and route parameter values.
• ViewResultViewResult is an ASP.NET Core MVC action result that renders a Razor view using an optional view name and model.
• exception-handler middlewareException-handling middleware is middleware that catches or processes exceptions raised during request processing.
• asp-for attributeThe asp-for attribute is an ASP.NET Core Razor attribute that associates an HTML element with a model property for Tag Helper processing.
• named clientA named client is an IHttpClientFactory configuration identified by a string name and used to create consistently configured HttpClient instances.
• separation of concernsSeparation of concerns is a design principle that isolates distinct aspects of an application so each can change with minimal impact on the others.
• target audienceAn audience is the intended recipient identified by a token's audience claim.
• transient failureA transient error is a temporary failure, such as a network or service interruption, that may succeed when the operation is retried.
• api modelAn API model is the data representation returned by an API action for serialization and transmission to a client.
• page directiveThe @page directive is a Razor directive that marks a .cshtml file as a routable Razor Page.
• label tag helperThe Label Tag Helper is an ASP.NET Core Tag Helper that generates a label's associated field reference and display caption from a bound property.
• systemd daemonA systemd daemon is a Linux background process managed and supervised by the systemd service manager.
• AuthenticationMiddlewareAuthenticationMiddleware is ASP.NET Core middleware that authenticates the user associated with an HTTP request.
• SignInManager<T>SignInManager<T> is an ASP.NET Core Identity service for signing users in and out and managing request authentication state.
• UseSqlite()UseSqlite() is an Entity Framework Core configuration method that selects SQLite as the database provider for a context.
• OpenApiReferenceOpenApiReference is a .NET project configuration element that specifies an OpenAPI service reference for client code generation.
• IFormFileCollectionIFormFileCollection is the ASP.NET Core collection type representing uploaded files received from a multipart form request.
• workflow jobA Quartz.NET job is a task whose executable logic is defined by an implementation of IJob.
• StatusCodeResultStatusCodeResult is an ASP.NET Core action result that returns a specified HTTP status code, optionally with response content.
• data modelA database model represents the application data stored in a database and the structure used to work with that data.
• convention over configurationConvention over configuration is a design approach in which framework-defined naming and structure conventions determine behavior unless explicitly overridden.
• AuthorizationPolicyBuilderAuthorizationPolicyBuilder is the ASP.NET Core builder API for constructing authorization policies from requirements and other authorization conditions.
• background processingA background task is application work that executes independently of direct user interaction, often continuously, periodically, or in response to queued items.
• implicit dependencyAn implicit dependency is a required object or service obtained indirectly rather than declared through a component's parameters or constructor arguments.
• Swagger UISwagger UI is a web-based interface that visualizes an API description and enables interactive API requests.
• branchA middleware pipeline branch is an alternative request-processing path selected within a middleware pipeline.
• MapMapMethods is an ASP.NET Core endpoint-mapping method for associating a URL pattern and handler with one or more specified HTTP methods.
• services propertyThe Services property is the WebApplicationBuilder property through which application and framework services are registered for dependency injection.
• request messagePOST is an HTTP method used to send data to a server for processing or resource creation.
• input modelAn input model is a nested application class that groups the values a Razor Page receives through model binding.
• Blazor ServerBlazor Server is a Blazor hosting model in which UI rendering and event handling execute on the server while updates are sent to the browser.
• gRPCgRPC is a high-performance, language-independent remote procedure call framework for service-to-service communication.
• PageResultPageResult is an ASP.NET Core action result that renders the associated Razor Page as HTML and returns a successful response.
• IAuthorizationRequirementIAuthorizationRequirement is the ASP.NET Core marker interface implemented by classes that represent authorization requirements.
• captive dependencyA captive dependency is a lifetime mismatch in which a longer-lived service holds a dependency whose lifetime is shorter than its own.
• Visual StudioVisual Studio is Microsoft's integrated development environment for building, debugging, and managing software projects.
• error-handling pathAn error handling path is a URL path designated to generate a response for an error status code.
• RequestDelegateRequestDelegate is an ASP.NET Core delegate type representing a function that processes an HTTP context and returns asynchronously.
• preload directiveHSTS preload is a browser-supported technique that embeds a site's HTTPS-only policy in browser preload data before the site receives an initial request.
• file uploadA file upload is the transfer of a file from an HTTP client to an application through a request.
• ASP.NETASP.NET is Microsoft's legacy web application framework for the .NET ecosystem, preceding ASP.NET Core.
• backend-for-frontend patternBackend for Frontend is an architecture pattern that provides a dedicated backend for a particular frontend, handling authentication and translating or forwarding frontend requests to downstream APIs.
• OpenID Connect ID tokenAn ID token is an OpenID Connect token that describes a user authentication event and may contain claims about the authenticated user.
• reference tokenA reference token is an opaque credential whose associated claims must be retrieved from the identity provider before a protected API can use them.
• refresh tokenA refresh token is a credential that allows a client to obtain a new access token after the current access token expires without requiring the user to authenticate again.
• self-contained tokenA self-contained token carries the metadata and claims needed for an API or other resource server to validate it without contacting the issuer.
• AllowAnonymousAllowAnonymous is an ASP.NET Core attribute that permits access to an endpoint, action, or Razor Page without authentication.
• cross-cutting concernA cross-cutting concern is application behavior that applies across many or all request paths and features rather than one specific resource.
• ASP.NET Core data protection apiThe ASP.NET Core data protection API is the framework API for protecting application data through encryption, decryption, token generation, and cryptographic key management.
• key fileA data protection key file is a small XML file containing cryptographic key material used by ASP.NET Core data protection for encryption and decryption.
• synchronizer token patternThe synchronizer token pattern is a CSRF defense pattern that validates matching user-specific tokens supplied through separate request channels such as a cookie and form field.
• ValidateAntiForgeryToken attributeThe ValidateAntiForgeryToken attribute is an ASP.NET Core MVC attribute that requires validation of antiforgery tokens for a request.
• server farmA web farm is a deployment in which multiple servers host the same web application and must share state or cryptographic keys when processing requests.
• .NET toolA .NET global tool is a .NET CLI tool installed for use across projects and invoked from the command line.
• BadHttpRequestExceptionBadHttpRequestException is an ASP.NET Core exception indicating that an HTTP request is malformed or contains values that cannot be bound or interpreted.
• IConfigurationIConfiguration is the .NET abstraction for reading aggregated application configuration values from key-value configuration sources.
• HTTP methodAn HTTP verb is the method token in an HTTP request that indicates the intended operation.
• constructor injectionConstructor injection is a dependency injection technique in which required dependencies are supplied through an object's constructor.
• dependency inversionThe dependency inversion principle is a design principle in which high-level modules depend on abstractions rather than low-level implementation details.
• SOLID principlesSOLID is a mnemonic for five object-oriented design principles: single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion.
• ResultsResults is an ASP.NET Core static helper type that creates HTTP responses with common status codes and optional JSON bodies.
• self-contained deploymentA self-contained deployment packages an application's required .NET runtime with the application so the target machine does not need .NET installed.
• AddOptions<T>()AddOptions<T>() is an ASP.NET Core service-collection extension method that creates an OptionsBuilder<T> for configuring an options type.
• IConfigureOptions<T>IConfigureOptions<T> is a .NET interface implemented by components that configure instances of an options type.
• HTTP GETGET is an HTTP method for retrieving a resource from a server.
• MapGetMapGet is an ASP.NET Core endpoint-mapping method for associating a URL pattern and handler with HTTP GET requests.
• options patternThe IOptions pattern is a .NET configuration pattern that represents application settings as strongly typed options objects obtained through dependency injection.
• dotnet restoredotnet restore is a .NET CLI command that downloads a project's package dependencies and establishes their references for building.
• AddControllersAddControllers is an ASP.NET Core service-registration method that adds the services required for controllers without adding Razor view-rendering services.
• ControllerBaseThe Controller base class is the ASP.NET Core MVC base class that provides controller infrastructure, including access to an IUrlHelper.
• MapControllersMapControllers is an ASP.NET Core endpoint-mapping method that exposes attribute-routed controller actions as endpoints.
• service locator patternThe service locator pattern is a design pattern in which application code directly requests dependencies from a central service provider.
• RouteAttributeRouteAttribute is an ASP.NET Core attribute that associates a controller action with a route template.
• short-circuit evaluationA short circuit is the termination of request-processing pipeline execution by returning a result without invoking the remaining components.
• object-relational mapperAn object-relational mapper is a software abstraction that maps object-oriented program types and operations to database concepts such as tables, columns, and queries.
• RawRaw is a Razor HTML helper method that writes a string to the response without HTML encoding it.
• TestServerTestServer is an ASP.NET Core in-memory server that accepts test requests and returns responses without requiring a network server.
• select tag helperThe Select Tag Helper is an ASP.NET Core Tag Helper that generates HTML select controls and their options from Razor model properties and item collections.
• SelectListItemSelectListItem is an ASP.NET Core MVC data structure representing one option in a select list, including its value, text, and selection state.
• url pathAn HTTP path identifies the resource or resource location targeted by an HTTP request.
• AuthorizeAsyncAuthorizeAsync is an ASP.NET Core authorization API method that asynchronously evaluates whether a user satisfies an authorization requirement or policy.
• retryA retry policy is a resilience rule that repeats a failed operation according to configured retry conditions and limits.
• IOptionsSnapshot<T>IOptionsSnapshot<T> is a .NET options interface that provides options values capable of reflecting configuration changes across dependency-injection scopes.
• HttpMessageHandlerHttpMessageHandler is the .NET base abstraction for processing HTTP requests and responses in an HttpClient handler chain.
• hsts headerHTTP Strict Transport Security is a web security policy that lets a site instruct browsers to use HTTPS for subsequent requests.
• ServiceFilterAttributeServiceFilterAttribute is an ASP.NET Core MVC attribute that obtains a filter and its dependencies from the dependency-injection container.
• TypeFilterAttributeTypeFilterAttribute is an ASP.NET Core MVC attribute that creates a filter through dependency injection while requiring registration only of its dependencies.
• SaveChangesSaveChanges is an Entity Framework Core database-context method that persists tracked data changes to the configured database.
• FactFact is an xUnit attribute identifying a parameterless method as an individual test case.
• templateA software template is a predefined starting structure containing code and configuration for building an application.
• AddSingletonAddSingleton is an ASP.NET Core service-registration method that registers a service with singleton lifetime.
• ASP.NET Core MVCASP.NET Core MVC is the ASP.NET Core web framework implementation of the Model-View-Controller pattern for building web applications.
• Accept headerAn Accept header is an HTTP request header that lists the media types a client can understand and may rank by preference.
• input formatterAn input formatter is an ASP.NET Core component that reads request content in a supported media format and converts it into application data.
• staticfilemiddlewareStaticFileMiddleware is the ASP.NET Core middleware component that serves existing files from a configured file directory in response to matching requests.
• development certificateA development certificate is a locally trusted certificate intended for securing an application's development-time HTTPS connections.
• middleware orderingMiddleware ordering is the arrangement of request-processing components that determines their execution sequence and response behavior.
• SqliteConnectionSqliteConnection is the Microsoft.Data.Sqlite connection type used to connect an application to a SQLite database.
• deletionRemove is an Entity Framework Core method that marks an entity for deletion when changes are saved.
• plain old CLR objectA plain old CLR object is an ordinary .NET object that does not depend on a specialized framework base type or programming model.
• TagHelperOutputTagHelperOutput is the ASP.NET Core object representing the generated element, attributes, and content produced by a Tag Helper.
• IdentityDbContextIdentityDbContext<TUser> is an Entity Framework Core database context base class that maps ASP.NET Core Identity data for a specified user type.
• JSON file providerA JSON provider is a configuration provider that reads application settings from JSON-formatted files.
• _ViewStart.cshtml_ViewStart.cshtml is a conventionally named Razor file containing code that executes before Razor views or pages in its directory and descendant directories are rendered.
• ASP.NET MVCASP.NET MVC is Microsoft's earlier web framework for building applications with the Model-View-Controller pattern on the .NET platform.
• System.Web.dllSystem.Web.dll is the .NET Framework assembly that supplies the core ASP.NET Web Forms and classic ASP.NET web infrastructure.
• IJobIJob is the Quartz.NET interface that defines the executable contract for a scheduled job.
• route groupA route group is a minimal API organization construct that applies a common route prefix and shared endpoint configuration to multiple endpoints.
• AddRazorPagesOptionsAddRazorPagesOptions is an ASP.NET Core extension method that configures Razor Pages options and conventions during service registration.
• Proof Key for Code ExchangeAuthorization code with PKCE is an OAuth authorization flow that protects the authorization code exchange with a proof key generated by the client.
• endpoint routingEndpoint routing is the ASP.NET Core routing system that separates request endpoint selection from endpoint execution in middleware.
• FromServices attributeThe FromServices attribute is an ASP.NET Core parameter attribute that directs a handler parameter to be resolved from dependency injection services.
• TLSTransport Layer Security is a cryptographic protocol that provides authenticated and encrypted communication over a network.
• terminal middlewareTerminal middleware is a middleware component that stops further pipeline processing by generating and returning a response.
• YARPYARP is a .NET library and proxy toolkit for building high-performance customizable reverse proxies.
• placeholderA log placeholder is a named brace-delimited marker in a logging message template whose value is supplied by a corresponding runtime parameter.
• .NET Framework.NET Framework is Microsoft's legacy Windows-focused platform and runtime for building .NET applications.
• AddPolicyAddPolicy is an ASP.NET Core authorization configuration method that registers a named policy defined by a policy builder.
• UseStatusCodePagesUseStatusCodePages is an ASP.NET Core application-builder extension method that adds StatusCodePagesMiddleware to the request pipeline.
• ForwardedHeadersMiddlewareForwardedHeadersMiddleware is ASP.NET Core middleware that applies proxy-forwarded HTTP headers to the request context.
• X-Forwarded-Proto headerX-Forwarded-Proto is an HTTP request header that identifies the protocol used by the client for the original request to a proxy.
• insecure direct object referenceAn insecure direct object reference is a security vulnerability in which a user gains access to an unauthorized resource by manipulating a direct identifier in a request URL or other input.
• dotnet ef database updatedotnet ef database update is an Entity Framework Core command that creates the database when necessary and applies pending migrations.
• HttpClientHandlerHttpClientHandler is the .NET HttpMessageHandler that establishes network connections and sends HTTP requests for HttpClient.
• action filter attributeActionFilterAttribute is an ASP.NET Core abstract base class that provides synchronous and asynchronous MVC action- and result-filter behavior.
• AuthorizationMiddlewareAuthorizationMiddleware is ASP.NET Core middleware that determines whether an authenticated user may access a selected endpoint.
• route constraintA route constraint is a rule attached to a route parameter that determines whether a URL value satisfies the requirements for matching a route template.
• IValidatableObjectIValidatableObject is a .NET interface that lets an object perform validation involving its own property values and return validation results.
• TypedResultsTypedResults is an ASP.NET Core static helper type that creates typed HTTP responses with common status codes and optional JSON bodies.
• soft deletionSoft delete is a deletion technique that marks a record as deleted so it is excluded from application exposure while remaining stored.
• model directiveThe @model directive is a Razor directive that declares the PageModel type associated with a Razor Page.
• Startup.ConfigureConfigure is the conventional ASP.NET Core Startup method that builds an application's middleware pipeline and endpoint configuration.
• UseEndpointsUseEndpoints is an ASP.NET Core extension method that adds endpoint execution middleware and registers endpoints in a request pipeline.
• MapRazorPagesMapRazorPages is an ASP.NET Core endpoint-mapping method that registers endpoints for an application's Razor Pages.
• payloadA JWT payload is the token section that contains its claims and other encoded data.
• security schemeAn OpenAPI security scheme is a declaration describing the authentication or authorization mechanism an HTTP API uses to protect operations.
• IUrlHelperIUrlHelper is an ASP.NET Core interface that provides methods for generating URLs from routing information within web application components.
• EnsureCreatedEnsureCreated is an Entity Framework Core database method that creates the database and its schema if they do not already exist, without applying migrations.
• PollyPolly is a .NET resilience library for defining policies that handle faults and control retries, timeouts, circuit breakers, and related behaviors.
• IIS integrationUseIISIntegration is an ASP.NET Core extension method that configures an application for out-of-process hosting behind Internet Information Services.
• UserManager<T>UserManager<T> is an ASP.NET Core Identity service for creating, retrieving, updating, and managing users and their associated credentials and data.
• cross-origin requestA cross-origin request is an HTTP request made by a web page to a different origin than the one that served the page.
• ASP.NET Web FormsASP.NET Web Forms is a server-side web application programming model based on graphical design tools and an event-driven control model.
• JWT AuthenticationJWT bearer authentication is an HTTP authentication technique that presents and validates a signed JSON Web Token in a bearer authorization header.
• AddEndpointFilterAddEndpointFilter is an ASP.NET Core endpoint-mapping method that attaches an endpoint filter to an endpoint or route group.
• BindConfiguration()BindConfiguration() is a .NET options extension method that binds an options type to a named configuration section.
• BindAsyncBindAsync is a static method convention that allows an ASP.NET Core minimal API parameter type to define custom model-binding logic.
• AddPageRouteAddPageRoute is a Razor Pages configuration method that associates an additional route template with a specified page.
• IPageRouteModelConventionIPageRouteModelConvention is an ASP.NET Core interface for modifying route templates and route metadata while Razor Page models are being constructed.
• parameter transformerA parameter transformer is a routing component that transforms route parameter or token text when generating route templates or URLs.
• razor expressionA Razor expression is an inline Razor construct that evaluates a C# expression and writes its result to the generated HTML output.
• assertionAn assertion is a test operation that verifies an actual result satisfies an expected condition.
• deploymentDeployment is the process of installing and configuring an application and its required artifacts in an environment where users can access it.
• ConfigureWebHostDefaultsConfigureWebHostDefaults is a host-builder method that applies default configuration for an ASP.NET Core web host, including configuring Kestrel.
• post-redirect-getPOST-Redirect-GET is a web interaction pattern in which a successful form submission responds with a redirect to a URL retrieved using GET, preventing refreshes from resubmitting the POST.
• FromRoute attributeThe FromRoute attribute is an ASP.NET Core parameter-binding attribute that specifies binding a parameter from route values.
• dotnet testdotnet test is a .NET CLI command that restores and builds a test project and then runs its tests.
• Microsoft.AspNetCore.Mvc.TestingMicrosoft.AspNetCore.Mvc.Testing is a .NET package that provides infrastructure for hosting and testing ASP.NET Core applications in memory.
• WithWebHostBuilderWithWebHostBuilder is a WebApplicationFactory method that returns a customized test factory configured through an application host builder.
• MapA dictionary is a key-value data structure that associates each key with a value.
• LamarLamar is an open-source .NET dependency injection and inversion-of-control container.
• nullable reference typesNullable reference types are a C# compiler feature that represents and checks whether reference-type values may be null.
• domain name systemDNS is the hierarchical naming system that resolves hostnames to IP addresses and other network records.
• StartAsyncStartAsync is an asynchronous host method that starts a configured application and returns when startup processing has completed.
• SeqSeq is a structured log server and analysis tool for collecting, storing, searching, and filtering application log events.
• AddEnvironmentVariablesAddEnvironmentVariables is a .NET configuration extension method that adds operating-system environment variables as configuration settings.
• AddUserSecretsAddUserSecrets is a .NET configuration extension method that loads User Secrets for an application.
• BindPropertiesBindProperties is an ASP.NET Core Razor Pages attribute that enables model binding for every property on a PageModel.
• MinimalApis.ExtensionsMinimalApis.Extensions is a .NET library that adds extensions for ASP.NET Core minimal APIs, including parameter validation support.
• sensitive informationSensitive data is information whose disclosure or misuse could harm a person, system, or organization.
• WithParameterValidationWithParameterValidation is a MinimalApis.Extensions endpoint extension method that adds parameter validation to a minimal API endpoint.
• HTTP responseHttpResponse is the ASP.NET Core object representing the HTTP response sent to a client, including its status code, headers, content type, and body.
• Microsoft.Extensions.Http.PollyMicrosoft.Extensions.Http.Polly is a .NET integration library that applies Polly resilience policies to HttpClient instances created by IHttpClientFactory.
• scope-based authorization policyA scope-based authorization policy is an authorization policy that requires an access token to contain a specified scope.
• AddControllersWithViewsAddControllersWithViews is an ASP.NET Core service-registration method that adds MVC controller and view services to an application's dependency injection container.
• pipeline reexecutionPipeline reexecution is the process of running a request-processing middleware pipeline again for a different path after an exception or other handling condition.
• AddHttpClientAddHttpClient is a .NET dependency-injection extension method that registers an HttpClient and optionally associates its configuration with a typed or named client.
• metadataMetadata is descriptive information attached to an endpoint that can be inspected or used by framework components.
• single-page applicationA single-page application is a web application that updates its user interface dynamically without full-page navigation for most interactions.
• one-to-many relationshipA many-to-one relationship is an association in which multiple instances of one entity type are associated with a single instance of another entity type.
• parameterized queryA parameterized query separates user-supplied values from the SQL command structure so the values are not interpreted as SQL code.
• grant typeA grant type is an OAuth 2.0-defined authorization flow for obtaining access credentials in a particular application scenario.
• ILoggerFactoryILoggerFactory is a .NET logging abstraction that registers logging providers and creates loggers associated with those providers.
• certificate storeA certificate store is an operating-system or application repository that holds digital certificates and associated trust information.
• certification authorityA certificate authority is a trusted entity that issues or signs digital certificates to attest to the identity of certificate holders.
• dotnet builddotnet build is a .NET CLI command that compiles a .NET project and produces runnable build outputs when compilation succeeds.
• directiveA Razor directive is an instruction beginning with @ that controls compilation or behavior of a Razor file.
• SupportsGetSupportsGet is a BindProperty setting that permits a Razor Pages property to receive values during GET request model binding.
• in-process hosting modelAn in-process hosting model runs an ASP.NET Core application directly inside the IIS process.
• out-of-process hosting modelAn out-of-process hosting model runs an ASP.NET Core application in a separate process from IIS, which forwards requests to it.
• IServiceCollectionIServiceCollection is the ASP.NET Core abstraction representing the collection of service registrations available to an application.
• LogInformationLogInformation is an ILogger extension method that records a message at the Information severity level.
• implementation typeAn implementation type is the concrete class that a dependency injection container creates to fulfill a service dependency.
• service typeA service type is the class or interface that a dependency injection container uses as the requested dependency contract.
• EnvironmentTagHelperEnvironmentTagHelper is a built-in ASP.NET Core Tag Helper that conditionally renders its element content for specified hosting environments.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.