book

Pro ASP.NET Core 7, Tenth Edition

Name: Pro ASP.NET Core 7, Tenth Edition
Author: Adam Freeman
ISBN: 9781633437821

by Adam Freeman

November 2023

Beginner to intermediate

1256 pages

32h 44m

English

Manning Publications

Read now

Unlock full access

Praises from reviewers of Pro ASP.NET Core 7, Tenth Edition
Pro ASP.NET Core 7
Copyright
dedication
contents
front matter
prefaceabout this bookWho should read this bookHow this book is organized: a roadmapAbout the codeliveBook discussion forumabout the authorabout the cover illustration
1 Putting ASP.NET Core in context
1.1 Understanding the application frameworks1.1.1 Understanding the MVC Framework1.1.2 Understanding Razor Pages1.1.3 Understanding Blazor1.1.4 Understanding the utility frameworks1.1.5 Understanding the ASP.NET Core platform1.2 Understanding this book1.2.1 What software do I need to follow the examples?1.2.2 What platform do I need to follow the examples?1.2.3 What if I have problems following the examples?1.2.4 What if I find an error in the book?1.2.5 What does this book cover?1.2.6 What doesn’t this book cover?1.2.7 How do I contact the author?1.2.8 What if I really enjoyed this book?1.2.9 What if this book has made me angry and I want to complain?Summary
Part 1.
2 Getting started
2.1 Choosing a code editor2.1.1 Installing Visual Studio2.1.3 Installing Visual Studio Code2.2 Creating an ASP.NET Core project2.2.1 Opening the project using Visual Studio2.2.2 Opening the project with Visual Studio Code2.3 Running the ASP.NET Core application2.3.1 Understanding endpoints2.3.2 Understanding routes2.3.3 Understanding HTML rendering2.3.4 Putting the pieces togetherSummary
3 Your first ASP.NET Core application
3.1 Setting the scene3.2 Creating the project3.2.1 Preparing the project3.2.2 Adding a data model3.2.3 Creating a second action and view3.2.4 Linking action methods3.2.5 Building the form3.2.6 Receiving form data3.2.7 Adding the Thanks view3.2.8 Displaying responses3.2.9 Adding validation3.2.10 Styling the contentSummary

