Advanced Web Development with .NET 6 and Angular

ASP.NET and ASP.NET Web API

Part 1 - 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

Filters

Filters allow to you add behavior in the request processing pipeline to keep repetitive code out of your controllers.

• How Filters Work
• Authorization Filters
• Action Filters
• Result Filters
• Exception Filters
• Service and Type Filters
• Filters versus Middleware

Minimal APIs

With ASP.NET Core we get a new model for building web apps: Minimal API. This does change some of the ways you work with ASP.NET Core.

• Benefits of Minimal APIs
• Routes and Handlers
• Model Binding and Return Types
• Code Organization
• Endpoint Filters
• Route Groups
• LAB: Managing Contacts with Minimal APIs

SignalR

Add real-time web functionality to your application.

• What is SignalR?
• Server Concepts
• Building SignalR Clients with C# and JavaScript
• LAB: Building an emergency dashboard with SignalR

Efficient Communication with gRPC

With gRPC you can setup efficient communication between two parties using modern Remote Procedure Call.

• What is gRPC?
• Defining your contracts
• Implementing your contracts on the server
• Generating a Proxy and using it on the client

Understanding Claims-Based Security

So what will you allow your user to do? This most likely depends on the role the user has in your organization. This role is now represented with claims. In this chapter you will get a better understanding why claims are better than roles, and how claims are transmitted in a secure way as tokens.

• Representing the user
• Introducing claims-based security
• Understanding tokens and their representation on the net
• Using Claims in .NET
• LAB: Authenticating a web site with claims

Modern web Authentication and Authorization

In the modern web we all want to share stuff. But how do you safely allow one web site to access resources from another web site? With OpenID Connect you can delegate authentication to an identity provider (such as Facebook, Azure AD, Identity Server and others).

• The Internet and a way of sharing
• Introducing OAuth and OpenID Connect
• OAuth Fundamentals: Authorization Code Grant, Implicit Grant and Client Credential Grant
• Implementing OpenID Connect web sign-in with AzureAD and Identity Server
• LAB: Protecting your ASP.NET Core site with OpenID Connect

Protecting a Web-API with OpenId Connect

Modern web sites and mobile appls consume REST services. You can use OpenID Connect to authenticate users, after which you can use claims to authorize resources stored in a web API.

• Protecting a Web API's Resources
• Adding permissions to the Server Side
• Requesting Permissions at the Client Side
• Using the Microsoft Authentication Library (MSAL)
• User Consent
• LAB: Getting an access token and passing it to the server

Hosted Services

With Hosted Services you can run background tasks in your website

• What is a Hosted Service
• Timed background tasks
• Queued background tasks
• Asynchronous timed background task
• LAB: Building a Hosted Service

Part 2 - Mastering Angular

Reactive Extensions for JavaScript

Reactive programming is a world on its own and is not necessarily tied to Angular. However Angular uses RxJS in many of its APIs, so we must have a proper understanding of what it means to write reactive code. RxJS has a steep learning curve. But once you master it, there is no going back.

• What are Reactive Extensions
• Observable and Observer
• Subjects
• Cold versus Hot Observables
• Making Async Calls
• Combining Observables
• Error Handling
• Dealing with Back Pressure
• LAB - Spotify Search with Observables

Change Detection

This module will teach you about the internals of Angular. This knowledge is primarily useful for performance tuning and debugging strange behavior.

• Zones
• How Change Detection Works
• Immutables and Observables
• Signals
• LAB - Optimizing Performance in an Angular Application

State management with NgRx

With the increasing complexity of client-side applications, a lot of state has to be kept. It's quite a challenge to keep all state consistent. Redux introduces a pattern to manage this state in a convenient way, while keeping your UI up to date as well. NgRx is the favorable implementation of Redux for Angular.

• The Redux Pattern
• Major Principles
• The Store, Actions and Reducers
• Using RxJS within Redux
• Efficient Slicing
• Using Async Pipes
• Tools

The NgRx Store

• Responsibilities
• Normalizing Data
• Initializing the Store

NgRx Reducers

• Useful Operators
• Splitting Up Reducers
• NgRx Effects
• LAB - Building a NgRx Store

Smart and Dumb Components

Should everyone be able to talk everything? No! Here we learn how to avoid chaos by splitting up our component into smart and dumb ones.

• Characteristics of Dumb Components
• Characteristics of Smart Components
• Performance Impact
• LAB - Integrating a NgRx Store into your Angular Application

Structuring an Application

Applications grow larger, code bases become unmanageable. Unless you structure them right.

• Domain, Routing, Core and Shared Modules
• Exporting and Providing
• Clean Imports
• Creating Libraries
• LAB - Structuring a more Complex Angular Application

Forms Advanced

Being able to dynamically add input elements to a form is incredibly useful for applications. This chapter looks at how to do exactly that in Angular.

• Dynamically Adding Elements
• FormArray
• Nested Forms
• LAB - Forms array and nesting