book

Mastering ASP.NET Core 10: Web Applications Made Easy with the Biggest Update Yet

Name: Mastering ASP.NET Core 10: Web Applications Made Easy with the Biggest Update Yet
Author: Mabrouk Mahdhi
ISBN: 9798868818929

by Mabrouk Mahdhi

November 2025

Intermediate to advanced

891 pages

18h 17m

English

Apress

Read now

Unlock full access

Mastering ASP.NET Core 10
Introduction
Who This Book Is ForHow This Book Is OrganizedWhat You Will Gain
Acknowledgments
Table of Contents
About the Author
About the Technical Reviewer
Part I: Foundations of ASP.NET Core 10
1. Welcome to ASP.NET Core 10
1.1 The Evolution of ASP.NET Core1.2 Why Choose ASP.NET Core 10?1.2.1 Cross-Platform Development1.2.2 High Performance and Scalability1.2.3 Security-First Approach1.2.4 Cloud-Native and Microservices Ready1.2.5 Blazor: The Future of Web UI Development1.2.6 A Unified Development Platform1.3 What’s New in ASP.NET Core 10?1.3.1 Blazor Enhancements1.3.2 OpenAPI 3.1 Support1.3.3 Minimal APIs Enhancements1.3.4 SignalR Updates1.4 Summary
2. Setting Up Your Dev Environment
2.1 Introduction2.1.1 Cross-Platform Development in ASP.NET Core 102.1.2 Overview of Tools and Workflows2.2 Installing the.NET SDK2.2.1 Downloading and Installing the.NET 10 SDK2.2.2 Verifying Installation from the Command Line2.3 Choosing and Installing an IDE2.3.1 Visual Studio on Windows2.3.2 Visual Studio Code for Cross-Platform Development2.3.3 Comparing IDE Features for ASP.NET Core2.4 Command-Line Interface (CLI) Basics2.4.1 Introduction to the.NET CLI2.4.2 Creating, Building, and Running Projects with the CLI2.4.3 Essential CLI Commands for Developers2.4.4 When to Use CLI vs IDE2.5 Configuring the Development Environment2.5.1 Setting Environment Variables (Development, Staging, Production)2.5.2 Working with appsettings.json and Secrets2.5.3 Configuring HTTPS for Local Development2.5.4 Managing SDK Versions with global.json2.6 Installing and Managing Dependencies2.6.1 Using NuGet Packages in ASP.NET Core2.6.2 Restoring and Updating Packages2.6.3 Package Management in Visual Studio and CLI2.7 Best Practices for a Productive Environment2.7.1 Keeping SDKs and Tools Up to Date2.7.2 Recommended Extensions for Visual Studio and VS Code2.7.3 Source Control Setup with Git and GitHub2.8 Summary
3. Creating Your First ASP.NET Core 10 Application
3.1 Introduction3.1.1 Chapter Goals3.1.2 Why Start with an API?3.2 Creating the Project3.2.1 Choosing the Right Template3.2.2 Initializing the Project with the CLI3.2.3 Standardize the Default Folder Structure3.3 Designing the Domain Model3.3.1 Defining the Purpose3.3.2 Creating a Simple Entity: Book3.4 Implementing the Broker Layer3.4.1 Creating the Storage Broker3.4.2 Configuring In-Memory Storage3.5 Building the Foundation Service3.5.1 Creating the BookService3.5.2 Adding Simple Validation3.6 Exposing the API3.6.1 Creating the BooksController3.6.2 Defining Endpoints for CRUD Operations3.6.3 Testing the Endpoints with Postman3.7 Dependency Injection and Configuration3.7.1 Registering Services and Brokers in Program.cs3.7.2 Keeping Things Simple and Aligned with Auto Injection3.8 Summary and What’s Next

