Creating .Net Core Microservices using Clean Architecture

Explore catalog microservices built with clean architecture, spanning api, application, core, and infrastructure layers, driven by docker compose and a MongoDB backend with custom mappers.

Create a new blank solution in Visual Studio 26 for a clean architecture ecommerce project, name the solution 'e-commerce', and initialize with a basic skeleton before building the catalog microservice.

Set up a clean architecture for the catalog microservice by scaffolding a solution with a services folder, creating catalog api, and adding catalog.application, catalog.core, and catalog.infrastructure libraries, then build succeeds.

Learn how to set up correct project references in a clean architecture for .NET core microservices, linking API, application, infrastructure, and core layers, and validating by rebuilding.

Explore adding NuGet packages for a .NET Core microservices project, including swagger with Swashbuckle, mediator for CQRS, and the MongoDB driver for MongoDB integration.

Create a base entity blueprint for all domain models by defining a MongoDB-backed base class with an ID property and serialization attributes, then scaffold product-related entities.

Create product brand and product type entities in a clean architecture project, using a base entity for id, adding a name property, applying on element annotation, and rebuilding to verify.

Create a product entity from the base entity, including name, summary, description, image, brand name, type name, price as decimal 128, with created and updated dates, plus interfaces and repositories.

Create repository interfaces for product brands and types, with get all and get by id (async), then outline a product repository using the specification pattern and a pagination class.

Create a generic pagination class in a clean architecture project, with page index, page size, count, and read-only data collection of T where T is a class, plus a specification.

Create catalog specification params for a .net core microservices app, defining max page size, page size, and page index with validation, plus optional search and sort options.

Create the iProductRepository interface with async operations for products, including getAllAsync, getProducts with pagination and specParams, and filters by name or brand and ID, plus getProduct by ID.

Implement a brand repository for a .NET core microservice using clean architecture, configure the MongoDB client, read the connection string from app settings, and access the brand collection.

Implement a type repository in the .net core microservices project by creating a types collection, implementing its interface, and reusing the pattern from the brand repository.

Implement a Mongo-based product repository with constructor injection and configuration, implementing iProductRepository and providing create, delete, get, update, and search by name or brand with catalog spec params.

Implement a dynamic product repository using specification patterns to filter by search, brand ID, and type ID. Build and apply data filters with sorting and pagination for efficient results.

Explore replacing config with IOptions to bind strongly typed database settings, inject options in repositories, and wire up the Mongo client via program.cs for safer, testable configuration.

Define and prepare database seed data in the infrastructure layer by adding JSON seed collections for brands, products, and types, and configure copy to content for MongoDB seeding.

Create a database seeder class to seed brands, types, and products from JSON files at startup, using a seed path, async reads, and Mongo-generated IDs.

Create product, brand, and type dto records in the application layer to model immutable data carriers for API requests and responses, using explicit mappers and value-based equality.

Create dto responses first by adding a responses folder, define record-based response types with init properties for id and name, and prepare mappers for the mediator-based cqrs flow.

Create the get all brands query and implement its handler in the application project, set up queries, commands, handlers, and mappers, and prepare a brand response dto for the controller.

Create a get all brands handler using mediator, fetch brands from repository, map entities to brand responses, and expose a DTO list for the UI.

Implement a get all types query and handler, inject the type repository, and map results to a types response with a custom mapper, mirroring the brands pattern.

Implement get all products query and handler with pagination, fetch products via repository, and map them to a paginated product response using a product mapper.

Implement a get product by brand query and its handler. Wire repository calls, map to product responses, and return the list.

Create a get product by id query and its handler to retrieve a product by id from the repository and return a product response.

Create a get product by name query and its handler in a clean architecture microservices project, implementing the query to return a list of product responses from the repository.

Implement a create product command and its handler with CQRS, map command to entity, validate brand and type via repository, and persist the new product.

Update product command and handler fetches the existing product by id, validates brand and type, maps updates to an entity, saves changes, and returns a boolean.

Implement delete product by id command and handler in a clean architecture CQRS setup. Wire a repository call to delete and return a boolean, shaping the API layer.

Build a catalog API controller in clean architecture, leveraging a mediator pattern to serve get all products, get product by id, and get by name with product DTO mapping.

Learn to build the catalog controller for creating, updating, and deleting products with post, put, and delete endpoints using mediator commands, dto handling, and a product mapper.

Fixes create product dto to match the update product dto and implements an explicit api to command mapper in a clean architecture net core microservices setup, with price as decimal.

Create a catalog controller with endpoints to get all brands, get all types, and get products by brand name, using mediator to return brand, type, and product DTOs.