4 Using the development tools
4.1 Creating ASP.NET Core projects4.1.1 Creating a project using the command line4.2 Adding code and content to projects4.2.1 Understanding item scaffolding4.3 Building and running projects4.3.1 Using the hot reload feature4.4 Managing packages4.4.1 Managing NuGet packages4.4.2 Managing tool packages4.4.3 Managing client-side packages4.5 Debugging projectsSummary
5 Essential C# features
5.1 Preparing for this chapter5.1.1 Opening the project5.1.2 Enabling the MVC Framework5.1.3 Creating the application components5.1.4 Selecting the HTTP port5.1.5 Running the example application5.2 Understanding top-level statements5.3 Understanding global using statements5.3.1 Understanding implicit using statements5.4 Understanding null state analysis5.4.1 Ensuring fields and properties are assigned values5.4.2 Providing a default value for non-nullable types5.4.3 Using nullable types5.4.4 Checking for null values5.4.5 Overriding null state analysis5.4.6 Disabling null state analysis warnings5.5 Using string interpolation5.6 Using object and collection initializers5.6.1 Using an index initializer5.7 Using target-typed new expressions5.8 Pattern Matching5.8.1 Pattern matching in switch statements5.9 Using extension methods5.9.1 Applying extension methods to an interface5.9.2 Creating filtering extension methods5.10 Using lambda expressions5.10.1 Defining functions5.10.2 Using lambda expression methods and properties5.11 Using type inference and anonymous types5.11.1 Using anonymous types5.12 Using default implementations in interfaces5.13 Using asynchronous methods5.13.1 Working with tasks directly5.13.2 Applying the async and await keywords5.13.3 Using an asynchronous enumerable5.14 Getting namesSummary
6 Testing ASP.NET Core applications
6.1 Preparing for this chapter6.1.1 Opening the project6.1.2 Selecting the HTTP port6.1.3 Enabling the MVC Framework6.1.4 Creating the application components6.1.5 Running the example application6.2 Creating a unit test project6.3 Writing and running unit tests6.3.1 Running tests with the Visual Studio Test Explorer6.3.2 Running tests with Visual Studio Code6.3.3 Running tests from the command line6.3.4 Correcting the unit test6.3.5 Isolating components for unit testing6.3.6 Using a mocking package6.3.7 Creating a mock objectSummary
7 SportsStore: A real application
7.1 Creating the projects7.1.1 Creating the unit test project7.1.2 Opening the projects7.1.3 Configuring the HTTP port7.1.4 Creating the application project folders7.1.5 Preparing the services and the request pipeline7.1.6 Configuring the Razor view engine7.1.7 Creating the controller and view7.1.8 Starting the data model7.1.9 Checking and running the application7.2 Adding data to the application7.2.1 Installing the Entity Framework Core packages7.2.2 Defining the connection string7.2.3 Creating the database context class7.2.4 Configuring Entity Framework Core7.2.5 Creating a repository7.2.6 Creating the database migration7.2.7 Creating seed data7.3 Displaying a list of products7.3.1 Preparing the controller7.3.2 Updating the view7.3.3 Running the application7.4 Adding pagination7.4.1 Displaying page links7.4.2 Improving the URLs7.5 Styling the content7.5.1 Installing the Bootstrap package7.5.2 Applying Bootstrap styles7.5.3 Creating a partial viewSummary
8 SportsStore: Navigation and cart
8.1 Adding navigation controls8.1.1 Filtering the product list8.1.2 Refining the URL scheme8.1.3 Building a category navigation menu8.1.4 Correcting the page count8.2 Building the shopping cart8.2.1 Configuring Razor Pages8.2.2 Creating a Razor Page8.2.3 Creating the Add to Cart buttons8.2.4 Enabling sessions8.2.5 Implementing the cart featureSummary
9 SportsStore: Completing the cart
9.1 Refining the cart model with a service9.1.1 Creating a storage-aware cart class9.1.2 Registering the service9.1.3 Simplifying the cart Razor Page9.2 Completing the cart functionality9.2.1 Removing items from the cart9.2.2 Adding the cart summary widget9.3 Submitting orders9.3.1 Creating the model class9.3.2 Adding the checkout process9.3.3 Creating the controller and view9.3.4 Implementing order processing9.3.5 Completing the order controller9.3.6 Displaying validation errors9.3.7 Displaying a summary pageSummary
10 SportsStore: Administration
10.1 Preparing Blazor Server10.1.1 Creating the imports file10.1.2 Creating the startup Razor Page10.1.3 Creating the routing and layout components10.1.4 Creating the Razor Components10.1.5 Checking the Blazor setup10.2 Managing orders10.2.1 Enhancing the model10.2.2 Displaying orders to the administrator10.3 Adding catalog management10.3.1 Expanding the repository10.3.2 Applying validation attributes to the data model10.3.3 Creating the list component10.3.4 Creating the detail component10.3.5 Creating the editor component10.3.6 Deleting productsSummary
11 SportsStore: Security and deployment
11.1 Creating the Identity database11.1.1 Installing the Identity package for Entity Framework Core11.1.2 Creating the context class11.1.3 Defining the connection string11.1.4 Configuring the application11.1.5 Creating and applying the database migration11.1.6 Defining the seed data11.2 Adding a conventional administration feature11.3 Applying a basic authorization policy11.4 Creating the account controller and views11.5 Testing the security policy11.6 Preparing ASP.NET Core for deployment11.6.1 Configuring error handling11.6.2 Creating the production configuration settings11.6.3 Creating the Docker image11.6.4 Running the containerized applicationSummary
Part 2.
12 Understanding the ASP.NET Core platform
12.1 Preparing for this chapter12.1.1 Running the example application12.2 Understanding the ASP.NET Core platform12.2.1 Understanding middleware and the request pipeline12.2.2 Understanding services12.3 Understanding the ASP.NET Core project12.3.1 Understanding the entry point12.3.2 Understanding the project file12.4 Creating custom middleware12.4.1 Defining middleware using a class12.4.2 Understanding the return pipeline path12.4.3 Short-Circuiting the request pipeline12.4.4 Creating pipeline branches12.4.5 Creating terminal middleware12.5 Configuring middleware12.5.1 Using the options pattern with class-based middlewareSummary
13 Using URL routing
13.1 Preparing for this chapter13.1.1 Understanding URL routing13.1.2 Adding the routing middleware and defining an endpoint13.1.3 Simplifying the pipeline configuration13.1.4 Understanding URL patterns13.1.5 Using segment variables in URL patterns13.1.6 Generating URLs from routes13.2 Managing URL matching13.2.1 Matching multiple values from a single URL segment13.2.2 Using default values for segment variables13.2.3 Using optional segments in a URL Pattern13.2.4 Using a catchall segment variable13.2.5 Constraining segment matching13.2.6 Defining fallback routes13.3 Advanced routing features13.3.1 Creating custom constraints13.3.2 Avoiding ambiguous route exceptions13.3.3 Accessing the endpoint in a middleware componentSummary
14 Using dependency injection
14.1 Preparing for this chapter14.1.1 Creating a middleware component and an endpoint14.1.2 Configuring the request pipeline14.2 Understanding service location and tight coupling14.2.1 Understanding the service location problem14.2.2 Understanding the tightly coupled components problem14.3 Using dependency injection14.3.1 Using a Service with a Constructor Dependency14.3.2 Getting services from the HttpContext object14.4 Using Service Lifecycles14.4.1 Creating transient services14.4.2 Avoiding the transient service reuse pitfall14.4.3 Using scoped services14.5 Other dependency injection features14.5.1 Creating dependency chains14.5.2 Accessing services in the Program.cs file14.5.3 Using service factory functions14.5.4 Creating services with multiple implementations14.5.5 Using unbound types in servicesSummary
15 Using the platform features, part 1
15.1 Preparing for this chapter15.2 Using the configuration service15.2.1 Understanding the environment configuration file15.2.2 Accessing configuration settings15.2.3 Using the configuration data in the Program.cs file15.2.4 Using configuration data with the options pattern15.2.5 Understanding the launch settings file15.2.6 Using the environment service15.2.7 Storing user secrets15.3 Using the logging service15.3.1 Generating logging messages15.3.2 Logging messages with attributes15.3.3 Configuring minimum logging levels15.3.4 Logging HTTP requests and responses15.4 Using static content and client-side packages15.4.1 Adding the static content middleware15.4.2 Using client-side packagesSummary
16 Using the platform features, part 2
16.1 Preparing for this chapter16.2 Using cookies16.2.1 Enabling cookie consent checking16.2.2 Managing cookie consent16.3 Using sessions16.3.1 Configuring the session service and middleware16.3.2 Using session data16.4 Working with HTTPS connections16.4.1 Enabling HTTPS connections16.4.2 Detecting HTTPS requests16.4.3 Enforcing HTTPS requests16.4.4 Enabling HTTP strict transport security16.5 Using rate limits16.6 Handling exceptions and errors16.6.1 Returning an HTML error response16.6.2 Enriching status code responses16.7 Filtering requests using the host headerSummary
17 Working with data
17.1 Preparing for this chapter17.2 Caching data17.2.1 Caching data values17.2.2 Using a shared and persistent data cache17.3 Caching responses17.4 Caching output17.4.1 Defining a custom cache policy17.5 Using Entity Framework Core17.5.1 Installing Entity Framework Core17.5.2 Creating the data model17.5.3 Configuring the database service17.5.4 Creating and applying the database migration17.5.5 Seeding the database17.5.6 Using data in an endpointSummary
Part 3.
18 Creating the example project
18.1 Creating the project18.2 Adding a data model18.2.1 Adding NuGet packages to the project18.2.2 Creating the data model18.2.3 Preparing the seed data18.2.4 Configuring EF Core services and middleware18.2.5 Creating and applying the migration18.3 Adding the CSS framework18.4 Configuring the request pipeline18.5 Running the example application
19 Creating RESTful web services
19.1 Preparing for this chapter19.2 Understanding RESTful web services19.2.1 Understanding request URLs and methods19.2.2 Understanding JSON19.3 Creating a web service using the minimal API19.4 Creating a web service using a controller19.4.1 Enabling the MVC Framework19.4.2 Creating a controller19.5 Improving the web service19.5.1 Using asynchronous actions19.5.2 Preventing over-binding19.5.3 Using action results19.5.4 Validating data19.5.5 Applying the API controller attribute19.5.6 Omitting Null properties19.5.7 Applying a rate limitSummary
20 Advanced web service features
20.1 Preparing for this chapter20.1.1 Dropping the database20.1.2 Running the example application20.2 Dealing with related data20.2.1 Breaking circular references in related data20.3 Supporting the HTTP PATCH method20.3.1 Understanding JSON Patch20.3.2 Installing and configuring the JSON Patch package20.3.3 Defining the action method20.4 Understanding content formatting20.4.1 Understanding the default content policy20.4.2 Understanding content negotiation20.4.3 Specifying an action result format20.4.4 Requesting a format in the URL20.4.5 Restricting the formats received by an action method20.4.6 Caching output20.5 Documenting and exploring web services20.5.1 Resolving action conflicts20.5.2 Installing and configuring the Swashbuckle package20.5.3 Fine-Tuning the API descriptionSummary
21 Using controllers with views, part I
21.1 Preparing for this chapter21.1.1 Dropping the database21.1.2 Running the example application21.2 Getting started with views21.2.1 Configuring the application21.2.2 Creating an HTML controller21.2.3 Creating a Razor View21.2.4 Selecting a View by name21.3 Working with Razor Views21.3.1 Setting the view model type21.3.2 Understanding the view model type pitfall21.4 Understanding the Razor syntax21.4.1 Understanding directives21.4.2 Understanding content expressions21.4.3 Setting element content21.4.4 Setting attribute values21.4.5 Using conditional expressions21.4.6 Enumerating sequences21.4.7 Using Razor code blocksSummary
22 Using controllers with views, part II
22.1 Preparing for this chapter22.1.1 Dropping the database22.1.2 Running the example application22.2 Using the view bag22.3 Using temp data22.4 Working with layouts22.4.1 Configuring layouts using the view bag22.4.2 Using a view start file22.4.3 Overriding the default layout22.4.4 Using layout sections22.5 Using partial views22.5.1 Enabling partial views22.5.2 Creating a partial view22.5.3 Applying a partial view22.6 Understanding content-encoding22.6.1 Understanding HTML encoding22.6.2 Understanding JSON encodingSummary
23 Using Razor Pages
23.1 Preparing for this chapter23.1.1 Running the example application23.2 Understanding Razor Pages23.2.1 Configuring Razor Pages23.2.2 Creating a Razor Page23.3 Understanding Razor Pages routing23.3.1 Specifying a routing pattern in a Razor Page23.3.2 Adding routes for a Razor Page23.4 Understanding the Page model class23.4.1 Using a code-behind class file23.4.2 Understanding action results in Razor Pages23.4.3 Handling multiple HTTP methods23.4.4 Selecting a handler method23.5 Understanding the Razor Page view23.5.1 Creating a layout for Razor Pages23.5.2 Using partial views in Razor Pages23.5.3 Creating Razor Pages without page modelsSummary
24 Using view components
24.1 Preparing for this chapter24.1.1 Dropping the database24.1.2 Running the example application24.2 Understanding view components24.3 Creating and using a view component24.3.1 Applying a view component24.4 Understanding view component results24.4.1 Returning a partial view24.4.2 Returning HTML fragments24.5 Getting context data24.5.1 Providing context from the parent view using arguments24.5.2 Creating asynchronous view components24.6 Creating view components classes24.6.1 Creating a hybrid controller classSummary
25 Using tag helpers
25.1 Preparing for this chapter25.1.1 Dropping the database25.1.2 Running the example application25.2 Creating a tag helper25.2.1 Defining the tag helper class25.2.2 Registering tag helpers25.2.3 Using a tag helper25.2.4 Narrowing the scope of a tag helper25.2.5 Widening the scope of a tag helper25.3 Advanced tag helper features25.3.1 Creating shorthand elements25.3.2 Creating elements programmatically25.3.3 Prepending and appending content and elements25.3.4 Getting view context data25.3.5 Working with model expressions25.3.6 Coordinating between tag helpers25.3.7 Suppressing the output element25.4 Using tag helper components25.4.1 Creating a tag helper component25.4.2 Expanding tag helper component element selectionSummary
26 Using the built-in tag helpers
26.1 Preparing for this chapter26.1.1 Adding an image file26.1.2 Installing a client-side package26.1.3 Dropping the database26.1.4 Running the example application26.2 Enabling the built-in tag helpers26.3 Transforming anchor elements26.3.1 Using anchor elements for Razor Pages26.4 Using the JavaScript and CSS tag helpers26.4.1 Managing JavaScript files26.4.2 Managing CSS stylesheets26.5 Working with image elements26.6 Using the data cache26.6.1 Setting cache expiry26.7 Using the hosting environment tag helperSummary
27 Using the forms tag helpers
27.1 Preparing for this chapter27.1.1 Dropping the database27.1.2 Running the example application27.2 Understanding the form handling pattern27.2.1 Creating a controller to handle forms27.2.2 Creating a Razor Page to handle forms27.3 Using tag helpers to improve HTML forms27.3.1 Working with form elements27.3.2 Transforming form buttons27.4 Working with input elements27.4.1 Transforming the input element type attribute27.4.2 Formatting input element values27.4.3 Displaying values from related data in input elements27.5 Working with label elements27.6 Working with select and option elements26.6.1 Populating a select element27.7 Working with text areas27.8 Using the anti-forgery feature27.8.1 Enabling the anti-forgery feature in a controller27.8.2 Enabling the anti-forgery feature in a Razor Page27.8.3 Using anti-forgery tokens with JavaScript clientsSummary
28 Using model binding
28.1 Preparing for this chapter28.1.1 Dropping the database28.1.2 Running the example application28.2 Understanding model binding28.3 Binding simple data types28.3.1 Binding simple data types in Razor Pages28.3.2 Understanding default binding values28.4 Binding complex types28.4.1 Binding to a property28.4.2 Binding nested complex types28.4.3 Selectively binding properties28.5 Binding to arrays and collections28.5.1 Binding to arrays28.5.2 Binding to simple collections28.5.3 Binding to dictionaries28.5.4 Binding to collections of complex types28.6 Specifying a model binding source28.6.1 Selecting a binding source for a property28.6.2 Using headers for model binding28.6.3 Using request bodies as binding sources28.7 Manual model bindingSummary
29 Using model validation
29.1 Preparing for this chapter29.1.1 Dropping the database29.1.2 Running the example application29.2 Understanding the need for model validation29.3 Validating data29.3.1 Displaying validation messages29.3.2 Understanding the implicit validation checks29.3.3 Performing explicit validation29.3.4 Configuring the default validation error messages29.3.4 Displaying property-level validation messages29.3.5 Displaying model-level messages29.4 Explicitly validating data in a Razor Page29.5 Specifying validation rules using metadata29.5.1 Creating a custom property validation attribute29.5.2 Creating a custom model validation attribute29.6 Performing client-side validation29.7 Performing remote validation29.7.1 Performing remote validation in Razor PagesSummary
30 Using filters
30.1 Preparing for this chapter30.1.1 Enabling HTTPS Connections30.1.2 Dropping the database30.1.3 Running the example application30.2 Using filters30.3 Understanding filters30.4 Creating custom filters30.4.1 Understanding authorization filters30.4.2 Understanding resource filters30.4.3 Understanding action filters30.4.4 Understanding page filters30.4.5 Understanding result filters30.4.6 Understanding exception filters30.4.7 Creating an exception filter30.5 Managing the filter lifecycle30.5.1 Creating filter factories30.5.2 Using dependency injection scopes to manage filter lifecycles30.6 Creating global filters30.7 Understanding and changing filter orderSummary
31 Creating form applications
31.1 Preparing for this chapter31.1.1 Dropping the database31.1.2 Running the example application31.2 Creating an MVC forms application31.2.1 Preparing the view model and the view31.2.2 Reading data31.2.3 Creating data31.2.4 Editing data31.2.5 Deleting data31.3 Creating a Razor Pages forms application31.3.1 Creating common functionality31.3.2 Defining pages for the CRUD operations31.4 Creating new related data objects31.4.1 Providing the related data in the same request31.4.2 Breaking out to create new dataSummary
Part 4.
32 Creating the example project
32.1 Creating the project32.1.1 Adding NuGet packages to the project32.2 Adding a data model32.2.1 Preparing the seed data32.2.2 Configuring Entity Framework Core32.2.3 Creating and applying the migration32.3 Adding the Bootstrap CSS framework32.4 Configuring the services and middleware32.5 Creating a controller and view32.6 Creating a Razor Page32.7 Running the example application
33 Using Blazor Server, part 1
33.1 Preparing for this chapter33.2 Understanding Blazor Server33.2.1 Understanding the Blazor Server advantages33.2.2 Understanding the Blazor Server disadvantages33.2.3 Choosing between Blazor Server and Angular/React/Vue.js33.3 Getting started with Blazor33.3.1 Configuring ASP.NET Core for Blazor Server33.3.2 Creating a Razor Component33.4 Understanding the basic Razor Component features33.4.1 Understanding Blazor events and data bindings33.4.2 Working with data bindings33.5 Using class files to define components33.5.1 Using a code-behind class33.5.2 Defining a Razor Component classSummary
34 Using Blazor Server, part 2
34.1 Preparing for this chapter34.2 Combining components34.2.1 Configuring components with attributes34.2.2 Creating custom events and bindings34.3 Displaying child content in a component34.3.1 Creating template components34.3.2 Using generic type parameters in template components34.3.3 Cascading parameters34.4 Handling errors34.4.1 Handling connection errors34.4.2 Handling uncaught application errors34.4.3 Using error boundariesSummary
35 Advanced Blazor features
35.1 Preparing for this chapter35.2 Using component routing35.2.1 Preparing the Razor Page35.2.2 Adding routes to components35.2.3 Navigating between routed components35.2.4 Receiving routing data35.2.5 Defining common content using layouts35.3 Understanding the component lifecycle methods35.3.1 Using the lifecycle methods for asynchronous tasks35.4 Managing component interaction35.4.1 Using references to child components35.4.2 Interacting with components from other code35.4.3 Interacting with components using JavaScriptSummary
36 Blazor forms and data
36.1 Preparing for this chapter36.1.1 Dropping the database and running the application36.2 Using the Blazor form components36.2.1 Creating custom form components36.2.2 Validating form data36.2.3 Handling form events36.3 Using Entity Framework Core with Blazor36.3.1 Understanding the EF Core context scope issue36.3.2 Understanding the repeated query issue36.4 Performing CRUD operations36.4.1 Creating the list component36.4.2 Creating the details component36.4.3 Creating the editor component36.5 Extending the Blazor form features36.5.1 Creating a custom validation constraint36.5.2 Creating a valid-only submit button componentSummary
37 Using Blazor WebAssembly
37.1 Preparing for this chapter37.1.1 Dropping the database and running the application37.2 Setting Up Blazor WebAssembly37.2.1 Creating the shared project37.2.2 Creating the Blazor WebAssembly project37.2.3 Preparing the ASP.NET Core project37.2.4 Adding the solution references37.2.5 Opening the projects37.2.6 Completing the Blazor WebAssembly configuration37.2.7 Testing the placeholder components37.3 Creating a Blazor WebAssembly component37.3.1 Importing the data model namespace37.3.2 Creating a component37.3.3 Creating a layout37.3.4 Defining CSS styles37.4 Completing the Blazor WebAssembly Form application37.4.1 Creating the details component37.4.2 Creating the editor componentSummary
38 Using ASP.NET Core Identity
38.1 Preparing for this chapter38.2 Preparing the project for ASP.NET Core Identity38.2.1 Preparing the ASP.NET Core Identity database38.2.2 Configuring the application38.2.3 Creating and applying the Identity database migration38.3 Creating user management tools38.3.1 Preparing for user management tools38.3.2 Enumerating user accounts38.3.3 Creating users38.3.4 Editing users38.3.5 Deleting users38.4 Creating role management tools38.4.1 Preparing for role management tools38.4.2 Enumerating and deleting roles38.4.3 Creating roles38.4.4 Assigning role membershipSummary
39 Applying ASP.NET Core Identity
39.1 Preparing for this chapter39.2 Authenticating users39.2.1 Creating the login feature39.2.2 Inspecting the ASP.NET Core Identity cookie39.2.3 Creating a Sign-Out page39.2.4 Testing the authentication feature39.2.5 Enabling the Identity authentication middleware39.3 Authorizing access to endpoints39.3.1 Applying the authorization attribute39.3.2 Enabling the authorization middleware39.3.3 Creating the access denied endpoint39.3.4 Creating the seed data39.3.5 Testing the authentication sequence39.4 Authorizing access to Blazor applications39.4.1 Performing authorization in Blazor components39.4.2 Displaying content to authorized users39.5 Authenticating and authorizing web services39.5.1 Building a simple JavaScript client39.5.2 Restricting access to the web service39.5.3 Using cookie authentication39.5.4 Using bearer token authentication39.5.5 Creating tokens39.5.6 Authenticating with tokens39.5.7 Restricting access with tokens39.5.8 Using tokens to request dataSummary
index

Content preview from Pro ASP.NET Core 7, Tenth Edition

14 Using dependency injection

This chapter covers

Understanding how dependency injection allows components to access shared services
Configuring services lifecycles to control when services are instantiated
Understanding how to define and access services using dependency injection

Services are objects that are shared between middleware components and endpoints. There are no restrictions on the features that services can provide, but they are usually used for tasks that are needed in multiple parts of the application, such as logging or database access.

The ASP.NET Core dependency injection feature is used to create and consume services. This topic causes confusion and can be difficult to understand. In this chapter, I describe the problems ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Architecting ASP.NET Core Applications - Third Edition

Publisher Resources

ISBN: 9781633437821Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Pro ASP.NET Core 7, Tenth Edition

by Adam Freeman

14 Using dependency injection

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.