Advanced ASP.NET Core Development

Application Architecture Overview

If you think good architecture is expensive, try bad architecture. As modern applications become more feature rich, the need for a solid foundation becomes more important. In this module, we will discuss the most proven architectural styles and how they can be implemented in ASP.NET Core.

• Clean Architecture & Domain-Driven-Design
• Centralized VS. Distributed Applications
• Event-driven Architecture
• Highly Decoupled Applications using Microservices
• Modular Monoliths: Most of the Benefits of Microservices, None of the Deployment Pitfalls

ASP.NET Core Developer Tools

• Visual Studio for ASP.NET Core
• Hot Reloading
• .NET Templates
• Visual Studio Code and .NET CLI
• Copilot Tips and Tricks: Getting the most out of your Assistant

ASP.NET Core Pipeline

ASP.NET Core is several times faster than ASP.NET Framework. How did they do this? By removing all 'fat' from the request processing. Here you will learn how the configure the ASP.NET Core pipeline, and we will examine some of the built-in middleware.

• Understanding the principle of the ASP.NET Core Pipeline
• Configuring the pipeline in the Program class
• Understanding Dependency Injection
• Diagnostic Middleware
• Using HTTPS and the HSTS header
• Serving Static Files
• Configuring Routing
• Understanding Sessions and Caching
• Exploring other built-in middleware
• LAB: Building an ASP.NET Core web site by configuring middleware

Dependency Injection Best Practices

• Dependency Injection in ASP.NET Core
• Grouping and Managing Dependencies
• Lazy Loading Dependencies
• LAB: Optimizing Dependency Injection in Libraries

Building Custom Middleware for ASP.NET Core

The Open Web Interface for .NET brought a simple standard way for building web servers with .NET. ASP.NET Core built upon this standard and with it you can easily build your own custom extensions.

• Building your own custom middleware
• Testing your middleware
• LAB: Building a custom middleware class and testing it

ASP.NET Core Configuration

ASP.NET Core allows you to pick and choose where to store your configuration. No more deploying configuration with production settings in source control! We will look at the idea behind this and of course how to choose your ideal configuration.

• Different ways of getting configuration to your code
• Storing sensitive configuration in Secrets
• Using Azure App Configuration
• Using the Options Pattern
• Adding your own Configuration Providers
• LAB: Using ASP.NET Core Configuration and Feature Toggles

Logging, Monitoring and Telemetry

Proper logging is essential to find problems while developing and in production. But just storing some logs doesn't really help you if you don't use them. By monitoring your logs and metrics, and setting up alerts when something goes wrong, you can fix problems before they get out of hand.

• Choosing from different Logging Providers
• Understanding Logging Scopes
• Capturing and Exporting Metrics, Traces, and Logs using OpenTelemetry
• Monitoring your Application
• Setting up Alerts
• LAB: Logging and Monitoring

Building Real-time Applications with SignalR

Today's modern apps are expected to deliver up-to-date information without hitting a refresh button. Add real-time functionality to your dashboards, maps, games and more. In this chapter, we'll discover how you can leverage SignalR to build real-time applications.

• What is SignalR?
• SignalR Use Cases and Best Practices
• Server Concepts
• Building SignalR Clients with C# and JavaScript
• LAB: Using SignalR in a Distributed Application

Efficient and Resilient Communication

Whether your backend is exposed as a REST API, or you need to integrate with other applications, your application needs to communicate. In this chapter, we'll take a look at how to make that communication efficient and resilient. From configuring your HttpClient correctly to making sure you never drop a message, we'll cover it all.

• HttpClient Best Practices
• Creating and Configuring Health Endpoints
• Never Drop a Message using Resiliency Handlers
• LAB: Using the Circuit Breaker Pattern

Remote Procedure Calls with gRPC

gRPC is a high-performance, open-source universal RPC framework. It's widely used in the industry and is a great way to build efficient APIs.

• What is gRPC?
• Defining your contracts
• Implementing your contracts on the server
• Generating a Proxy and using it on the client
• LAB: Service to Service Communication with gRPC

Working with Data Stores: More than just SQL Databases

Backend developers are typically tied to their relational databases, while Frontend developers often favor NoSQL. So, which one is better? Well, both can be great, but sometimes the unknown is unloved. Besides that, we also need to consider caching, spreading data over multiple data stores, and performance.

• Permanent Storage: SQL or NoSQL?
• Caching Data for Quick and Convenient Access
• Spreading and Combining Data using Multiple Data Stores
• LAB: Working with multiple Data Stores

Internationalization

The world is a big place, with many spoken languages. If you want to reach the world, you should build multi-language support in from the beginning.

• Display Content in Different Cultures
• Using resource files
• Autodetect Cultures
• LAB: Adding language support to an ASP.NET Core web site