Wire up all components in program.cs by configuring custom MongoDB serializers for GUID and date time offset serializers as strings for readability, and register controllers, swagger, and mediator.

Configure launch properties for .NET core microservices by naming profiles, setting ports 8000 and 5000, enabling swagger and automatic browser launch, and preparing Docker MongoDB integration.

Set up docker for a dotnet core microservice, enabling container and docker compose, with a multi-stage build and catalog db using mongo and environment overrides.

Demonstrates catalog microservice setup with docker-compose, fixes Mongo data volumes, seeds data, and tests APIs like get products, get brands, types, and create or delete products on port 8000.

Build the basket microservice backed by Redis using clean architecture, implementing the basket API, application core, and infrastructure, with create, query, and delete operations and a calculated total price.

Set up a basket microservices solution with an ASP.NET Core web API, enable docker container support on Linux, and wire basket core, application, and infrastructure projects with references.

Install the required NuGet packages for the basket api, including Swashbuckle.AspNetCore for OpenAPI and MediatR, and add StackExchange.Redis via Microsoft.Extensions.Caching.StackExchangeRedis.

Create a basket checkout entity with username, total price, address details, and card details, then define shopping cart and cart item entities for the checkout flow.

Create shopping cart item and shopping cart entities for a .NET Core microservice using clean architecture, including quantity, unit price, product id, image, and a username with item list.

Create basket repository in a clean architecture setup by adding repositories folder and an iBasketRepository contract with get basket, update or insert, and delete basket by username to manage carts.

Implement a basket repository in the infrastructure layer, using a distributed cache and Newtonsoft.Json to serialize and deserialize shopping cart data by username, including get, set, and delete operations.

Create the application layer folder structure for .net core microservices, including commands, queries, responses, mappers, and dtos, and set up handlers to map responses early.

Model shopping cart response DTOs in a net core microservice using record classes with init properties, including item responses and a total price calculated from item price multiplied by quantity.

Implement a get basket by user name query and handler using mediator, fetch the shopping cart from the repository, and map it to a shopping cart response with item details.

Explore delegate based mapper using func to map between shopping cart and shopping cart response, comparing single and two response approaches in clean architecture style.

Implement a delete basket by username command and handler in a clean architecture microservice, using a string username, a unit return, and a basket repository to perform the deletion.

Create basket and cart item dtos for a .NET microservice, modeling product id, name, image, price, and quantity with positional parameters, plus a cart with user name and total price.

Create a shopping cart command and handler, convert the command to a domain entity, persist via the basket repository, and return a response mapped from the updated cart.

Create a basket controller in the api layer and wire MediatR to handle get basket by username query, create shopping cart command, and delete basket by username command.

Wire up program.cs by adding a cache settings poco with a connection string bound from app settings via the options pattern, configure mediator and stack exchange radius cache at localhost:6379.

Fix the program.cs issue by using the action radius cache options overload and removing the service provider. Build succeeds; prepare to move to the next video.

Adjust launch properties for basket API and catalog, align http/https ports and profiles, and prepare dotnet run with swagger in a dockerized container.

Update docker file and compose to enable orchestration and automatic assembly scanning, add basket and catalog services, configure basket DB and environment settings, then verify with a successful rebuild.

See a from-scratch basket microservice demo using docker, building layers, and composing the e-commerce stack with .NET, Redis, and Mongo, then test create and delete operations.

Kick off a discount service from scratch using clean architecture, docker, and gRPC with protobuf to Postgres; the basket api will consume it to apply coupons.

Create a discount module with a solution folder and four projects: discount.api, discount.application, discount.infrastructure, and discount.core, wire their references, and build to verify compilation.

Install NuGet packages for the infrastructure layer—dapper, gRPC asp.net core, PostgreSQL, mediator, and gRPC library—while noting swagger is unnecessary for the http2 protobuf based discount and basket services.

Create the coupon entity in the core layer of a clean architecture .net microservices project, defining id, product name, description, and discount amount, and outline the repository signature.

Create a discount repository by adding a repositories folder and implementing get discount, create discount, update discount, and delete discount methods based on product name using a coupon object.

Add a database settings class in the infrastructure settings with a connection string. Register it in program.cs by reading from app settings to enable the repository to use Postgres.

Implement a discount repository in the infrastructure repositories folder using the Dapper micro ORM to perform get, delete, update, and no discount logic for coupons by product name.

Develop the discount query and its handler within a clean architecture, organizing queries, commands, handlers, and mappers, and define a coupon dto with validation and mapping.

Create a coupon mapper for a .NET core microservice, mapping id, product name, description, and amount to a dto using static and delegate patterns as syntactic sugar.