4. Understanding the ASP.NET Core 10 Pipeline
4.1 Introduction4.1.1 Why Understanding the Pipeline Matters4.1.2 Evolution of the ASP.NET Core Middleware Architecture4.2 Anatomy of the ASP.NET Core Pipeline4.2.1 The Role of the Program.cs and Startup.cs4.2.2 How the Host Is Built4.2.3 The Request Lifecycle: From HTTP to Response4.3 Working with Middleware4.3.1 What Is Middleware?4.3.2 Registering Middleware Components4.3.3 Order of Middleware Execution4.3.4 Writing Custom Middleware4.4 Built-In Middleware in ASP.NET Core4.4.1 Static Files, Routing, and Endpoints4.4.2 Authentication and Authorization4.4.3 Exception Handling and Logging4.4.4 CORS, Compression, and Caching4.5 Pipeline Configuration Patterns4.5.1 Minimal APIs vs Conventional Configuration4.5.2 Splitting Pipeline Configuration by Environment4.6 Common Pitfalls and Best Practices4.6.1 Avoiding Anti-Patterns in Pipeline Design4.6.1.1 Placing Middleware in the Wrong Order4.6.1.2 Adding Business Logic to Middleware4.6.1.3 Overusing Inline Middleware4.6.1.4 Not Handling Exceptions Early4.6.1.5 Registering Middleware Conditionally Without Fallbacks4.6.2 Performance Considerations4.6.2.1 Avoid Unnecessary Middleware4.6.2.2 Minimize Input/Output Operations in Middleware4.6.2.3 Use Caching Where Appropriate4.6.2.4 Compress Responses for Bandwidth Efficiency4.6.2.5 Profile the Pipeline4.7 Summary and What’s Next
5. The.NET Ecosystem: Core, Framework, and Beyond
5.1 Introduction5.2 The Origins of.NET Framework5.2.1 Overview of.NET Framework as a Windows-Only Legacy5.2.1.1 Early Adoption and Enterprise Focus5.2.1.2 Influence on Developer Productivity5.2.2 Core Features: CLR, BCL, and Managed Code5.2.2.1 Benefits of Managed Execution5.2.2.2 Language Interoperability5.2.3 Strengths and Limitations in Modern Development5.3 The Shift to.NET Core5.3.1 Motivations for.NET Core5.3.2 Architecture and Runtime Differences5.3.3 Milestones:.NET Core 1.0 to 3.15.4 The Unified.NET Platform5.4.1 .NET 5+ and the Unification Vision5.4.2 Support for Multiple Operating Systems and Devices5.4.3 Long-Term Support (LTS) vs. Current Releases5.4.4 How ASP.NET Core 10 Fits into the Ecosystem5.5 The Building Blocks of.NET5.5.1 Runtime and Language Execution5.5.1.1 Common Language Runtime (CLR and CoreCLR)5.5.1.2 Intermediate Language and JIT Compilation5.5.2 Libraries and Compilation Models5.5.2.1 Base Class Libraries (BCL)5.5.2.2 CrossGen and Native AOT5.6 Supported Application Models5.7 Package Management and NuGet5.7.1 Introduction to the NuGet Ecosystem5.7.1.1 Package Installation5.7.1.2 Dependency Graphs and Transitive Dependencies5.7.2 Managing Dependencies and Versions5.7.2.1 Central Package Management5.7.2.2 Handling Version Conflicts5.7.3 Private Feeds and Enterprise Package Management5.7.4 Role of NuGet in Modern DevOps Pipelines5.8 Tooling Across the Ecosystem5.9 Community and Open Source5.10 Migration and Interoperability5.10.1 Migrating from.NET Framework to.NET 105.10.2 Interoperability with Legacy and External Systems5.10.2.1 COM and Windows Integration5.10.2.2 JavaScript and Web Interop5.10.2.3 Native Code Integration5.10.3 Strategies for Modernization5.10.4 The Value of a Flexible Ecosystem5.11 Future of the.NET Ecosystem5.11.1 Roadmap for.NET 11 and Beyond5.11.2 Trends Shaping the Future5.11.2.1 AI Integration5.11.2.2 Cloud-Native Development5.11.2.3 Performance Optimizations5.11.3 Staying Up to Date with Ecosystem Changes5.12 Summary
Part II: Core Features and Application Development
6. Mastering Dependency Injection
6.1 Introduction to Dependency Injection6.2 Understanding the ASP.NET Core DI Container6.2.1 How the ASP.NET Core DI Container Works6.2.2 Registering Dependencies in the Service Collection6.2.3 Injecting Services into Controllers6.2.4 Registering Different Service Lifetimes6.2.5 Resolving Dependencies Manually with IServiceProvider6.3 Constructor, Method, and Property Injection6.3.1 Constructor Injection (Recommended)6.3.2 Method Injection6.3.3 Property Injection6.4 Dependency Injection for Unit Testing6.4.1 Why DI is Crucial for Unit Testing6.4.2 Using Dependency Injection for Testability6.4.3 Unit Testing Controllers with DI6.5 Summary
7. Routing and Endpoints in ASP.NET Core 10
7.1 Introduction7.2 Defining Routes7.2.1 Conventional vs. Attribute Routing7.2.2 Route Templates and Constraints7.2.3 Route Parameters and Defaults7.3 The Endpoint Routing System7.3.1 What Are Endpoints?7.3.2 How ASP.NET Core Builds the Endpoint Table7.3.3 Middleware Integration in the Routing System7.4 Configuring Routing in Program.cs7.4.1 The MapGet, MapPost, and Other Map Methods7.4.2 Working with UseRouting and UseEndpoints7.4.3 Route Patterns in Minimal APIs vs. Controllers7.5 Routing with Controllers7.6 Routing in Razor Pages and Blazor7.7 Custom Route Constraints and Transformers7.8 Diagnostic and Debugging Tools7.9 Applying The Standard to Routing and Endpoints7.10 Summary
8. Configuration and Options in ASP.NET Core 10
8.1 Introduction8.2 Configuration Fundamentals8.2.1 Application vs. Host Configuration8.2.2 The IConfiguration Interface8.2.3 Configuration Providers and Their Order of Precedence8.3 Built-in Configuration Providers8.3.1 JSON Files8.3.2 Environment Variables8.3.3 Command-Line Arguments8.3.4 User Secrets8.3.5 Azure Key Vault and Cloud Providers8.3.6 Putting It All Together8.4 The Options Pattern8.4.1 Introduction to IOptions8.4.2 IOptionsSnapshot for Per-Request Scoped Options8.4.3 IOptionsMonitor for Dynamic Reloading8.4.4 Validating Configuration Values8.4.5 Summary of the Options Pattern8.5 Strongly Typed Configuration Binding8.5.1 Mapping Configuration to POCO Classes8.5.2 Nested Sections and Hierarchical Keys8.5.3 Examples with appsettings.json8.5.4 Why Strongly Typed Binding Matters8.6 Advanced Configuration Scenarios8.6.1 Auto-Reloading Configuration on File Changes8.6.2 Creating Custom Configuration Providers8.6.3 Centralized Configuration in Distributed and Microservices Architectures8.6.4 Putting It All Together8.7 Summary
9. Logging and Monitoring
9.1 Introduction to Logging and Monitoring9.2 Logging in ASP.NET Core9.2.1 The ILogger and Dependency Injection Model9.2.2 Built-in Logging Providers9.2.3 Log Levels and Filtering Strategies9.2.4 Structured Logging, Scopes, and Correlation9.2.5 Using Third-Party Providers9.3 Monitoring and Observability9.3.1 From Logs to Metrics and Traces9.3.2 Health Checks and Readiness Probes9.3.3 Distributed Tracing with OpenTelemetry9.3.4 Integration with Application Insights and Cloud Monitoring Platforms9.3.5 Observability Patterns for Microservices9.4 Best Practices and Security Considerations9.5 Summary
10. Building Secure Applications
10.1 Introduction to Security in ASP.NET Core10.1.1 Why Security Matters in Modern Web Applications10.1.2 Defense-in-Depth as a Guiding Principle10.1.3 Overview of ASP.NET Core 10.0 Security Features10.2 Authentication10.2.1 Understanding Authentication in ASP.NET Core10.2.2 Using ASP.NET Core Identity10.2.2.1 Identity Basics and Setup10.2.2.2 Managing Users, Roles, and Claims10.2.2.3 Customizing the Identity Model10.2.3 External Authentication Providers10.2.4 Token-Based Authentication10.2.4.1 JWT (JSON Web Tokens)10.2.4.2 OAuth2 and OpenID Connect10.2.5 Integrating with Azure Active Directory and Microsoft Entra10.3 Authorization10.3.1 Authorization Fundamentals10.3.2 Role-Based Authorization10.3.3 Claims-Based Authorization10.3.4 Policy-Based Authorization10.3.4.1 Defining and Applying Policies10.3.4.2 Using IAuthorizationService10.3.5 Resource-Based Authorization10.3.6 Combining Multiple Authorization Strategies10.4 Data Protection10.4.1 Why Data Protection Matters10.4.2 The ASP.NET Core Data Protection APIs10.4.3 Key Management and Rotation10.4.4 Persisting Keys Securely10.4.5 Scenarios for Cookie and Token Encryption10.4.6 GDPR Considerations and Compliance10.5 Securing Data in Transit10.5.1 Enforcing HTTPS10.5.2 Using UseHttpsRedirection10.5.3 Configuring HSTS (HTTP Strict Transport Security)10.5.4 TLS Configuration and Certificates10.5.5 Middleware for Transport Security10.6 Protecting Against Common Web Attacks10.6.1 Cross-Site Request Forgery (CSRF)10.6.2 Validating Requests10.6.2.1 HTTP Method Enforcement10.6.2.2 Model Validation10.6.2.3 Custom Validation and Fluent Validation10.6.2.4 Request Size and Content-Type Constraints10.6.2.5 Blazor-Specific Considerations10.6.2.6 Cross-References to Other Chapters10.6.3 Cross-Site Scripting (XSS)10.6.4 Using IHtmlHelper and Safe Rendering10.6.5 Clickjacking and Content Injection10.6.6 Frame Options and CSP Headers10.6.7 Configuring CORS (Cross-Origin Resource Sharing) for APIs10.7 Managing Secrets, Cookies, and Monitoring10.7.1 Secret and Configuration Management10.7.1.1 The Importance of Secure Configuration10.7.1.2 User Secrets for Local Development10.7.1.3 Environment Variables and Production Configuration10.7.1.4 Storing Secrets in Azure Key Vault10.7.1.5 Best Practices for Managing Credentials and Connection Strings10.7.2 Secure Cookies and Session Management10.7.2.1 Cookie Security Attributes10.7.2.2 Session State Considerations10.7.2.3 Token Expiration and Refresh Strategies10.7.3 Monitoring and Logging Security Events10.7.3.1 Why Security Logging Matters10.7.3.2 Configuring Security-Related Logging10.7.3.3 Integrating with Monitoring Systems10.7.3.4 Detecting and Responding to Suspicious Activity10.8 Deployment, Hardening, and Advanced Scenarios10.8.1 Secure Deployment and Hardening10.8.1.1 Minimizing the Attack Surface10.8.1.2 Protecting Endpoints and API Routes10.8.1.3 Updating Dependencies and Patch Management10.8.1.4 Threat Modeling and Ongoing Reviews10.8.2 Advanced Security Scenarios10.8.2.1 Multi-Factor Authentication (MFA)10.8.2.2 Federated Identity with External Providers10.8.2.3 Identity UI Scaffolding and Customization10.8.2.4 Security in Microservices and Distributed Systems10.9 Summary
11. Integrating Databases with EF Core
11.1 Introduction11.2 The Standard: A Guiding Philosophy for Software Development11.2.1 What is The Standard?11.2.2 Why Follow The Standard in Database Integration?11.2.3 Principles That Ensure Maintainable and Scalable Database Solutions11.2.4 The Role of Brokers, Services, and Exposers in The Standard Architecture11.2.5 Applying The Standard to EF Core Development11.3 Understanding Entity Framework Core11.3.1 What is EF Core?11.3.2 Benefits of Using EF Core in ASP.NET Core 1011.3.3 Comparison with Other ORM Frameworks11.3.4 EF Core vs. ADO.NET: Understanding the Differences11.4 Setting Up Entity Framework Core11.4.1 Installing EF Core in an ASP.NET Core 10 Project11.4.2 Configuring the Database Provider11.4.2.1 Traditional EF Core Configuration11.4.2.2 Configuring the Database Provider According to The Standard11.5 Modeling Data with EF Core11.5.1 Defining Entities11.5.1.1 Mapping Database Tables to C# Classes11.5.1.2 Keeping Entities Clean11.5.1.3 Primary Keys and Identity Management11.5.2 Configuring Relationships11.5.2.1 One-to-Many Relationships11.5.2.2 Many-to-Many Relationships11.6 Implementing The Architecture with EF Core11.6.1 Implementing Brokers11.6.1.1 Creating the StorageBroker11.6.1.2 Why Brokers Are Essential for Database Interactions11.6.2 Implementing Services11.6.2.1 Adding a StudentService to Handle Business Logic11.6.2.2 Validation, Exception Handling, and Mapping Inside Services11.6.3 Implementing Exposers11.6.3.1 Creating a Controller (StudentsController)11.7 Querying Data with EF Core11.7.1 Retrieving Data the Right Way11.7.2 Using IQueryable vs. IEnumerable11.8 Working with Migrations11.8.1 Introduction to Migrations11.8.2 Creating and Applying Migrations11.8.3 Handling Database Seeding11.9 Summary
12. Building Efficient APIs with ASP.NET Core
12.1 Introduction to API Development in ASP.NET Core12.1.1 Why APIs Are the Backbone of Modern Applications12.1.2 Efficiency as a Core Design Principle12.1.3 Minimal APIs vs. Controller-Based APIs12.1.4 Overview of ASP.NET Core 10 Features for APIs12.2 Designing RESTful APIs12.2.1 REST Principles and Resource-Based Design12.2.2 Routes, Conventions, and Versioning Strategies12.2.3 Returning Proper HTTP Status Codes12.2.4 Pagination, Filtering, and Sorting for Collections12.3 Creating Your First Web API12.3.1 Setting up the Project in Visual Studio12.3.2 Understanding the Default Template12.3.3 Adding a Model and DbContext with EF Core12.3.4 Building Your First Controller with CRUD Endpoints12.4 Using OData12.4.1 Why OData for Efficiency12.4.2 Installing and Enabling OData12.4.3 Exposing Entity Sets with OData Controllers12.4.4 Shaping Responses with Query Options12.4.5 Guardrails: Limiting and Validating Queries12.4.6 Writes with OData12.4.7 Concurrency and Conditional Updates with ETags12.4.8 Performance Tips for OData Endpoints12.4.9 Testing OData Queries12.4.10 What You Achieved12.5 Error Handling and API Robustness12.5.1 Returning Problem Details with RFC 780712.5.2 Global Exception Handling with Middleware12.5.3 Handling Concurrency with EF Core12.5.3.1 Entity configuration12.5.3.2 Update logic that surfaces 40912.5.4 Designing Meaningful Error Responses12.5.5 End-to-End Examples in the E-commerce API12.5.5.1 Product not found12.5.5.2 Order creation with guarded validation12.5.6 Minimal Integration Tests for Robustness12.5.6.1 Concurrency produces 40912.5.6.2 Invalid payload returns 400 with validation details12.6 Securing APIs12.6.1 Authentication and Authorization Basics12.6.2 Protecting Endpoints with [Authorize]12.6.3 Securing Sensitive Data in DTOs12.6.4 Rate Limiting and Throttling Strategies12.6.5 Additional Hygiene: HTTPS, CORS, and Secret Management12.6.6 Minimal Integration Tests for Secured Endpoints12.7 API Documentation and Testing12.7.1 OpenAPI + Scalar Integration12.7.2 Customizing Scalar for Real Consumers12.7.3 Make “Authorize” Work in Scalar12.7.4 Writing Helpful Summaries, Tags, and Examples12.7.5 Exercising the API with Scalar’s Interactive Reference12.7.6 Postman and HTTP REPL for Team Workflows12.7.7 Linting and Build-Time Document Generation12.7.8 Automated Integration Testing with WebApplicationFactory12.8 Summary
13. SignalR and Real-Time Communication
13.1 Introduction13.1.1 The Need for Real-Time Interactivity13.1.2 SignalR in the Context of ASP.NET Core 1013.2 Fundamentals of SignalR13.2.1 What Is SignalR?13.2.2 The Role of Persistent Connections13.2.3 Transport Mechanisms13.3 Configuring SignalR in ASP.NET Core 1013.3.1 Installing Required Packages13.3.2 Adding SignalR to the Middleware Pipeline13.3.3 Mapping Hubs in Program.cs13.4 Creating a SignalR Hub13.4.1 Defining a Hub Class13.4.2 Calling Clients from the Hub13.5 Consuming SignalR from the Client13.5.1 JavaScript Client Integration13.5.2 .NET Client Integration13.5.3 Blazor Server and Blazor WebAssembly Integration13.6 State and Scalability13.6.1 Managing Connection State13.6.2 Using Redis Backplanes for Scaling Out13.6.3 SignalR with Azure SignalR Service13.7 Security Considerations13.7.1 Authenticating Users in Hubs13.7.2 Authorization Policies and Endpoint Filtering13.7.3 Preventing Unauthorized Access to Messages13.8 Testing SignalR Applications13.8.1 Unit Testing Hub Methods13.8.2 Integration Testing with WebApplicationFactory13.8.3 Client-Side Testing Strategies13.9 Summary
14. Caching and Performance Optimization
14.1 Understanding Caching and Performance14.1.1 Why Performance Optimization Matters in ASP.NET Core14.1.2 The Role of Caching in Modern Web Scalability14.1.3 Types of Caching: Memory, Distributed, Hybrid, and Response-Level14.1.4 Cache Invalidation, Freshness, and Consistency14.1.5 When Not to Cache14.2 In-Memory and Distributed Caching14.2.1 Overview of IMemoryCache and IDistributedCache14.2.2 Configuring Caching Services in Program.cs14.2.3 Sliding and Absolute Expirations14.2.4 Using Redis or SQL Server as Distributed Caches14.2.5 Using Redis as a Distributed Cache14.2.6 Using SQL Server as a Distributed Cache14.2.7 Example: Caching Product Data in an E-Commerce API14.3 Hybrid Caching in ASP.NET Core 1014.3.1 The Concept of HybridCache: Combining Speed and Scalability14.3.2 Setting Up AddHybridCache()14.3.2.1 Configuring HybridCache in Program.cs14.3.2.2 Using HybridCache in an Application14.3.3 Reducing Cache Stampede and Race Conditions14.3.4 Practical Example: Caching Inventory Lookups Across Multiple Nodes14.3.5 When to Prefer Hybrid Caching Over Traditional Approaches14.4 Response and Output Caching14.4.1 Difference Between Response and Output Caching14.4.2 Configuring UseResponseCaching() Middleware14.4.2.1 Defining Cache-Control Headers14.4.2.2 Using the [ResponseCache] Attribute14.4.3 Working with Cache-Control, Vary, and Validation Headers14.4.4 Enabling Output Caching with AddOutputCache()14.4.5 Defining Output Cache Policies14.4.6 Tagging and Invalidation14.4.7 Example: Caching Razor Page and API Responses14.4.7.1 Controller Example (API)14.4.7.2 Razor Page Example14.4.8 Output Cache Storage Options14.5 Performance Optimization Beyond Caching14.5.1 Asynchronous I/O and Non-Blocking Execution14.5.2 Minimizing Middleware and Request Overhead14.5.3 Using Response Compression and HTTP/214.5.3.1 Configuring Response Compression14.5.3.2 Leveraging HTTP/214.5.4 Reducing Allocations and Improving Garbage Collection14.5.4.1 Minimize Object Allocations14.5.4.2 Use Structs and Span for Performance-Critical Operations14.5.5 Profiling and Benchmarking with dotnet-counters and BenchmarkDotNet14.5.5.1 Using dotnet-counters14.5.5.2 Using BenchmarkDotNet14.5.6 Optimizing Payloads and Serialization Performance14.5.6.1 Avoid Over-Serialization14.5.6.2 Use JSON Source Generation14.5.6.3 Compression and Binary Formats14.6 Best Practices and Summary14.6.1 Choosing the Right Caching Strategy for Your Scenario14.6.2 Measuring Cache Effectiveness: Hit Ratio and Latency14.6.3 Common Caching Anti-Patterns to Avoid14.6.4 Integrating Telemetry with Application Insights or OpenTelemetry14.6.4.1 Using Application Insights14.6.4.2 Using OpenTelemetry14.6.5 Summary: Balancing Speed, Scalability, and Correctness
15. File Handling and Storage
15.1 Introduction15.1.1 Understanding the Role of File Management in Modern Web Applications15.1.2 Common File-Related Scenarios in ASP.NET Core15.1.3 Security and Performance Considerations in File Operations15.2 Working with the File System15.2.1 Understanding File Providers15.2.1.1 Overview of IFileProvider Abstraction15.2.1.2 Using PhysicalFileProvider for Local File Access15.2.1.3 Exploring ManifestEmbeddedFileProvider and CompositeFileProvider15.2.2 Accessing and Reading Files15.2.3 Writing and Updating Files15.3 Handling File Uploads in ASP.NET Core15.3.1 Understanding the Request Lifecycle for File Uploads15.3.2 Uploading Files with Controllers and Razor Pages15.3.3 Validating and Securing File Uploads15.4 Serving and Downloading Files15.4.1 Serving Static Files15.4.2 Secure File Downloads15.4.3 Restricting Access to Files15.5 Managing Large Files and Streaming15.5.1 Buffered vs. Streamed File Uploads15.5.2 Download Streaming15.5.3 Progress Reporting15.6 File Storage Abstraction15.6.1 Introducing the Storage Broker15.6.2 Example: File Storage Broker for Product Images15.6.3 Using ValueTask for File Operations15.7 Integrating Cloud and External Storage15.7.1 Using Azure Blob Storage15.7.2 Amazon S3 and Google Cloud Storage15.7.2.1 Amazon S315.7.2.2 Google Cloud Storage15.7.3 Hybrid Storage Strategies15.8 Summary
Part III: Web and Cross-Platform Development
16. Razor Pages: Simplified Web Development
16.1 Introduction to Razor Pages16.1.1 Why Razor Pages Were Introduced in ASP.NET Core16.1.2 Page-Centric vs. Controller-Centric Development16.1.3 When to Choose Razor Pages Over MVC16.1.4 Overview of What You Will Build in This Chapter16.2 Architecture and Project Setup16.2.1 The Role of @page and the PageModel Class16.2.2 How Razor Pages Fit into the ASP.NET Core 10 Request Pipeline16.2.3 Creating a Razor Pages Project in Visual Studio16.2.4 Understanding Folder Conventions and Routing16.2.5 Configuring Razor Pages in Program.cs16.3 Building Your First Razor Page16.3.1 Anatomy of a Razor Page (.cshtml +.cshtml.cs)16.3.2 Handler Methods (OnGet, OnPost, and Async Variants)16.3.3 Using [BindProperty] and Handling User Input16.3.4 Form Submission and Redirection with RedirectToPage()16.3.5 Data Validation and Displaying Errors in the View16.4 Working with Routing, Layouts, and Tag Helpers16.4.1 Default URL Conventions and Custom Route Templates16.4.2 Using asp-page, asp-route, and asp-page-handler16.4.2.1 asp-page16.4.2.2 asp-route16.4.2.3 asp-page-handler16.4.3 Defining a Shared Layout with _Layout.cshtml16.4.4 _ViewStart.cshtml and _ViewImports.cshtml Explained16.4.4.1 _ViewStart.cshtml16.4.4.2 _ViewImports.cshtml16.4.5 Creating Partials and Shared Components with Tag Helpers16.4.6 Putting It All Together16.5 Styling, Scripts, and Data Integration16.5.1 Page-Specific CSS Isolation (.cshtml.css)16.5.2 Collocated JavaScript Files (.cshtml.js)16.5.3 Serving Static Assets and Razor Class Library Resources16.5.4 Integrating Entity Framework Core for CRUD Operations16.5.5 Handling AJAX Calls and Client-Side Interactivity16.6 Best Practices and Summary16.6.1 Organizing Large Razor Pages Projects16.6.2 Using Custom Base PageModels16.6.3 Security: Antiforgery Tokens and Authorization Attributes16.6.4 Common Pitfalls and Troubleshooting Tips16.6.5 Key Takeaways from Razor Pages Development
17. Model Binding and Validation
17.1 Introduction to Model Binding and Validation17.1.1 Why Model Binding Matters in ASP.NET Core 1017.1.2 How Validation Ensures Data Integrity17.1.3 The Request Lifecycle: From HTTP to Models17.2 Understanding Model Binding17.2.1 The Model Binding Process17.2.2 Supported Sources: Form Values, Route Data, Query Strings, and Headers17.2.2.1 Route Data17.2.2.2 Query Strings17.2.2.3 Form Values17.2.2.4 Headers17.2.3 Complex Types and Nested Object Binding17.2.4 Handling Collections and Arrays in Model Binding17.2.4.1 Binding Simple Collections17.2.4.2 Binding Collections of Complex Objects17.2.4.3 Default Model Binding Behavior vs. Customization17.3 Customizing Model Binding17.3.1 Using [Bind] Attribute for Property Inclusion and Exclusion17.3.2 Implementing Custom Model Binders17.3.3 Value Providers and Binding Context17.3.4 Dealing with Type Conversion and Binding Failures17.4 Introduction to Validation in ASP.NET Core17.4.1 The Role of Validation in Web Applications17.4.2 Built-In Validation Attributes17.4.3 Data Annotations vs. Fluent Validation Approaches17.4.4 Integrating Validation with Model Binding17.5 Advanced Validation Patterns17.5.1 Structural Validations: Ensuring Required Properties Are Not Null, Empty, or Default17.5.2 Logical Validations: Cross-Field Checks, Rules, and Constraints17.5.3 Dependency and External Validations: Validating with Databases or APIs17.5.4 Continuous vs. Circuit-Breaking Validations17.5.5 Collecting Multiple Errors with Upsertable Exceptions17.6 Implementing Custom Validation17.6.1 Custom Validation Attributes17.6.2 IValidatableObject Interface17.6.3 Model-Level Validation17.6.4 Using Services for Business Logic Validations17.7 Error Handling and Feedback17.7.1 Accessing ModelState in Controllers and Razor Pages17.7.2 Displaying Validation Errors in Views and Razor Pages17.7.3 Localized Error Messages and User-Friendly Feedback17.8 Testing Model Binding and Validation17.8.1 Writing Unit Tests for Structural Validation17.8.2 Mocking Services and Dependencies in Validation17.8.3 Ensuring Consistency Across Binding and Validation17.9 Best Practices and Performance Considerations17.9.1 Avoiding Over-Annotation Anti-Patterns17.9.2 Separating Models, DTOs, and Validation Logic17.9.3 Designing for Scalability in High-Request Environments17.9.3.1 Minimize Expensive Checks17.9.3.2 Leverage Caching17.9.3.3 Parallelizing Independent Validations17.9.3.4 Graceful Degradation Under Load17.9.4 Security Considerations in Binding and Validation17.9.5 Putting It All Together17.10 Summary
18. Advanced MVC Patterns
18.1 Introduction to Advanced MVC18.1.1 Revisiting Controllers, Views, and Models18.1.2 Why Advanced Patterns Are Needed Beyond the Basics18.2 Advanced Controller Patterns18.2.1 Base Controllers and Inheritance Strategies18.2.2 Custom Controller Factories and Dependency Injection18.2.3 Organizing Actions for Maintainability18.2.4 Attribute Routing vs. Conventional Routing in Complex Apps18.3 Advanced View Patterns18.3.1 Strongly Typed Views and Model Binding in Depth18.3.2 Layout Pages, Partial Views, and Nested Rendering18.3.3 Leveraging View Components for Reusable UI Blocks18.3.4 Razor Best Practices for Large Applications18.3.5 Performance Considerations in Rendering Views18.4 Advanced Model Patterns18.4.1 From Simple Models to Domain Models18.4.2 View Models, Domain Models, and DTOs: When to Use Each18.4.3 Rich Validation Techniques with Data Annotations and Fluent Validation18.4.4 Handling Complex Binding Scenarios (Collections, Nested Objects)18.4.5 Asynchronous Model Operations and State Management18.5 Separation of Concerns in MVC18.5.1 Avoiding Fat Controllers and Fat Models18.5.2 Introducing the Service Layer in MVC Applications18.5.3 Applying the Repository Pattern for Data Access18.5.4 Using the Unit of Work Pattern with EF Core18.5.5 Dependency Injection as the Glue for MVC Layers18.6 Cross-Cutting Concerns in MVC18.6.1 Action Filters and Result Filters18.6.2 Implementing Global Error Handling and Exception Filters18.6.3 Logging and Auditing with Filters18.6.4 Security and Authorization Filters18.7 Modularization and Large-Scale MVC Applications18.7.1 Organizing Applications with Areas18.7.2 Feature Folders vs. Conventional Folder Structures18.7.3 Domain-Driven Design Principles in MVC Projects18.7.4 Mixing MVC with APIs and Razor Pages in Hybrid Architectures18.8 Testing and Quality Assurance in MVC18.8.1 Unit Testing Controllers with Mocking Frameworks18.8.2 Testing Models and Validation Rules18.8.3 Verifying Views and Razor Output18.8.4 Integration Testing with ASP.NET Core TestServer18.8.5 Applying Test-Driven Development (TDD) in MVC18.9 Case Study: Evolving from the Basics18.9.1 Starting with Add Controller, Add View, Add Model18.9.2 Refactoring into Services, Repositories, and Layers18.9.3 Applying Advanced Patterns to a Real MVC App18.9.4 Lessons Learned in Scaling from Demo to Production18.10 Summary
19. Blazor Server: A Modern Approach to Web Apps
19.1 Introduction to Blazor Server19.1.1 Why Blazor Server Matters in ASP.NET Core 1019.1.2 Revisiting the Server-Side Rendering Model19.1.3 Comparing Blazor Server, Blazor WebAssembly, and MVC19.2 Understanding the Blazor Server Hosting Model19.2.1 SignalR and Real-Time Communication19.2.2 Circuit Management and State Preservation19.2.3 Lifecycle Events in Blazor Server19.3 Building Your First Blazor Server Application19.3.1 Project Templates and Setup19.3.2 Anatomy of a Blazor Server App19.3.3 Running and Debugging Locally19.4 Components as the Building Blocks19.4.1 Anatomy of a Component (.razor, code-behind, styling)19.4.2 Parameters and Data Binding19.4.3 Event Handling in Blazor Server19.4.4 Component Reusability and Best Practices19.5 Data Access and Integration19.5.1 Using Dependency Injection in Blazor Components19.5.2 Working with Entity Framework Core in Blazor Server19.5.3 Calling External APIs and Services19.5.4 State Management Strategies19.6 Layouts, Routing, and Navigation19.6.1 Using Layout Components for Consistency19.6.2 Defining Routes with @page19.6.3 Handling Parameters and Query Strings19.6.4 Nested Components and Hierarchical Routing19.7 Forms, Validation, and User Interaction19.7.1 Building Forms with Input Components19.7.2 Leveraging Data Annotations for Validation19.7.3 Custom Validation Logic19.7.4 Enhancing User Experience with Real-Time Feedback19.8 Authentication and Authorization in Blazor Server19.8.1 Securing Components and Pages with [Authorize]19.8.2 Role-Based and Policy-Based Authorization19.8.3 Handling Authentication State19.8.4 Integrating Identity with Blazor Server19.9 Advanced Patterns and Best Practices19.9.1 Applying The Standard to Blazor Components (Bases, Components, Pages)19.9.2 Modular Architecture in Blazor Server19.9.3 Handling Large Applications and Component Libraries19.9.4 Patterns for Maintainability and Long-Term Support19.10 Deployment and Hosting19.10.1 Hosting Options: IIS, Azure App Service, Containers19.10.2 Configuration for Production Environments19.10.3 Monitoring and Logging in Live Systems19.11 Summary
20. Blazor WebAssembly: Full-Stack Web Development
20.1 Introduction to Blazor WebAssembly20.1.1 The Evolution of Blazor WebAssembly20.1.2 Architecture Overview: Runtime, WebAssembly, and the Browser Sandbox20.1.3 Comparing Blazor Server and Blazor WebAssembly20.1.4 When to Choose Blazor WebAssembly20.1.5 Hosting Options: Standalone vs ASP.NET Core Hosted20.1.6 Anatomy of a Blazor WebAssembly Project20.2 Building and Communicating in a Full-Stack Blazor App20.2.1 Creating a Modern Blazor WebAssembly App in.NET 1020.2.2 Creating a Hosted Blazor WebAssembly Solution20.2.3 Building the Server API20.2.4 Consuming APIs from Blazor WebAssembly20.2.5 Managing Configuration and Environment Settings20.2.6 Handling Errors, Serialization, and Resilience20.2.7 Implementing Caching and Offline-Ready Requests20.3 Enhancing Performance and User Experience20.3.1 Understanding Application Startup, Payload Size, and Assembly Loading20.3.2 Lazy Loading Assemblies20.3.2.1 Marking Assemblies for Deferred Loading20.3.2.2 Using LazyAssemblyLoader in Routing20.3.2.3 User Feedback During Lazy Loading20.3.3 Progressive Web Apps (PWA): Bringing Native Feel to the Web20.3.3.1 Enabling PWA Support in Blazor20.3.3.2 Understanding manifest.webmanifest and Service Workers20.3.3.3 Offline Caching and Background Updates20.3.4 Installing Blazor PWAs on Desktop and Mobile20.3.5 Combining Lazy Loading and PWAs for Maximum Impact20.4 Working with Native Dependencies and Deployment20.4.1 Using Native Code Compiled to WebAssembly20.4.2 Declaring <NativeFileReference> in the project20.4.3 Invoking native functions with [DllImport]20.4.4 Handling callbacks from unmanaged to managed20.4.5 Packaging native dependencies in a NuGet package20.4.6 Debugging and inspecting runtime behavior20.4.7 Publishing and hosting Blazor WebAssembly apps20.4.8 Deploying to Azure, IIS, and static CDNs20.4.8.1 Azure Static Web Apps20.4.8.2 Azure App Service or IIS20.5 Summary
21. Using Tag Helpers and View Components
21.1 Introduction to Tag Helpers and View Components21.1.1 Why Tag Helpers Matter in ASP.NET Core 1021.1.2 Comparing Tag Helpers, HTML Helpers, and Razor Syntax21.2 Working with Tag Helpers21.2.1 Built-in Tag Helpers: form, input, link, environment, and more21.2.2 Attributes and Conventions That Drive Tag Helpers21.2.3 Binding Tag Helpers to Models and Validation Metadata21.2.4 Combining Tag Helpers with Razor Pages and MVC Views21.2.5 Best Practices for Maintainability and Consistency21.3 Creating Custom Tag Helpers21.3.1 Anatomy of a Custom Tag Helper Class21.3.2 Using Attributes and Dependency Injection Within Tag Helpers21.3.3 Rendering Dynamic Content and Handling Conditional Logic21.3.4 Building a Reusable Navigation Menu Tag Helper21.3.5 Testing and Debugging Custom Tag Helpers21.4 Understanding and Implementing View Components21.4.1 The Purpose of View Components in ASP.NET Core21.4.2 Comparing View Components with Partial Views and Controllers21.4.3 Creating a View Component: Class, View, and Invocation21.4.4 Passing Data into View Components21.4.5 Building a “Latest Articles” View Component21.4.6 Managing Reusability and Separation of Concerns21.5 Summary and Best Practices21.5.1 When to Prefer Tag Helpers, HTML Helpers, or Razor Components21.5.2 Guidelines for Reusability and Consistency Across Large Projects21.5.3 Performance Considerations with Tag Helpers and View Components21.5.4 Common Pitfalls and How to Avoid Them21.5.5 Summary
22. Building Rich Forms with Tag Helpers
22.1 Introduction to Forms in ASP.NET Core 1022.1.1 Why forms matter in modern web applications22.1.2 From raw HTML forms to Tag Helpers22.1.3 The role of model binding and validation in forms22.1.4 Putting it together22.2 Creating Forms with Tag Helpers22.2.1 The <form> Tag Helper and antiforgery tokens22.2.2 Input Tag Helpers: text, password, checkbox, radio, and select22.2.3 Label, validation, and summary Tag Helpers22.2.4 Binding form fields to model properties22.2.5 Building a registration form step by step22.3 Enhancing Forms with Rich Features22.3.1 Working with validation attributes and client-side validation22.3.2 Displaying validation messages and summaries22.3.3 Dropdowns, lists, and complex binding scenarios22.3.4 Supporting file uploads with the Input Tag Helper22.3.5 Handling conditional form sections and partial rendering22.3.6 Bringing it all together22.4 Best Practices and Summary22.4.1 Keeping forms maintainable and secure22.4.2 Accessibility considerations in form design22.4.3 Common pitfalls and how to avoid them22.4.4 Summary of key takeaways
23. Integrating.NET MAUI with ASP.Net Core
23.1 Introduction23.1.1 Why integrate MAUI with ASP.NET Core?23.1.2 Comparing traditional mobile apps with integrated architectures23.1.3 Common use cases: authentication, forms, APIs, and hybrid UIs23.2 Setting Up the Integration Environment23.2.1 Creating a.NET MAUI solution with an ASP.NET Core backend23.2.2 Sharing projects and class libraries23.2.3 Configuring dependency injection and shared services23.2.4 Putting it all together23.3 Working with Data and Forms Across MAUI and ASP.NET Core23.3.1 Reusing ASP.NET Core form models in.NET MAUI apps23.3.2 Leveraging model binding and validation in cross-platform scenarios23.3.3 Implementing secure form submissions and antiforgery concepts23.3.4 Building a registration form shared between web and mobile23.4 Communication Between MAUI and ASP.NET Core Services23.4.1 Calling ASP.NET Core APIs from a MAUI client23.4.2 Handling authentication and authorization tokens23.4.3 Using SignalR for real-time updates in MAUI23.4.4 Offline synchronization strategies for mobile-first scenarios23.4.5 Bringing it all together23.5 Best Practices and Summary23.5.1 Structuring shared code for maintainability23.5.2 Ensuring consistency in validation and user experience23.5.3 Performance considerations in hybrid setups23.5.4 Summary and recommendations for production-ready integrations
24. Building Hybrid Applications with Blazor and.NET MAUI
24.1 Introduction to Hybrid Blazor with.NET MAUI24.1.1 Understanding the Hybrid Application Model24.1.2 Why Choose Blazor Hybrid: Benefits and Trade-Offs24.1.3 Comparing Blazor WebAssembly, Blazor Server, and Blazor Hybrid24.1.4 Scenarios Where Hybrid Apps Shine24.2 Creating and Configuring a Blazor Hybrid Application24.2.1 Setting up a New.NET MAUI Blazor Project in Visual Studio24.2.2 Anatomy of a Blazor Hybrid Project24.2.3 Hosting the BlazorWebView Control24.2.4 Integrating Razor Components into Native MAUI Pages24.2.5 Managing Navigation Between Blazor and MAUI Pages24.2.6 Debugging and Running on Android, iOS, Windows, and macOS24.3 Best Practices and Real-World Scenarios24.3.1 Structuring Projects for Reusability and Maintainability24.3.2 Sharing Services, Models, and Business Logic Between MAUI and Blazor Layers24.3.3 Accessing Native Device APIs with Dependency Injection24.3.4 Handling Offline Data and Synchronization Strategies24.3.5 Performance Considerations for Hybrid Apps24.3.6 Summary and Key Takeaways
Part IV: Advanced Practices and Sample Project
25. Unit Testing and Integration Testing
25.1 Introduction to Testing in ASP.NET Core25.1.1 The Role of Testing in Modern Application Development25.1.2 Benefits of Automated Testing: Reliability, Maintainability, and Confidence25.1.3 Unit Testing vs. Integration Testing: Scope and Differences25.1.4 Overview of the Testing Ecosystem: xUnit, NUnit, MSTest, Moq, and TestServer25.2 Unit Testing in ASP.NET Core25.2.1 Designing for Testability: Dependency Injection and Separation of Concerns25.2.2 Writing Unit Tests with xUnit25.2.3 Using Mocking Frameworks (Moq) to Isolate Dependencies25.2.4 Testing Controllers, Services, and Model Validations25.2.5 Test-Driven Development (TDD) with ASP.NET Core25.3 Integration Testing in ASP.NET Core25.3.1 What Integration Tests Validate and When to Use Them25.3.2 Setting Up the Test Host with WebApplicationFactory25.3.3 Testing Controllers and Middleware End-to-End25.3.4 Working with In-Memory Databases and TestServer25.3.5 Handling External Services in Integration Tests (Stubs, Mocks, WireMock)25.3.6 Managing Test Data and Cleanup Strategies25.4 UI Testing Considerations25.4.1 The Purpose of UI Testing25.4.2 Common Tools for.NET UI Testing25.4.3 UI Testing for Blazor Applications25.4.4 UI Testing for.NET MAUI and.NET MAUI Blazor25.4.5 Integrating UI Tests into CI/CD Pipelines25.5 Best Practices and Summary25.5.1 Balancing Unit and Integration Testing in Real Projects25.5.2 Ensuring Tests Remain Maintainable and Fast25.5.3 Structuring Test Projects and Applying Naming Conventions25.5.4 Continuous Integration Pipelines and Automated Test Execution25.5.5 Common Pitfalls and How to Avoid Them25.5.6 Summary and Key Takeaways
26. Optimizing Performance in ASP.NET Core 10
26.1 Introduction26.1.1 Why Performance Matters in Modern Web Applications26.1.2 Measuring Success: Throughput, Latency, Scalability, and Responsiveness26.1.3 Common Performance Pitfalls in ASP.NET Core Applications26.2 Application-Level Performance Techniques26.2.1 Efficient Use of Dependency Injection and Object Lifetimes26.2.2 Minimizing Memory Allocations and Garbage Collection Impact26.2.3 Leveraging Asynchronous Programming for Scalability26.2.4 Improving Serialization and Model Binding Performance26.2.4.1 Choosing the Right Serializer26.2.4.2 Reducing Payload Size with DTOs26.2.4.3 Optimizing Serialization Options26.2.4.4 Streaming with IAsyncEnumerable<T>26.2.4.5 Efficient Model Validation and Binding26.2.4.6 Benchmarking Serialization and Binding26.3 Infrastructure and Middleware Optimization26.3.1 Caching Strategies: In-Memory, Distributed, and Response Caching26.3.2 Using Compression and Response Buffering Wisely26.3.3 Optimizing Static File Delivery and Content Caching Headers26.3.4 Fine-Tuning Middleware Pipeline for Minimal Overhead26.4 Monitoring, Diagnostics, and Best Practices26.4.1 Profiling Tools and Performance Diagnostics in ASP.NET Core26.4.2 Logging and Tracing for Performance Bottlenecks26.4.3 Load Testing and Capacity Planning26.4.4 Best Practices Summary for Building High-Performance ASP.NET Core Applications
27. Deploying ASP.NET Core Applications
27.1 Preparing Applications for Deployment27.1.1 Understanding Deployment Models27.1.2 Configuration for Production27.2 Deployment Targets and Strategies27.2.1 Deploying to IIS on Windows27.2.2 Deploying to Linux with Nginx or Apache27.2.3 Containerized Deployments with Docker27.2.4 Cloud Deployment Scenarios27.3 Managing and Maintaining Deployed Applications27.3.1 Monitoring and Logging in Production27.3.2 Applying Updates and Zero-Downtime Deployments27.3.3 Security and Compliance Considerations27.4 Summary
28. Extending ASP.NET Core with Middleware
28.1 Introduction to Middleware28.1.1 The Role of Middleware in the ASP.NET Core Request Pipeline28.1.2 Built-In Middleware vs. Custom Middleware28.1.3 Ordering and Execution Flow28.2 Working with Built-In Middleware28.2.1 Commonly Used Middleware Components28.2.2 Configuring Middleware in the Program.cs File28.2.3 Understanding Middleware Dependencies28.3 Creating Custom Middleware28.3.1 Anatomy of Custom Middleware: RequestDelegate and Invoke28.3.2 Handling Requests and Responses in Custom Middleware28.3.3 Dependency Injection in Middleware Components28.3.4 Reusable Middleware Patterns and Best Practices28.4 Middleware in Real-World Applications28.4.1 Composing Middleware Pipelines for Maintainability28.4.2 Performance Considerations in Middleware Design28.4.3 Debugging Middleware Execution Order28.4.4 Best Practices for Extending ASP.NET Core with Middleware
29. Creating the Final Project: Planning and Setup
29.1 Introduction29.1.1 The Goal of the NoteKeeper Project29.1.2 Integrating Core ASP.NET Core 10 Concepts29.1.3 Looking Ahead to Chapter 3029.2 Project Overview and Requirements29.2.1 Understanding the Problem Domain: Personal Note Management29.2.2 User Stories and Functional Goals29.2.3 Functional Requirements29.2.4 Non-Functional Goals: Simplicity, Responsiveness, and Maintainability29.3 Choosing the Architecture29.3.1 Applying The Standard Layering Approach29.3.1.1 Brokers: Data and File Interaction29.3.1.2 Services: Business Rules, Validation, and Mapping29.3.1.3 Orchestrations: Coordinating Workflows29.3.1.4 Exposers: Blazor Pages and API Endpoints29.3.2 Folder and Namespace Organization29.3.3 Benefits of Separation of Concerns for Testing and Scalability29.4 Technology Stack Selection29.4.1 ASP.NET Core 10 and Blazor Server for the User Interface29.4.2 Entity Framework Core 10 with SQLite for Persistence29.4.3 ASP.NET Core Identity for Authentication (Optional)29.4.4 Dependency Injection and Configuration Management29.4.5 Logging, Caching, and Exception Handling Middleware29.4.6 Unit Testing with xUnit and bUnit29.5 Solution Structure and Setup29.5.1 The Backend Project: Notekeeper.Core29.5.1.1 Project Purpose:29.5.1.2 Current Structure Overview:29.5.2 The Frontend Project: Notekeeper.Web29.5.2.1 Project Purpose:29.5.2.2 Current Structure Overview:29.5.3 Configuring References and Dependencies29.5.4 Setting up appsettings.json and Connection Strings29.6 Designing the Domain Model29.6.1 Understanding the Domain29.6.2 The Note: The Core of the System29.6.3 Tags: Adding Organization and Discovery29.6.4 Attachments: Enhancing Notes with Context29.6.5 Relationships and Data Flow29.6.6 Entity Constraints and Validation29.6.7 Preparing the Model for Data Persistence29.6.8 Using Sample Data for Demonstration29.6.9 Building a Foundation for Growth29.7 Configuration and Secrets Management29.7.1 Environment-Specific Configuration29.7.2 Managing Connection Strings and File Paths29.7.3 Using User Secrets in Development29.7.4 Azure Key Vault Integration29.8 Setting Up the Development Environment29.8.1 Required SDKs and Tools29.8.2 Installing Necessary NuGet Packages29.8.3 Verifying EF Core Migrations and Database Creation29.8.4 Setting Up Git Repository and Branch Strategy29.8.5 Configuring Pre-Commit Checks and Formatters29.8.6 A Ready-to-Build Environment29.9 Summary
30. Building the Final Project
30.1 Introduction30.2 Implementing the Data Layer30.2.1 Setting up the StorageBroker30.2.2 Managing Generic CRUD Operations30.2.3 Implementing Entity-Specific Logic for Notes30.2.4 Defining the IStorageBroker.Notes.cs Interface30.2.5 Managing Data Consistency and Reliability30.2.6 A Robust and Reusable Data Foundation30.3 Implementing the Service Layer30.3.1 Defining service interfaces for Notes, Tags, and Attachments30.3.2 Implementing the NoteService: validation and business logic30.3.2.1 Validation rules in practice30.3.2.2 Exception taxonomy and logging30.3.3 Adding tagging and attachment services30.3.4 Integrating brokers with services using dependency injection30.3.5 Unit testing core service methods30.3.5.1 Negative and exceptional paths30.3.5.2 Recipe for teams30.3.6 What we achieved in the service layer30.4 Implementing the Controllers30.4.1 Why RESTFulSense?30.4.2 Building the NotesController30.4.3 Handling Create Operations (POST)30.4.4 Handling Read Operations (GET)30.4.5 Handling Update Operations (PUT)30.4.6 Handling Delete Operations (DELETE)30.4.7 Centralized Exception Mapping30.4.8 Benefits of Controller Abstraction30.5 Building the Blazor User Interface30.5.1 Overview of the Blazor Component Hierarchy30.5.2 Creating the Main Layout and Navigation30.5.3 Creating the Notes List Component30.5.4 Building Supporting Pages30.5.5 Styling Components with Custom CSS30.6 Integrating the Backend and Frontend30.6.1 Configuring dependency injection for cross-layer communication30.6.2 Implementing the API broker30.6.3 Implementing foundation services that call the API broker30.6.4 Connecting Blazor components to services30.6.5 Data binding and real-time updates30.6.6 Handling API calls and asynchronous workflows30.6.7 Implementing search and tag filtering in the UI30.7 Applying Cross-Cutting Concerns30.7.1 Centralized error handling and validation feedback30.7.2 Implementing logging with ILogger30.7.3 Configuring caching for frequently accessed data30.7.4 Managing localization and date formatting30.8 Testing the Application30.8.1 Testing philosophy and structure30.8.2 Writing unit tests for the service layer30.8.3 Handling validation and exception scenarios30.8.4 Using bUnit to test Blazor components30.8.5 Mocking dependencies and simulating workflows30.8.6 Running tests via CLI and Visual Studio30.9 Summary
Index

