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

Video description

One of the greatest and most complete books about ASP.NET Core!
Delcoigne Vincent, Wavenet

Fully updated to ASP.NET 5.0, ASP.NET Core in Action, Second Edition is a hands-on primer to building cross-platform web applications with your C# and .NET skills. Even if you've never worked with ASP.NET you'll start creating productive cross-platform web apps fast.

about the technology

Build full-stack web applications that run anywhere. Developers love ASP.NET Core for its libraries and pre-built components that maximize productivity. Version 5.0 offers new features for server-side apps, as well as background services for cross-platform development.

about the book

ASP.NET Core in Action, Second Edition is a comprehensive guide to creating web applications with ASP.NET Core 5.0. Go from basic HTTP concepts to advanced framework customization. Illustrations and annotated code make learning visual and easy. Master logins, dependency injection, security, and more. This updated edition covers the latest features, including Razor Pages and the new hosting paradigm.

what's inside

  • Developing apps for Windows and non-Windows servers
  • Configuring applications
  • Building custom components
  • Logging, testing, and security

about the audience

For intermediate C# developers.

about the author

Andrew Lock is a Microsoft MVP who has worked with ASP.NET Core since before its first release.

The most comprehensive ASP.NET Core book on the market. It covers just about everything you need to learn to quickly become productive in the often confusing and fast-changing world of .NET Core.
Filip Wojcieszyn, Sonova AG

Fantastic book. The topics are explained clearly and thoroughly.
Luis Moux, EMO

A comprehensive reference for ASP.NET Core.
Jean-François Morin, Laval University

NARRATED BY JULIE BRIERLEY

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

Product information

  • Title: ASP.NET Core in Action, Second Edition, video edition
  • Author(s): Andrew Lock
  • Release date: March 2021
  • Publisher(s): Manning Publications
  • ISBN: None