Xiaodi Yan / Сяоди Ян - Web API Development with ASP.NET Core 8 / Разработка веб-API с использованием ASP.NET Core 8 [2024, PDF, EPUB, ENG]

Примеры страниц (скриншоты)

Оглавление

Preface xv
1
Fundamentals of Web APIs 1
What is a web API? 1
What is a REST API? 2
The constraints of REST 3
A REST API example 4
Is my web API RESTful? 5
Designing a REST-based API 6
Identifying the resources 7
Defining the relationships between resources 7
Identifying operations 8
Designing the URL paths for resources 9
Mapping API operations to HTTP methods 12
Assigning response codes 14
Documenting the API 16
RPC and GraphQL APIs 20
What is an RPC-based API? 20
What is a GraphQL API? 25
Real-time APIs 28
The problem with API polling 29
What is a real-time API? 30
Which real-time communication technology is best for your application? 33
Summary 34
2
Getting Started with ASP.NET Core Web APIs 35
Technical requirements 35
Setting up the development environment 36
Configuring VS Code 37
Checking the .NET SDK 38
Creating a simple REST web API project 39
Building and running the project 41
Building the project 42
Running the project 43
Changing the port number 45
Hot Reload 46
Testing the API endpoint 46
Swagger UI 46
Debugging 53
Understanding the MVC pattern 57
The model and the controller 57
Creating a new model and controller 59
Creating a service 62
Implementing a GET operation 64
Implementing a CREATE operation 65
Implementing an UPDATE operation 67
Dependency injection 68
Understanding DI 69
DI in ASP.NET Core 70
DI tips 84
Introduction to minimal APIs 85
Creating a simple endpoint 86
Using DI in minimal APIs 87
What is the difference between minimal APIs and controller-based APIs? 89
Summary 89
3
ASP.NET Core Fundamentals (Part 1) 91
Technical requirements 91
Routing 92
What is attribute routing? 92
Mapping HTTP methods to action methods 94
Route constraints 95
Binding source attributes 97
Configuration 99
Using appsettings.json 100
Using the options pattern 102
Other configuration providers 110
Environments 114
Understanding the launchSettings.json file 116
Setting the environment 118
Understanding the priorities of configuration and environment variables 122
Checking the environment in the code 123
Summary 125
4
ASP.NET Core Fundamentals (Part 2) 127
Technical requirements 128
Logging 128
Using built-in logging providers 128
Logging levels 132
Logging parameters 134
Using third-party logging providers 136
Structured logging 138
What should/shouldn’t we log? 143
Middleware 144
What is middleware? 144
Built-in middleware 154
Creating a custom middleware component 159
Summary 162
5
Data Access in ASP.NET Core (Part 1: Entity Framework Core Fundamentals) 163
Technical requirements 164
Why use ORM? 164
Configuring the DbContext class 166
Creating models 166
Creating and configuring the DbContext class 168
Creating the database 170
Adding seed data 173
Implementing CRUD controllers 173
Creating the controller 174
How controllers work 177
Basic LINQ queries 178
Querying the data 179
Filtering the data 181
Sorting and paging 182
Creating an entity 184
Updating an entity 185
Deleting an entity 190
Configuring the mapping between models and database 192
Mapping conventions 192
Data annotations 193
Fluent API 195
Separating the mapping configurations 198
Summary 200
6
Data Access in ASP.NET Core (Part 2 – Entity Relationships) 201
Technical requirements 202
Understanding one-to-many relationships 202
One-to-many configuration 202
One-to-many CRUD operations 207
Understanding one-to-one relationships 219
One-to-one configuration 219
One-to-one CRUD operations 222
Understanding many-to-many relationships 223
Many-to-many configuration 223
Many-to-many CRUD operations 228
Understanding owned entities 233
Summary 235
7
Data Access in ASP.NET Core (Part 3: Tips) 237
Technical requirements 238 Understanding DbContext pooling 238
Understanding the difference between tracking versus no-tracking queries 241
Understanding the difference between IQueryable and IEnumerable 245
Client evaluation versus server evaluation 248
Using raw SQL queries 251
FromSql() and FromSqlRaw() 252
SqlQuery() and SqlQueryRaw() 254
ExecuteSql() and ExecuteSqlRaw() 255
Using bulk operations 256
ExecuteUpdate() 256
ExecuteDelete() 257
Understanding concurrency conflicts 258
Native database-generated concurrency token 261
Application-managed concurrency token 263
Handling concurrency conflicts 264
Reverse engineering 265
Other ORM frameworks 268
Summary 269
8
Security and Identity in ASP.NET Core 271
Technical requirements 272
Getting started with authentication and authorization 272
Creating a sample project with authentication and authorization 273
Understanding the JWT token structure 285
Consuming the API 286
Configuring the Swagger UI to support authorization 288
Delving deeper into authorization 290
Role-based authorization 290
Claim-based authorization 295
Understanding the authorization process 300
Policy-based authorization 306
Managing users and roles 312
New Identity API endpoints in ASP.NET Core 8 313
Understanding OAuth 2.0 and OpenID Connect 316
What is OAuth 2.0? 316
What is OpenID Connect? 320
Integrating with other identity providers 322
Other security topics 323
Always use Hypertext Transfer Protocol Secure (HTTPS) 323
Using a strong password policy 324
Implementing two-factor
authentication (2FA) 326
Implementing rate-limiting 327
Using model validation 327
Using parameterized queries 330
Using data protection 330
Keeping secrets safe 330
Keeping the framework up to date 331
Checking the Open Web Application Security Project (OWASP) Top 10 331
Summary 331
9
Testing in ASP.NET Core (Part 1 – Unit Testing) 333
Technical requirements 333
Introduction to testing in ASP.NET Core 334
Writing unit tests 335
Preparing the sample application 335
Setting up the unit tests project 337
Writing unit tests without dependencies 339
Writing unit tests with dependencies 342
Using FluentAssertions to verify the test results 347
Testing the database access layer 351
How can we test the database access layer? 351
Creating a test fixture 353
Using the test fixture 355
Writing tests for methods that change the database 357
Parallelism of xUnit 362
Using the repository pattern 365
Testing the happy path and the sad path 370
Summary 372
10
Testing in ASP.NET Core (Part 2 – Integration Testing) 373
Technical requirements 373
Writing integration tests 373
Setting up the integration test project 374
Writing basic integration tests with WebApplicationFactory 375
Testing with a database context 377
Testing with mock services 383
Testing with authentication and authorization 385
Preparing the sample application 385
Creating a test fixture 386
Creating the test class 386
Testing the anonymous API endpoints 387
Testing the authorized API endpoints 388
Code coverage 398
Using data collectors 399
Generating a code coverage report 401
Summary 405
11
Getting Started with gRPC 407
Technical requirements 407
Recap of gRPC 408
Setting up a gRPC project 408
Creating a new gRPC project 408
Understanding the gRPC project structure 409
Creating protobuf messages 415
Defining a protobuf message 416
Understanding field numbers 418
Understanding the field types 419
Other .NET types 422
Creating a protobuf service 430
Defining a unary service 431
Creating a gRPC client 433
Defining a server streaming service 437
Defining a client streaming service 440
Defining a bidirectional streaming service 443
Consuming gRPC services in ASP.NET Core applications 447
Updating proto files 449
Summary 451
Further reading 452
12
Getting Started with GraphQL 453
Technical requirements 454
Recap of GraphQL 454
Setting up a GraphQL API using HotChocolate 455
Adding mutations 459
Using variables in queries 462
Defining a GraphQL schema 463
Scalar types 463
Object types 465
Retrieving related objects using resolvers 467
Field resolvers 469
Resolver for a list of objects 472
Using data loaders 477
Batch data loader 480
Group data loader 482
Dependency injection 484
Using the Service attribute 485
Understanding the lifetime of the injected services 486
Interface and union types 487
Interfaces 488
Union types 493
Filtering, sorting, and pagination 500
Filtering 500
Sorting 511
Pagination 515
Visualizing the GraphQL schema 524
Summary 526
Further reading 526
13
Getting Started with SignalR 527
Technical requirements 527
Recap of real-time web APIs 528
Setting up SignalR 528
Building SignalR clients 531
Building a TypeScript client 531
Building a Blazor client 539
Using authentication and
authorization in SignalR 543
Adding authentication and authorization to the SignalR server 544
Adding a login endpoint 547
Authenticating the TypeScript client 548
Authenticating the Blazor client 551
Managing users and groups 553
Managing events in SignalR 553
Sending a message to a specific user 555
Using strongly typed hubs 557
Joining groups 559
Sending a message to a group 561
Sending messages from other services 563
Configuring SignalR hubs and clients 565
Configuring SignalR hubs 565
HTTP configuration options 567
Automatically reconnecting 568
Scaling SignalR 573
Summary 574
14
CI/CD for ASP.NET Core Using Azure Pipelines and GitHub Actions 575
Technical requirements 576
Introduction to CI/CD 576
CI/CD concepts and terminologies 578
Understanding the importance of CI/CD 579
Containerizing ASP.NET Core applications using Docker 580
What is containerization? 580
Installing Docker 581
Understanding Dockerfiles 583
Building a Docker image 587
Running a Docker container 589
CI/CD using Azure DevOps and Azure Pipelines 593
Preparing the source code 593
Creating Azure resources 594
Creating an Azure DevOps project 595
Creating a pull request pipeline 597
Publishing the Docker image to ACR 605
Deploying the application to Azure Web App
for Containers 611
Configuring settings and secrets 615
GitHub Actions 615
Preparing the project 615
Creating GitHub Actions 616
Pushing a Docker image to ACR 620
Summary 622
15
ASP.NET Core Web API Common Practices 623
Technical requirements 623
Common practices of ASP.NET web
API development 624
Using HTTPS instead of HTTP 624
Using HTTP status codes correctly 624
Using asynchronous programming 626
Using pagination for large collections 629
Specifying the response types 632
Adding comments to the endpoints 634
Using System.Text.Json instead of Newtonsoft.Json 637
Optimizing the performance by
implementing caching 638
In-memory caching 639
Distributed caching 645
Response caching 651
Output caching 652
What caching strategy should I use? 655
Using HttpClientFactory to manage HttpClient instances 655
Creating a basic HttpClient instance 656
Named HttpClient instances 660
Typed HttpClient instances 660
Summary 662
16
Error Handling, Monitoring, and Observability 663
Technical requirements 663
Error handling 663
Handling exceptions 664
Health checks 673
Implementing a basic health check 674
Monitoring and observability 680
What is observability? 681
Summary 715
17
Cloud-Native Patterns 717
Technical requirements 717
Domain-driven design 718
Ubiquitous language 718
Bounded context 719
DDD layers 719
Clean architecture 728
Microservices 729
Web API design patterns 732
CQRS 732
Summary 760
Further reading 760
Index 761
Other Books You May Enjoy 778