ASP.NET Core in Action, Second Edition, Video Edition

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