REST APIs with C# .NET

Prerequisites#

• Getting Started with Git
• Getting Started with C# .NET
• Software Architecture & Design Principles in C#
• Entity Framework Core

Initial Setup#

1. Install Chocolatey to manage all software in Windows
2. Install Visual Studio Code
3. Install MySQL
4. Install MySQL Workbench
5. Install Docker Desktop
6. Install Git

Dependency Injection#

1. AddSingleton(), AddScoped() & AddTransient() in a .NET 7 Web API
   • Intro
   • The Web API Project
   • AddSingleton()
   • AddScoped()
   • AddTransient()

Repository Pattern#

1. The Repository Pattern explained for EVERYONE (with Code Examples)
   • Intro
   • Repository Pattern Definitions
   • Code Example with a .NET 7 Web API in C#
   • Build a Repository
   • Inject the Repository in the Controller
   • Register the Repository/Service
   • One More Beauty of Dependency Injection & the Repository Pattern

Authentication and Authorization with JWT#

1. Create JSON Web Tokens (JWT) - User Registration / Login / Authentication

   • Intro
   • Add the AuthController with the Register() Method
   • Install the BCrypt.NET NuGet Package
   • Test the User Registration
   • Implement the Login() Method
   • Test the Login() Method
   • Create the JSON Web Token
   • Final Test

2. Stay Fresh: .NET 7 Web API Refresh Tokens

   • Intro
   • Add the Refresh Token Model
   • Change the User Model
   • Implement the RefreshToken logic in the Controller
   • Refresh the RefreshToken

3. Role-Based Authorization with JSON Web Tokens (JWT) & the dotnet user-jwts CLI

   • Intro
   • Secure Your Web API with the [Authorize] Attribute
   • Configure Your Web API to use JSON Web Tokens
   • Use the new dotnet user-jwts CLI of .NET 7
   • First Test with Swagger
   • Configure Swagger to provide a JWT
   • Use a Token from the dotnet user-jwts CLI
   • Add Roles
   • Validate the Issuer Signing Key
   • Set a Role using Claims

4. How to Read Claims of a JSON Web Token in a .NET 7 Web API

   • Intro
   • Use the API Controller
   • Use a Service instead of the Controller

REST API#

1. .NET 7 Web API & Entity Framework → Full Course (CRUD, Repository Pattern, DI, SQL Server & more)

   • Introduction
   • Create a Web API Project
   • Solution Overview
   • Start Building a Web API - Add a new Model
   • Add the Controller
   • Write the GET method
   • Test the GET Method with Swagger
   • GET a Single Hero
   • Add a Hero with POST
   • Update a Character with PUT
   • DELETE a Hero
   • Use the Repository Pattern by creating a Service
   • Make use of Dependency Injection
   • Refactor all CRUD Operations (using the Service)
   • Register the SuperHeroService in the Program.cs
   • Test all CRUD Operations after adding the SuperHeroService
   • Add Entity Framework 7
   • Install EF Tools & NuGet Packages
   • Install SQL Server Express & SQL Server Management Studio
   • Implement the DataContext/DbContext
   • Add the ConnectionString
   • Add the DbSet
   • Register the DataContext
   • Run Code-First Migrations
   • Check the Migrations in SQL Server Management Studio
   • Add a Hero in the Database manually
   • Use Entity Framework in the SuperHeroService
   • Final Tests & Fixes

2. Improve the developer experience of an API with Swagger documentation

   • Introduction
   • Document an ASP.NET Core Web API with Swagger tools
   • Exercise - Enable OpenAPI documentation in an ASP.NET Core Web API app
   • Enrich your OpenAPI documentation with XML comments and annotations
   • Exercise - Customize and extend your OpenAPI documentation with XML comments and annotations
   • Knowledge check
   • Summary

Microservices#

1. Create microservices with .NET and ASP.NET Core
   • Build your first microservice with .NET
   • Deploy a .NET microservice to Kubernetes
   • Create and deploy a cloud-native ASP.NET Core microservice
   • Implement resiliency in a cloud-native ASP.NET Core microservice
   • Instrument a cloud-native ASP.NET Core microservice
   • Implement feature flags in a cloud-native ASP.NET Core microservices app
   • Use managed data stores in a cloud-native ASP.NET Core microservices app
   • Understand API gateways in a cloud-native ASP.NET Core microservices app
   • Deploy a cloud-native ASP.NET Core microservice with GitHub Actions

Exercises I#

1. Create ToDoList API project.
2. Use Visual Studio Code as your IDE and MySQL as the database.
3. For database diagram, you could follow this video as your references.
4. Use EF Core and Code-First Migrations.
5. Implement Dependency Injection and Repository Pattern.
6. Use Mapster to map the models (if needed). Follow the tutorial here
7. Log any error using Serilog. Follow the tutorial here
8. Implement Authentication (JWT with refresh token). Only authorized user can access TodoItem’s API.
9. Create unit tests using xUnit. Follow the tutorial here
10. Containerize the Web API project and MySQL using Docker. Check this tutorial for your references.
11. Push your project to your private repository in TSP’s Gitlab.

Clean Architecture & DDD#

1. ASP.NET 6 REST API Following CLEAN ARCHITECTURE & DDD Tutorial
   • Project Setup
   • Generating JWT Tokens
   • Repository Pattern
   • Global Error Handling
   • Flow Control
   • CQRS & MediatR
   • Object Mapping - Mapster
   • Validation Behavior | MediatR + FluentValidation
   • JWT Bearer Authentication in ASP.NET 6
   • Mapping Software Logic Using Process Modeling
   • 3 Steps for Modeling a Complex Domain
   • Implementing AggregateRoot, Entity, ValueObject
   • Domain Layer Structure & Skeleton
   • REST + DDD + CA + CQRS - When it all plays together
   • EF Core, DDD, and Clean Architecture - Mapping Aggregates to Relational Databases
   • The Identity Paradox
   • Domain Events
   • The complete guide to unit testing structure best practices