ASP.NET Core in Action, Second Edition, video edition

Table of contents

1. Part 1. Getting started with ASP.NET Core
2. Chapter 1. Getting started with ASP.NET Core
3. Chapter 1. What is ASP.NET Core?
4. Chapter 1. If you’re new to .NET development
5. Chapter 1. If you’re a .NET Framework developer creating a new application
6. Chapter 1. Converting an existing ASP.NET application to ASP.NET Core
7. Chapter 1. How does ASP.NET Core process a request?
8. Chapter 2. Your first application
9. Chapter 2. Creating your first ASP.NET Core application
10. Chapter 2. Running the web application
11. Chapter 2. The .csproj project file: Defining your dependencies
12. Chapter 2. The Startup class: Configuring your application
13. Chapter 2. Defining how requests are handled with middleware
14. Chapter 2. Handling request logic with PageModels and handlers
15. Chapter 3. Handling requests with the middleware pipeline
16. Chapter 3. Combining middleware in a pipeline
17. Chapter 3. Simple pipeline scenario 2: Handling static files
18. Chapter 3. Handling errors using middleware
19. Chapter 3. Handling other errors: StatusCodePagesMiddleware
20. Chapter 4. Creating a website with Razor Pages
21. Chapter 4. The MVC design pattern
22. Chapter 4. Applying the MVC design pattern to Razor Pages
23. Chapter 4. Applying the MVC design pattern to Razor Pages
24. Chapter 4. Razor Pages vs. MVC in ASP.NET Core
25. Chapter 4. When to choose MVC controllers over Razor Pages
26. Chapter 4. Returning responses with ActionResults
27. Chapter 5. Mapping URLs to Razor Pages using routing
28. Chapter 5. Routing in ASP.NET Core
29. Chapter 5. Convention-based routing vs. attribute routing
30. Chapter 5. Customizing Razor Page route templates
31. Chapter 5. Exploring the route template syntax
32. Chapter 5. Generating URLs from route parameters
33. Chapter 5. Generating URLs from other parts of your application
34. Chapter 5. Customizing conventions with Razor Pages
35. Chapter 6. The binding model: Retrieving and validating user input
36. Chapter 6. From request to model: Making the request useful
37. Chapter 6. Binding simple types
38. Chapter 6. Binding complex types
39. Chapter 6. Choosing a binding source
40. Chapter 6. Using DataAnnotations attributes for validation
41. Chapter 6. Validating on the client for user experience
42. Chapter 7. Rendering HTML using Razor views
43. Chapter 7. Creating Razor views
44. Chapter 7. Creating dynamic web pages with Razor
45. Chapter 7. Layouts, partial views, and _ViewStart
46. Chapter 7. Using partial views to encapsulate markup
47. Chapter 7. Selecting a view from an MVC controller
48. Chapter 8. Building forms with Tag Helpers
49. Chapter 8. Creating forms using Tag Helpers
50. Chapter 8. The Label Tag Helper
51. Chapter 8. The Select Tag Helper
52. Chapter 8. Generating links with the Anchor Tag Helper
53. Chapter 8. Using conditional markup with the Environment Tag Helper
54. Chapter 9. Creating a Web API for mobile and client applications using MVC
55. Chapter 9. Creating your first Web API project
56. Chapter 9. Applying the MVC design pattern to a Web API
57. Chapter 9. Attribute routing: Linking action methods to URLs
58. Chapter 9. Using common conventions with the [ApiController] attribute
59. Chapter 9. Generating a response from a model
60. Chapter 9. Choosing a response format with content negotiation
61. Part 2. Building complete applications
62. Chapter 10. Service configuration with dependency injection
63. Chapter 10. Understanding the benefits of dependency injection
64. Chapter 10. Creating loosely coupled code
65. Vhapter 10. Using the dependency injection container
66. Chapter 10. Registering services using objects and lambdas
67. Chapter 10. Injecting services into action methods, page handlers, and views
68. Chapter 10. Understanding lifetimes: When are services created?
69. Chapter 10. Singleton: There can be only one
70. Chapter 11. Configuring an ASP.NET Core application
71. Chapter 11. Building a configuration object for your app
72. Chapter 11. Using multiple providers to override configuration values
73. Chapter 11. Storing configuration secrets safely
74. Chapter 11. Using strongly typed settings with the options pattern
75. Chapter 11. Reloading strongly typed options with IOptionsSnapshot
76. Chapter 11. Configuring an application for multiple environments
77. Chapter 11. Setting the hosting environment
78. Chapter 12. Saving data with Entity Framework Core
79. Chapter 12. When should you choose EF Core?
80. Chapter 12. Adding EF Core to an application
81. Chapter 12. Managing changes with migrations
82. Chapter 12. Querying data from and saving data to the database
83. Chapter 12. Loading a single record
84. Chapter 12. Using EF Core in production applications
85. Chapter 13. The MVC and Razor Pages filter pipeline
86. Chapter 13. The Razor Pages filter pipeline
87. Chapter 13. Adding filters to your actions, controllers, Razor Pages, and globally
88. Chapter 13. Creating custom filters for your application
89. Chapter 13. Action filters: Customizing model binding and action results
90. Chapter 13. Exception filters: Custom exception handling for your action methods
91. Chapter 13. Page filters: Customizing model binding for Razor Pages
92. Chapter 13. Using dependency injection with filter attributes
93. Chapter 14. Authentication: Adding users to your application with Identity
94. Chapter 14. Authentication in ASP.NET Core: Services and middleware
95. Chapter 14. Authentication for APIs and distributed applications
96. Chapter 14. What is ASP.NET Core Identity?
97. Chapter 14. Creating a project that uses ASP.NET Core Identity
98. Chapter 14. The ASP.NET Core Identity data model
99. Chapter 14. Adding ASP.NET Core Identity to an existing project
100. Chapter 14. Customizing a page in ASP.NET Core Identity’s default UI
101. Chapter 14. Managing users: Adding custom data to users
102. Chapter 15. Authorization: Securing your application
103. Chapter 15. Authorization in ASP.NET Core
104. Chapter 15. Handling unauthorized requests
105. Chapter 15. Creating custom policies for authorization
106. Chapter 15. Controlling access with resource-based authorization
107. Chapter 15. Hiding elements in Razor templates from unauthorized users
108. Chapter 16. Publishing and deploying your application
109. Chapter 16. Running vs. publishing an ASP.NET Core app
110. Chapter 16. Publishing your app to IIS
111. Chapter 16. Hosting an application on Linux
112. Chapter 16. Preparing your app for deployment to Linux
113. Chapter 16. Configuring the URLs for your application
114. Chapter 16. Optimizing your client-side assets using BundlerMinifier
115. Chapter 16. Adding BundlerMinifier to your application
116. Chapter 16. Serving common files from a CDN
117. Part 3. Extending your applications
118. Chapter 17. Monitoring and troubleshooting errors with logging This chapter covers
119. Chapter 17. Adding log messages to your application
120. Chapter 17. Log category: Which component created the log
121. Chapter 17. Adding a new logging provider to your application
122. Chapter 17. Changing log verbosity with filtering
123. Chapter 17. Structured logging: Creating searchable, useful logs
124. Chapter 17. Using scopes to add additional properties to your logs
125. Chapter 18. Improving your application’s security
126. Chapter 18. Using the ASP.NET Core HTTPS development certificates
127. Chapter 18. Enforcing HTTPS for your whole app
128. Chapter 18. Defending against cross-site scripting (XSS) attacks
129. Chapter 18. Protecting from cross-site request forgery (CSRF) attacks
130. Chapter 18. Protecting from cross-site request forgery (CSRF) attacks
131. Chapter 18. Adding CORS to specific Web API actions with EnableCorsAttribute
132. Chapter 18. Avoiding SQL injection attacks with EF Core and parameterization
133. Chapter 18. Protecting your users’ passwords and data
134. Chapter 19. Using a third-party dependency injection container
135. Chapter 19. Building custom components
136. Chapter 19. Branching middleware pipelines with the Map extension
137. Chapter 19. Building a custom middleware component
138. Chapter 19. Creating simple endpoints with MapGet and WriteJsonAsync
139. Chapter 19. Handling complex configuration requirements
140. Chapter 20. Building custom MVC and Razor Pages components
141. Chapter 20. Creating a custom Tag Helper to conditionally hide elements
142. Chapter 20. View components: Adding logic to partial views
143. Chapter 20. Building a custom validation attribute
144. Chapter 20. Replacing the validation framework with FluentValidation
145. Chapter 20. Adding FluentValidation to your application
146. Chapter 21. Calling remote APIs with IHttpClientFactory
147. Chapter 21. Creating HttpClients with IHttpClientFactory
148. Chapter 21. Configuring named clients at registration time
149. Chapter 21. Creating a custom HttpMessageHandler
150. Chapter 22. Building background tasks and services
151. Chapter 22. Creating headless worker services using IHost
152. Chapter 22. Coordinating background tasks using Quartz.NET
153. Chapter 22. Using clustering to add redundancy to your background tasks
154. Chapter 23. Testing your application
155. Chapter 23. Unit testing with xUnit
156. Chapter 23. Adding Fact and Theory unit tests
157. Chapter 23. Unit testing custom middleware
158. Chapter 23. Integration testing: Testing your whole app in-memory
159. Chapter 23. Replacing dependencies in WebApplicationFactory
160. Chapter 23. Isolating the database with an in-memory EF Core provider
161. Appendix A. Preparing your development environment
162. Appendix B. Sharing code between projects
163. Appendix B. Understanding the .NET ecosystem
164. Appendix B. NET 5.0: The first step in the One .NET vision
165. Appendix B. Fudging .NET Standard 2.0 support with the compatibility shim