Create a discount command and handler, validate input, convert to a discount entity, persist via IDiscountRepository, and return a coupon DTO.

Create the update discount command and its handler, wiring validation for product name, description, and amount. Map to entity, update via the repository, and return a discount DTO.

Create a delete discount command and handler, validate the product name, and implement the CQRS pattern with a discount repository to return a boolean indicating success.

Seed the database on startup via an infrastructure extension that migrates the database with database settings and retries while inserting adidas quick force indoor and unix racket coupons.

Apply iOptions to retrieve the current configured database settings from the DI container and inject them where needed. Rebuild confirms the configuration works and prepares for creating the protobuf file.

Create discount.proto in a protos folder with proto3 syntax to define message contracts, rpc methods for get, create, update, delete discount, and configure protobuf compiler for grpc code on server.

Create a discount gRPC service from a protobuf contract by generating server and client stubs, then implement a discount service with a mediator and mapper to expose a coupon model.

Implement asynchronous create, update, and delete discount commands, map DTOs, and send commands via mediator, then build and wire program.cs to finalize the discount service.

Configure and wire the program.cs file to run on an http/2 Kestrel endpoint, set up gRPC services, mediator pipelines, and repository registrations, then migrate the database and map gRPC endpoints.

Add docker capabilities to the dotnet core microservices by configuring docker compose for catalog, basket, and discount databases, building images, and launching services with docker compose up.

Learn to consume the discount microservice within the basket microservice using a gRPC client, connect the basket API to the discount service, and apply discounts to prices.

Install and configure essential NuGet packages for gRPC in a basket microservice, including grpc.aspnet, grpc.aspnet core, grpc.net.client, and grpc.tools.protobuf, then prepare the protobuf file for code generation.

Create a protos folder and proto client that stay in sync with server changes to the discount API, generating client code as a gRPC service in the application layer.

Create a gRPC discount service in the basket app, generate client and server code from protobuf, and implement an async GetDiscount by product name to adjust billing.

Inject the discount gRPC service into the create shopping cart handler and apply discounts by calling get discount per product name, adjusting item prices by coupon amount.

Configure a .NET Core microservice to use gRPC by adding a Settings folder and gRPC settings class, wiring gRPC client in program.cs, and using app settings for the discount URL.

Address a gRPC logging dependency injection issue by registering the logger in the discount service, then rebuild images and run containers to test integration with the basket service.

Demonstrate a basket microservice in .NET core, integrating a discount service with docker compose and gRPC, plus logging and testing with seeded data and pricing.

Explore building an ordering microservice with SQL Server backing, saga pattern and async messaging. Implement plain CQRS with custom abstractions across the application and infrastructure, without using mediator.

Define a clean architecture for ordering microservices by creating ordering.api, ordering.application, ordering.infrastructure, and ordering.core projects, wiring references, and validating the build.

Create core layer entities by adding an entity base class in the entities folder and an order entity derived from it, with audit properties and user, address, and card details.

Create an IAsyncRepository interface with generic CRUD operations for entities, including get all, get by id, add, update, and delete, using async patterns and predicate-based querying.

Create an order repository interface by extending a generic async repository for the order entity, and add a custom method to get order by user name.

Create a SQL Server backed DbContext in a clean architecture project by wiring an order context, defining Orders DbSet, and applying audit fields (created and last modified) during SaveChangesAsync.

Implement a generic async repository base for EF Core that supports add, delete, get all, get by id, and update using an order context and no-tracking queries.

Implement a dedicated order repository by extending the repository base and implementing IOrderRepository. Wire in the order context, apply no-tracking for performance, and filter orders by username.

Define ordering DTOs by creating a create order DTO with username, total price, first name, last name, email, address, and card info, plus an order DTO with an id.

Learn to replace mediator-based CQRS with a clean command pattern and a feature-focused folder structure for orders, including commands, queries, and mappers.

Create a clean cqrs abstraction layer by defining marker interfaces for commands and queries, plus command and query handlers, using contravariant and covariant generics to enable flexible dispatch.

Create a get order list query and its handler to fetch orders by username via the order repository, then map to order DTOs in a cqrs pattern without mediator.

Create a custom order mapper with a static to-dto method mapping order fields to an order dto, handle nulls, and fix the dto constructor by adding expiration.

Create an order command and handler in a .NET core microservice with clean architecture. Map the command to an order entity, persist via the repository, and return generated order id.

Create a delete order command and handler in a clean architecture .NET core microservice, implement command interfaces, inject IOrderRepository and logger, check by id, delete async, and log actions.