Overview

ASP.NET Core 10 is finally here. Dive into the most encompassing update to Microsoft’s framework for developing web apps using the all-new .NET 10 framework. This book continues the legacy of the classic, bestselling ASP.NET Core manual but with 100% new material. Create modern, high-performance web apps with ease.

In this completely new manual, gain a deeper understanding of ASP.NET Core for .NET 10 and dives deep into the tools and techniques required to build modern, extensible web applications. New features and capabilities such as enhancements to the minimal hosting model, improved Blazor capabilities with a unified template, and advanced routing options, and optimizations for performance and security. For each of these topics, make the abstract concrete with real-world examples.

Starting with the nuts-and-bolts topics, learn about middleware components, built-in services, request model binding, and more. As you gain knowledge and confidence, the author introduces increasingly more complex topics and advanced features, including endpoint routing and dependency injection.

What You Will Learn

Explore the entire ASP.NET Core 10 platform
Apply the new ASP.NET Core for .NET 10 features in your developer environment
See how to create RESTful web services, web applications, and client-side applications
Build on your existing knowledge to get up and running with new programming models quickly and effectively

Who This Book Is For

This book is for web developers with a basic knowledge of web development and C# who want to incorporate the latest improvements and functionality in ASP.NET Core 10 into their own projects.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9798868818929Purchase Link Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills