فهرست مطالب

• inside front cover
• ASP.NET Core in Action
• Copyright
• Praise for the Second Edition
• contents
• front matter
• Chapter 1. Getting started with ASP.NET Core
• 1.1 What is ASP.NET Core?
• 1.2 What types of applications can you build?
• 1.3 Choosing ASP.NET Core
• 1.4 How does ASP.NET Core work?
• 1.5 What you’ll learn in this book
• Summary
• Part 1. Getting started with minimal APIs
• Chapter 2. Understanding ASP.NET Core
• 2.1 Using a web framework
• 2.2 Why ASP.NET Core was created
• 2.3 Understanding the many paradigms of ASP.NET Core
• 2.4 When to choose ASP.NET Core
• Summary
• Chapter 3. Your first application
• 3.1 A brief overview of an ASP.NET Core application
• 3.2 Creating your first ASP.NET Core application
• 3.3 Running the web application
• 3.4 Understanding the project layout
• 3.5 The .csproj project file: Declaring your dependencies
• 3.6 Program.cs file: Defining your application
• 3.7 Adding functionality to your application
• Summary
• Chapter 4. Handling requests with the middleware pipeline
• 4.1 Defining middleware
• 4.2 Combining middleware in a pipeline
• 4.3 Handling errors using middleware
• Summary
• Chapter 5. Creating a JSON API with minimal APIs
• 5.1 What is an HTTP API, and when should you use one?
• 5.2 Defining minimal API endpoints
• 5.3 Generating responses with IResult
• 5.4 Running common code with endpoint filters
• 5.5 Organizing your APIs with route groups
• Summary
• Chapter 6. Mapping URLs to endpoints using routing
• 6.1 What is routing?
• 6.2 Endpoint routing in ASP.NET Core
• 6.3 Exploring the route template syntax
• 6.4 Generating URLs from route parameters
• Summary
• Chapter 7. Model binding and validation in minimal APIs
• 7.1 Extracting values from a request with model binding
• 7.2 Binding simple types to a request
• 7.3 Binding complex types to the JSON body
• 7.4 Arrays: Simple types or complex types?
• 7.5 Making parameters optional with nullables
• 7.6 Binding services and special types
• 7.7 Custom binding with BindAsync
• 7.8 Choosing a binding source
• 7.9 Simplifying handlers with AsParameters
• 7.10 Handling user input with model validation
• Summary
• Part 2. Building complete applications
• Chapter 8. An introduction to dependency injection
• 8.1 Understanding the benefits of dependency injection
• 8.2 Creating loosely coupled code
• 8.3 Using dependency injection in ASP.NET Core
• 8.4 Adding ASP.NET Core framework services to the container
• 8.5 Using services from the DI container
• Summary
• Chapter 9. Registering services with dependency injection
• 9.1 Registering custom services with the DI container
• 9.2 Registering services using objects and lambdas
• 9.3 Registering a service in the container multiple times
• 9.4 Understanding lifetimes: When are services created?
• 9.5 Resolving scoped services outside a request
• Summary
• Chapter 10. Configuring an ASP.NET Core application
• 10.1 Introducing the ASP.NET Core configuration model
• 10.2 Building a configuration object for your app
• 10.3 Using strongly typed settings with the options pattern
• 10.4 Configuring an application for multiple environments
• Summary
• Chapter 11. Documenting APIs with OpenAPI
• 11.1 Adding an OpenAPI description to your app
• 11.2 Testing your APIs with Swagger UI
• 11.3 Adding metadata to your minimal APIs
• 11.4 Generating strongly typed clients with NSwag
• 11.5 Adding descriptions and summaries to your endpoints
• 11.6 Knowing the limitations of OpenAPI
• Summary
• Chapter 12. Saving data with Entity Framework Core
• 12.1 Introducing Entity Framework Core
• 12.2 Adding EF Core to an application
• 12.3 Managing changes with migrations
• 12.4 Querying data from and saving data to the database
• 12.5 Using EF Core in production applications
• Summary
• Part 3. Generating HTML with Razor Pages and MVC
• Chapter 13. Creating a website with Razor Pages
• 13.1 Your first Razor Pages application
• 13.2 Exploring a typical Razor Page
• 13.3 Understanding the MVC design pattern
• 13.4 Applying the MVC design pattern to Razor Pages
• Summary
• Chapter 14. Mapping URLs to Razor Pages using routing
• 14.1 Routing in ASP.NET Core
• 14.2 Convention-based routing vs. explicit routing
• 14.3 Routing requests to Razor Pages
• 14.4 Customizing Razor Page route templates
• 14.5 Generating URLs for Razor Pages
• 14.6 Customizing conventions with Razor Pages
• Summary
• Chapter 15. Generating responses with page handlers in Razor Pages
• 15.1 Razor Pages and page handlers
• 15.2 Selecting a page handler to invoke
• 15.3 Accepting parameters to page handlers
• 15.4 Returning IActionResult responses
• 15.5 Handler status codes with StatusCodePagesMiddleware
• Summary
• Chapter 16. Binding and validating requests with Razor Pages
• 16.1 Understanding the models in Razor Pages and MVC
• 16.2 From request to binding model: Making the request useful
• 16.3 Validating binding models
• 16.4 Organizing your binding models in Razor Pages
• Summary
• Chapter 17. Rendering HTML using Razor views
• 17.1 Views: Rendering the user interface
• 17.2 Creating Razor views
• 17.3 Creating dynamic web pages with Razor
• 17.4 Layouts, partial views, and _ViewStart
• Summary
• Chapter 18. Building forms with Tag Helpers
• 18.1 Catering to editors with Tag Helpers
• 18.2 Creating forms using Tag Helpers
• 18.3 Generating links with the Anchor Tag Helper
• 18.4 Cache-busting with the Append Version Tag Helper
• 18.5 Using conditional markup with the Environment Tag Helper
• Summary
• Chapter 19. Creating a website with MVC controllers
• 19.1 Razor Pages vs. MVC in ASP.NET Core
• 19.2 Your first MVC web application
• 19.3 Comparing an MVC controller with a Razor Page PageModel
• 19.4 Selecting a view from an MVC controller
• 19.5 Choosing between Razor Pages and MVC controllers
• Summary
• Chapter 20. Creating an HTTP API using web API controllers
• 20.1 Creating your first web API project
• 20.2 Applying the MVC design pattern to a web API
• 20.3 Attribute routing: Linking action methods to URLs
• 20.4 Using common conventions with [ApiController]
• 20.5 Generating a response from a model
• 20.6 Choosing between web API controllers and minimal APIs
• Summary
• Chapter 21. The MVC and Razor Pages filter pipeline
• 21.1 Understanding the MVC filter pipeline
• 21.2 The Razor Pages filter pipeline
• 21.3 Filters or middleware: Which should you choose?
• 21.4 Creating a simple filter
• 21.5 Adding filters to your actions and Razor Pages
• 21.6 Understanding the order of filter execution
• Summary
• Chapter 22. Creating custom MVC and Razor Page filters
• 22.1 Creating custom filters for your application
• 22.2 Understanding pipeline short-circuiting
• 22.3 Using dependency injection with filter attributes
• Summary
• Part 4. Securing and deploying your applications
• Chapter 23. Authentication: Adding users to your application with Identity
• 23.1 Introducing authentication and authorization
• 23.2 What is ASP.NET Core Identity?
• 23.3 Creating a project that uses ASP.NET Core Identity
• 23.4 Adding ASP.NET Core Identity to an existing project
• 23.5 Customizing a page in ASP.NET Core Identity’s default UI
• 23.6 Managing users: Adding custom data to users
• Summary
• Chapter 24. Authorization: Securing your application
• 24.1 Introduction to authorization
• 24.2 Authorization in ASP.NET Core
• 24.3 Using policies for claims-based authorization
• 24.4 Creating custom policies for authorization
• 24.5 Controlling access with resource-based authorization
• 24.6 Hiding HTML elements from unauthorized users
• Summary
• Chapter 25. Authentication and authorization for APIs
• 25.1 Authentication for APIs and distributed applications
• 25.2 Understanding bearer token authentication
• 25.3 Adding JWT bearer authentication to minimal APIs
• 25.4 Using the user-jwts tool for local JWT testing
• 25.5 Describing your authentication requirements to OpenAPI
• 25.6 Applying authorization policies to minimal API endpoints
• Summary
• Chapter 26. Monitoring and troubleshooting errors with logging
• 26.1 Using logging effectively in a production app
• 26.2 Adding log messages to your application
• 26.3 Controlling where logs are written using logging providers
• 26.4 Changing log verbosity with filtering
• 26.5 Structured logging: Creating searchable, useful logs
• Summary
• Chapter 27. Publishing and deploying your application
• 27.1 Understanding the ASP.NET Core hosting model
• 27.2 Publishing your app to IIS
• 27.3 Hosting an application in Linux
• 27.4 Configuring the URLs for your application
• Summary
• Chapter 28. Adding HTTPS to an application
• 28.1 Why do I need HTTPS?
• 28.2 Using the ASP.NET Core HTTPS development certificates
• 28.3 Configuring Kestrel with a production HTTPS certificate
• 28.4 Enforcing HTTPS for your whole app
• Summary
• Chapter 29. Improving your application’s security
• 29.1 Defending against cross-site scripting (XSS) attacks
• 29.2 Protecting from cross-site request forgery (CSRF) attacks
• 29.3 Calling your web APIs from other domains using CORS
• 29.4 Exploring other attack vectors
• Summary
• Part 5. Going further with ASP.NET Core
• Chapter 30. Building ASP.NET Core apps with the generic host and Startup
• 30.1 Separating concerns between two files
• 30.2 The Program class: Building a Web Host
• 30.3 The Startup class: Configuring your application
• 30.4 Creating a custom IHostBuilder
• 30.5 Understanding the complexity of the generic host
• 30.6 Choosing between the generic host and minimal hosting
• Summary
• Chapter 31. Advanced configuration of ASP.NET Core
• 31.1 Customizing your middleware pipeline
• 31.2 Using DI with OptionsBuilder and IConfigureOptions
• 31.3 Using a third-party dependency injection container
• Summary
• Chapter 32. Building custom MVC and Razor Pages components
• 32.1 Creating a custom Razor Tag Helper
• 32.2 View components: Adding logic to partial views
• 32.3 Building a custom validation attribute
• 32.4 Replacing the validation framework with FluentValidation
• Summary
• Chapter 33. Calling remote APIs with IHttpClientFactory
• 33.1 Calling HTTP APIs: The problem with HttpClient
• 33.2 Creating HttpClients with IHttpClientFactory
• 33.3 Handling transient HTTP errors with Polly
• 33.4 Creating a custom HttpMessageHandler
• Summary
• Chapter 34. Building background tasks and services
• 34.1 Running background tasks with IHostedService
• 34.2 Creating headless worker services using IHost
• 34.3 Coordinating background tasks using Quartz.NET
• Summary
• Chapter 35. Testing applications with xUnit
• 35.1 An introduction to testing in ASP.NET Core
• 35.2 Creating your first test project with xUnit
• 35.3 Running tests with dotnet test
• 35.4 Referencing your app from your test project
• 35.5 Adding Fact and Theory unit tests
• 35.6 Testing failure conditions
• Summary
• Chapter 36. Testing ASP.NET Core applications
• 36.1 Unit testing custom middleware
• 36.2 Unit testing API controllers and minimal API endpoints
• 36.3 Integration testing: Testing your whole app in-memory
• 36.4 Isolating the database with an in-memory EF Core provider
• Summary
• Appendix A. Preparing your development environment
• Appendix B. Useful references
• Index
• Inside back cover