Create a custom order not found exception in the application layer by deriving from application exception, with a constructor that accepts name and key value pair to improve reuse.

Create update order command and handler, fetch the order by ID, validate existence, apply updates via a mapper, persist with update async, and log the success.

Create an order command validator with fluent validation, installing the NuGet package and enforcing not empty fields, max length 70, non-negative price, and card validations (number, MMYY, CVV).

Create the update order command validator in a .NET Core microservice, deriving from abstract validator to enforce id not empty and greater than zero, with explicit CQRS enforcement.

Learn to implement a validation behaviour as a decorator for command handlers in dotnet core, wiring fluent validation validators to validation context and throwing a validation exception to fail fast.

Implement an unhandled exception behavior decorator for generic command handlers, log the error, and rethrow to integrate with the mediator pipeline in a .NET core microservices clean architecture.

Create a design-time db context factory for the order context, load configuration from app settings, configure the connection and retry logic, apply migrations, and prepare for seeding.

Seed the order context with a dedicated seed and wire it into program.cs for asynchronous execution, creating a Rahul seed record with dummy data, audit fields, and saving changes.

Create and wire a service collection extension to centralize dependency injection for a .NET core microservice, configuring SQL Server, repositories, CQRS handlers, fluent validation, and decorator pipelines.

Wire the program.cs file by wiring ordering services with CQRS and infra components using builder.configuration, update app settings for the order connection string, and keep controllers, OpenAPI, and maps intact.

Create a db extension that migrates the database at startup, using a hosted extension method on IHost, with a Polly-based retry policy and a seeder to initialize data.

Implement database seeding in program.cs by pairing migrate database with order context seed. Use services and a logger to run the seed asynchronously at startup and wait for completion.

Understand creating an orders controller in a dotnet core microservice using clean architecture, with explicit CQRS, mediator pattern, and handlers for create, update, delete, and get orders by username.

Add docker support and container compose to the ordering api, seed the order db with a volume, and apply migrations using dotnet ef migrations add initial create.

Navigate a .NET 10 EF core tooling issue by pivoting to a micro orm with dapper to continue building microservices in clean architecture, planning future fixes when tooling matures.

Fix the typo in ordering.infrastructure that disrupted dependency injection and entity framework mappings, then run dockerized migrations and seed data with swagger enabled to make the ordering microservice work.

Publish the basket checkout event to RabbitMQ, and have the ordering microservice subscribe, completing the basket checkout workflow in a disconnected, clean architecture for net core microservices.

Create an infrastructure project as a reusable class library for a pub-sub architecture, starting with a message broker, shared event definitions, and base integration events for .NET 10.

Create a base integration event with correlation id, creation date, and audit fields to accompany all events, enabling cross-service tracing and time travel debugging across microservices.

Inherit the base integration event to create a basket checkout event and include basket entity properties. Define an event bus constant for the basket checkout queue to route messages.

Connect the basket microservice to the event bus by adding a project reference to the event bus messages project and installing MassTransit packages to relay messages to the broker.

Create a basket checkout command and handler using CQRS and mediator, publish a basket checkout event via mass transit, and trigger basket deletion post-checkout.

Create a .NET microservices basket mapper with to-entity and basket checkout mappings, transforming response data into shopping cart items and a basket checkout event including user, address, and payment details.

Implement a basket checkout endpoint by adding a post action in the basket controller that accepts a checkout DTO and dispatches a basket check out command via mediator, returning 202.

Register mass transit in basket api program.cs and wire rabbitmq as the event bus, using host configuration; mirror the consumer setup in the ordering microservice.

Install NuGet packages within the ordering microservice's application layer and maintain version consistency. Add project references to event bus messages, then implement the consumer in the ordering service.

Learn to implement a basket ordering consumer using MassTransit, mapping basket checkout events to a checkout order command, wiring CQRS handlers, and logging through a mediator-driven workflow.

Wire up the ordering program.cs by configuring mass transit as a rabbitmq consumer, map basket ordering consumer, set event bus settings, and recreate the docker file for infrastructure.

Set up docker container support for basket and ordering microservices, configure rabbitmq and compose overrides, and rebuild images to run a containerized .net core microservices architecture.

Show how to perform end-to-end basket checkout in a .net core microservices setup by downgrading mass transit to resolve licensing and using RabbitMQ and docker compose for async checkout.

Kick off the course by exploring the Saga pattern and outbox-driven microservices, implementing atomic transactions with domain-driven events, and building a message dispatcher as a background job.

Explore the saga pattern for long-running distributed transactions, using forward and compensating actions, with orchestrator and choreography approaches, and understand eventual consistency and the outbox pattern.

