1 PROJECT CONFIGURATION ......................................................
1.1 Creating a New Project ............................................................................ 1
1.2 launchSettings.json File Configuration ..................................................... 3
1.3 Program.cs Class Explanations ................................................................. 4
1.4 Extension Methods and CORS Configuration ............................................. 8
1.5 IIS Configuration ..................................................................................... 9
1.6 Additional Code in the Program Class ..................................................... 11
1.7 Environment-Based Settings .................................................................. 12
1.8 ASP.NET Core Middleware ...................................................................... 14
1.8.1 Creating a First Middleware Component ................................................. 17
1.8.2 Working with the Use Method ............................................................... 19
1.8.3 Using the Map and MapWhen Methods .................................................. 21
1.8.4 Using MapWhen Method ...................................................................... 22
2 CONFIGURING A LOGGING SERVICE ......................................24
2.1 Creating the Required Projects .............................................................. 24
2.2 Creating the ILoggerManager Interface and Installing NLog ................. 25
2.3 Implementing the Interface and Nlog.Config File ................................... 27
2.4 Configuring Logger Service for Logging Messages ................................. 28
2.5 DI, IoC, and Logger Service Testing ....................................................... 30
3 ONION ARCHITECTURE IMPLEMENTATION ............................ 32
3.1 About Onion Architecture ....................................................................... 33
3.1.1 Advantages of the Onion Architecture ................................................... 34
3.1.2 Flow of Dependencies.......................................................................... 34
3.2 Creating Models ..................................................................................... 35
3.3 Context Class and the Database Connection ........................................... 37
3.4 Migration and Initial Data Seed .............................................................. 40
3.5 Repository Pattern Logic ........................................................................ 43
3.6 Repository User Interfaces and Classes ................................................. 45
3.7 Creating a Repository Manager .............................................................. 46
3.8 Adding a Service Layer ........................................................................... 49
3.9 Registering RepositoryContext at a Runtime .......................................... 52
4 HANDLING GET REQUESTS ..................................................... 54
4.1 Controllers and Routing in WEB API ....................................................... 54
4.2 Naming Our Resources ........................................................................... 59
4.3 Getting All Companies From the Database ............................................. 59
4.4 Testing the Result with Postman ............................................................ 63
4.5 DTO Classes vs. Entity Model Classes ..................................................... 65
4.6 Using AutoMapper in ASP.NET Core ........................................................ 68
5 GLOBAL ERROR HANDLING .................................................... 72
5.1 Handling Errors Globally with the Built-In Middleware........................... 72
5.2 Program Class Modification .................................................................... 74
5.3 Testing the Result .................................................................................. 75
6 GETTING ADDITIONAL RESOURCES ....................................... 77
6.1 Getting a Single Resource From the Database ........................................ 77
6.1.1 Handling Invalid Requests in a Service Layer ......................................... 79
6.2 Parent/Child Relationships in Web API .................................................. 82
6.3 Getting a Single Employee for Company ................................................. 85
7 CONTENT NEGOTIATION ........................................................ 89
7.1 What Do We Get Out of the Box? ............................................................ 89
7.2 Changing the Default Configuration of Our Project ................................ 90
7.3 Testing Content Negotiation ................................................................... 91
7.4 Restricting Media Types ......................................................................... 93
7.5 More About Formatters .......................................................................... 94
7.6 Implementing a Custom Formatter ........................................................ 95
8 METHOD SAFETY AND METHOD IDEMPOTENCY ...................... 98
9 CREATING RESOURCES ........................................................ 100
9.1 Handling POST Requests ...................................................................... 100
9.2 Code Explanation ................................................................................. 103
9.2.1 Validation from the ApiController Attribute ........................................... 104
9.3 Creating a Child Resource .................................................................... 107
9.4 Creating Children Resources Together with a Parent ........................... 110
9.5 Creating a Collection of Resources ....................................................... 111
9.6 Model Binding in API ............................................................................ 117
10 WORKING WITH DELETE REQUESTS .................................. 121
10.1 Deleting a Parent Resource with its Children ....................................... 123
11 WORKING WITH PUT REQUESTS ....................................... 125
11.1 Updating Employee .............................................................................. 125
11.1.1 About the Update Method from the RepositoryBase Class .................... 129
11.2 Inserting Resources while Updating One ............................................. 129
12 WORKING WITH PATCH REQUESTS ................................... 132
12.1 Applying PATCH to the Employee Entity ............................................... 133
13 VALIDATION ..................................................................... 140
13.1 ModelState, Rerun Validation, and Built-in Attributes .......................... 140
13.1.1 Rerun Validation ............................................................................... 141
13.1.2 Built-in Attributes ............................................................................. 142
13.2 Custom Attributes and IValidatableObject ........................................... 143
13.3 Validation while Creating Resources .................................................... 145
13.3.1 Validating Int Type ........................................................................... 148
13.4 Validation for PUT Requests ................................................................. 149
13.5 Validation for PATCH Requests ............................................................. 151
14 ASYNCHRONOUS CODE ...................................................... 156
14.1 What is Asynchronous Programming? .................................................. 156
14.2 Async, Await Keywords, and Return Types ........................................... 158
14.2.1 Return Types of the Asynchronous Methods ......................................... 160
14.2.2 The IRepositoryBase Interface and the RepositoryBase Class Explanation 161
14.3 Modifying the ICompanyRepository Interface and the
CompanyRepository Class .............................................................................. 161
14.4 IRepositoryManager and RepositoryManager Changes ........................ 162
14.5 Updating the Service layer ................................................................... 163
14.6 Controller Modification ......................................................................... 165
14.7 Continuation in Asynchronous Programming ....................................... 168
14.8 Common Pitfalls ................................................................................... 169
15 ACTION FILTERS ............................................................... 171
15.1 Action Filters Implementation .............................................................. 171
15.2 The Scope of Action Filters ................................................................... 172
15.3 Order of Invocation .............................................................................. 173
15.4 Improving the Code with Action Filters ................................................ 175
15.5 Validation with Action Filters ............................................................... 175
15.6 Refactoring the Service Layer .............................................................. 178
16 PAGING ............................................................................. 183
16.1 What is Paging? ................................................................................... 183
16.2 Paging Implementation ........................................................................ 184
16.3 Concrete Query .................................................................................... 187
16.4 Improving the Solution ........................................................................ 189
16.4.1 Additional Advice .............................................................................. 192
17 FILTERING ........................................................................ 194
17.1 What is Filtering? ................................................................................. 194
17.2 How is Filtering Different from Searching? ........................................... 195
17.3 How to Implement Filtering in ASP.NET Core Web API ........................ 196
17.4 Sending and Testing a Query ................................................................ 198
18 SEARCHING ....................................................................... 201
18.1 What is Searching?............................................................................... 201
18.2 Implementing Searching in Our Application ......................................... 201
18.3 Testing Our Implementation ................................................................ 203
19 SORTING ........................................................................... 206
19.1 What is Sorting? ................................................................................... 206
19.2 How to Implement Sorting in ASP.NET Core Web API .......................... 208
19.3 Implementation – Step by Step ............................................................ 210
19.4 Testing Our Implementation ................................................................ 212
19.5 Improving the Sorting Functionality .................................................... 213
20 DATA SHAPING ................................................................. 215
20.1 What is Data Shaping? ......................................................................... 215
20.2 How to Implement Data Shaping ......................................................... 216
20.3 Step-by-Step Implementation .............................................................. 218
20.4 Resolving XML Serialization Problems .................................................. 223
21 SUPPORTING HATEOAS ..................................................... 226
21.1 What is HATEOAS and Why is it so Important?..................................... 226
21.1.1 Typical Response with HATEOAS Implemented ..................................... 227
21.1.2 What is a Link?................................................................................. 227
21.1.3 Pros/Cons of Implementing HATEOAS ................................................. 228
21.2 Adding Links in the Project .................................................................. 229
21.3 Additional Project Changes .................................................................. 231
21.4 Adding Custom Media Types ................................................................. 232
21.4.1 Registering Custom Media Types ........................................................ 233
21.4.2 Implementing a Media Type Validation Filter ........................................ 234
21.5 Implementing HATEOAS ....................................................................... 235
22 WORKING WITH OPTIONS AND HEAD REQUESTS.............. 243
22.1 OPTIONS HTTP Request ....................................................................... 243
22.2 OPTIONS Implementation .................................................................... 243
22.3 Head HTTP Request .............................................................................. 245
22.4 HEAD Implementation .......................................................................... 245
23 ROOT DOCUMENT .............................................................. 247
23.1 Root Document Implementation .......................................................... 247
24 VERSIONING APIS ............................................................ 252
24.1 Required Package Installation and Configuration ................................ 252
24.2 Versioning Examples ............................................................................ 253
24.2.1 Using Query String ........................................................................... 255
24.2.2 Using URL Versioning ........................................................................ 256
24.2.3 HTTP Header Versioning .................................................................... 257
24.2.4 Deprecating Versions ........................................................................ 258
24.2.5 Using Conventions ............................................................................ 259
25 CACHING ........................................................................... 260
25.1 About Caching ...................................................................................... 260
25.1.1 Cache Types .................................................................................... 260
25.1.2 Response Cache Attribute .................................................................. 261
25.2 Adding Cache Headers.......................................................................... 261
25.3 Adding Cache-Store .............................................................................. 263
25.4 Output Caching .................................................................................... 266
25.4.1 Differences Between Output and Response Caching .............................. 266
25.5 Using Output Caching In Our App ......................................................... 267
25.5.1 Using Policies With Output Caching ..................................................... 269
25.5.2 Output Cache Keys ........................................................................... 271
25.5.3 Caching Revalidation ......................................................................... 272
26 RATE LIMITING AND THROTTLING .................................... 276
26.1 Implementing Rate Limiting ................................................................. 277
26.1.1 Rejection Configuration ..................................................................... 278
26.1.2 Rate Limiter Queues ......................................................................... 279
26.1.3 Policies With Rate Limiting ................................................................. 280
27 JWT, IDENTITY, AND REFRESH TOKEN .............................. 283
27.1 Implementing Identity in ASP.NET Core Project ................................... 283
27.2 Creating Tables and Inserting Roles ..................................................... 286
27.3 User Creation ....................................................................................... 287
27.4 Big Picture ........................................................................................... 293
27.5 About JWT ............................................................................................ 293
27.6 JWT Configuration ................................................................................ 295
27.7 Protecting Endpoints ............................................................................ 297
27.8 Implementing Authentication .............................................................. 298
27.9 Role-Based Authorization ..................................................................... 303
28 REFRESH TOKEN ................................................................ 306
28.1 Why Do We Need a Refresh Token ....................................................... 308
28.2 Refresh Token Implementation ............................................................ 309
28.3 Token Controller Implementation ........................................................ 313
29 BINDING CONFIGURATION AND OPTIONS PATTERN......... 317
29.1 Binding Configuration .......................................................................... 318
29.2 Options Pattern .................................................................................... 320
29.2.1 Using IOptions ................................................................................. 321
29.2.2 IOptionsSnapshot and IOptionsMonitor................................................ 323
30 DOCUMENTING API WITH SWAGGER ................................ 326
30.1 About Swagger ..................................................................................... 326
30.2 Swagger Integration Into Our Project .................................................. 327
30.3 Adding Authorization Support .............................................................. 331
30.4 Extending Swagger Configuration ........................................................ 334
31 DEPLOYMENT TO IIS ......................................................... 338
31.1 Creating Publish Files ........................................................................... 338
31.2 Windows Server Hosting Bundle .......................................................... 340
31.3 Installing IIS........................................................................................ 341
31.4 Configuring Environment File ............................................................... 344
31.5 Testing Deployed Application ............................................................... 345
32 BONUS 1 - RESPONSE PERFORMANCE IMPROVEMENTS ..... 349
32.1 Adding Response Classes to the Project ............................................... 349
32.2 Service Layer Modification ................................................................... 351
32.3 Controller Modification ......................................................................... 353
32.4 Testing the API Response Flow ............................................................ 355
33 BONUS 2 - INTRODUCTION TO CQRS AND MEDIATR WITH
ASP.NET CORE WEB API ............................................................ 358
33.1 About CQRS and Mediator Pattern ........................................................ 358
33.1.1 CQRS .............................................................................................. 358
33.1.2 Advantages and Disadvantages of CQRS ............................................. 360
33.1.3 Mediator Pattern ............................................................................... 361
33.2 How MediatR facilitates CQRS and Mediator Patterns .......................... 362
33.3 Adding Application Project and Initial Configuration ............................ 362
33.4 Requests with MediatR ......................................................................... 365
33.5 Commands with MediatR ...................................................................... 371
33.5.1 Update Command ............................................................................. 373
33.5.2 Delete Command .............................................................................. 375
33.6 MediatR Notifications ........................................................................... 376
33.7 MediatR Behaviors ............................................................................... 379
33.7.1 Adding Fluent Validation .................................................................... 380
33.7.2 Creating Decorators with MediatR PipelineBehavior ............................... 381
33.7.3 Validating null Object ........................................................................ 386