Define an outbox message entity with base audit properties, correlation id, and processing timestamps to support saga and outbox patterns in order processing.

Define an order status enum with pending, paid, and failed, and extend the order with a status property initialized to pending on creation and updated when the message broker executes.

Extend the order context with an outbox pattern using Entity Framework, adding outbox messages with id, correlation id, content, occurred on, and processed on for reliable messaging and faster lookups.

Extend the iOrderRepository to support outbox messaging by adding an AddAsync(outboxMessage) method and implementing it in infrastructure with orderContext.outboxMessages.AddAsync and save changes async, preparing for checkout handler updates.

Extend the create order handler to persist an outbox entry by mapping the order, serialize content to json, and define outbox message types for order created for correlation.

Create a background outbox dispatcher that reads pending events from the database and publishes them to RabbitMQ via MassTransit, marking them as published with UTC timestamps to prevent dual writes.

Register outbox message dispatcher in Program.cs as a hosted background service with mass transit, scanning pending messages and publishing to the broker, and upgrade EF migrations to apply outbox table.

Execute ef migrations to add the outbox table and apply database updates, then rebuild and run docker compose to validate the ordering microservice and outbox pattern.

Demonstrates managing .Net core microservices with docker, including outbox table demo, saga flow, and dockerized checkout that publishes to message broker, while handling SQL Server readiness and pending state.

Orchestrate a microservice saga from basket checkout to order creation using the outbox pattern and RabbitMQ. Publish payment outcomes with correlation IDs to update ordering and finalize the order.

Create a lightweight payment microservice as a simple API project under e-commerce services, avoid clean architecture for now, and start with a background service while removing the weather forecast pieces.

Install and restore NuGet packages directly from the current project, add the event bus messages dependency, and wire up project references to prepare the payment microservice for the consumer phase.

Develop and wire an order created consumer in the payment microservice using MassTransit iConsumer to handle order created events, simulate payment processing, and publish payment completed or failed events.

Complete the order creation consumer by publishing a completed event on success or a payment failed event on error, including order ID and correlation ID, and the failure reason.

Wire up program.cs by configuring mass transit, registering the order created consumer, and defining RabbitMQ queues such as order created queue, payment completed queue, and payment failed queue.

Extend the listeners to react to payment outcomes events and update order state, enabling the saga orchestrator to apply the payment result to the saga step.

Create a payment failed consumer in a .net core microservice, wire it to the order repository and logger, update the order status on failure, and log the failure reason.

wire up the ordering api in program.cs by registering basket checkout, payment completed, and payment failed consumers, configure endpoints and queues, and prepare docker configuration for payment.

Set up docker for a dotnet core microservices project by configuring profiles, ports, and docker compose, then build and run ordering and payment containers.

Fix a payment service registration issue by undoing a misplaced mass transit setup, correctly wiring the DI, rebuilding the app, and proceeding to the next video demo.

Demonstrates saga orchestration using an outbox pattern in a .net core microservices setup. The demo covers basket API operations, checkout, order state changes, and RabbitMQ messaging.

Build an in-house identity layer with ASP.NET Core Identity, implement token creation and validation with claims for mobile, web, and Angular clients, including access and refresh tokens.

Create a simple identity microservice to handle authentication and authorization, using a dedicated identity project under services, with optional container support and straightforward template setup.

Create an application user model inheriting IdentityUser and an identity db context to map EF Core identity tables and enable migrations with custom fields like first name and last name.

Modify app settings to use an identity connection with sql server, implement token based authentication, and configure issuer, audience, and a 60 minutes token expiry for stateless security.

Wire up program.cs to configure EF core identity with the app identity db context and SQL server. Enable JWT authentication, token validation, and authorization, and integrate swagger for API documentation.

Create dto types to exchange data over the wire via folders. Define a register dto with first name, last name, email, and password, and a login dto for the controller.

Create an authentication controller for net core microservices using identity, implement register and login endpoints with user manager, generate jwt tokens with claims and signing keys.

Update launch settings by keeping identity, adjusting payment ports to 5005 and 8005, enable launch browser and swagger url, and note Docker changes will follow in the next video.

Explore making Docker changes for .NET core microservices, setting up container support with Dockerfile and Docker Compose, configuring identity and order databases, volumes, credentials, and migrations.

Apply migrations to initialize and update the identity database, create the migrations folder, and deploy with docker compose while using dotnet ef migrations and dotnet ef database update.

Register a user, login to obtain a JWT token, and inspect its claims like subject, expiration, issuer, and audience, with notes on Azure AD delegation for service authentication.