Getting started with Clean Architecture using .Net Core

Name: Getting started with Clean Architecture using .Net Core
Rating: 4.4 (286 reviews)

Complete guide to build enterprise edition application end to end

Created byRahul Sahay

Last updated 10/2023

English

English [Auto],

What you'll learn

Learn how to create Microservices using .Net Core
Learn how to stitch multiple technologies together
Learn how to implement message queues
Learn how to implement Mediator Pattern
Learn how to implement CQRS Pattern
Lear how how to Containerize your solution
Lear how how to use Application Gateway
Learn how to implement structured Logging
Lear how to handle cross cutting concerns like ELK Stack, Observability etc

Course content

3 sections • 26 lectures • 1h 59m total length

Introduction0:43
Explore microservices using clean architecture implemented in dotnet core, tracing the evolution from monolith to modular and microservices patterns, and understanding why clean architecture is the next big thing.
Github Strategy3:24
Explore the clean architecture and E shopping GitHub repos, review the readme with course links and design patterns, and understand microservices wiring with Docker, Kubernetes, and Azure.
Layered Vs Domain Centric2:36
Compare layered architecture with domain centric design, noting tight data coupling and brittleness, and show how a domain centric approach centers use cases for scalable microservices.
Hexagonal Architecture1:38
Explore hexagonal architecture, where the domain sits at the center and ports and adapters decouple the inner domain from presentation, persistence, and external systems, enabling isolated testing and loose coupling.
Onion Architecture1:27
Explore onion architecture with a domain-centered core surrounded by application, presentation, and infrastructure layers; invert dependencies for isolated testing and domain-driven design, then preview clean architecture for microservices.
Clean Architecture2:05
Explore clean architecture with domain-centered pattern, where entities form the core and use cases surround them. Wire dependencies to the presentation layer, enabling testable, isolated domain-driven software.
CQRS Pattern2:47
Learn the cqrs pattern within clean architecture, separating read queries from commands, using a mediator to translate requests in microservices, with examples like product queries and basket commands.

Project Creation4:55
Create a blank solution and scaffold a clean architecture with movies API, movies core, application, and infrastructure projects in dotnet, using Rider or Visual Studio.
Adding Project References2:39
Add references to application, infrastructure, and API projects to enforce separation of concerns and let the orchestrator route requests, then build and begin implementing from code.
Creating Movie Entity5:13
Create a movie entity in a clean architecture project by building a base abstract entity with a substitutable ID and outlining a repository structure.
Generic Repository Creation3:41
Implement a generic repository pattern with a base async CRUD interface for any entity (get all, get by id, add, update, delete) and plan a movie-specific repository.
Creating Custom Movie Repository2:25
Create a custom movie repository by inheriting the generic repository, define iMovieRepository with custom operations such as get movies by director name, and verify the build.
Adding Infrastructure Nuget Packages3:31
Add infrastructure dependencies by installing the latest NuGet packages for design, tools, SQL Server, and in-memory, update the csproj, and prepare to implement the database context.
Adding Movie Context and Seed Data5:13
Implement a movie context by inheriting from db context, use the entity framework pattern, define a movies db set, and seed data with a movie context seed, including retry logic.
Implementing Base Repository6:02
Implement a generic base repository with async methods for get all, get by id, add, update, and delete using a movie context, and save changes.
Implementing Movie Repository2:43
Implement the movie repository with missing members and a get movies by director name using the movie context, completing the infrastructure before starting the application layer.
Adding Nuget Packages Application Project2:42
Add NuGet packages to implement mediator pattern with command-query separation in the application and API layers, using AutoMapper and FluentValidation; set up folders for commands, queries, handlers, responses, and mappers.
Create Movie Command and Handler5:36
Create a movie command and its handler in clean architecture, map the request via a movie mapper to the repository, and return a movie response.
Implementing Movie Mapper3:22
Create a movie mapping profile with Automapper, adding create map and reverse map for movie and movie response, and implement a lazy mapper extension to auto-map properties.
Implementing Movie Query and Handler5:50
Implement a get movies by director name query and its handler in a clean architecture using .net core, inject the movie repository, and map to movie responses.
Configuring Services in Startup12:30
Implement startup configuration in the startup.cs, register controllers, api versioning, swagger, automapper, mediator, and the movie repository via dependency injection.
Startup File Configuration changes3:20
Configure startup for clean architecture in .NET Core by wiring the application builder, development exception page, HTTPS redirection, routing, and Swagger with Swagger UI for the movie review API.
Program file implementation10:34
Implement the program file in a docker-based .NET core app. Configure a connection string to sql server, seed the database with a movies context, and wire in structured logging.
Controller Creation8:19
Explore building a clean architecture with .net core by creating a versioned api controller, a movie controller using mediator to handle get by director and create movie commands.
Demo9:50
Experience a hands-on clean architecture demo in dotnet core with a dockerized sql server setup. Trace end-to-end data flow from controller to handler and repository in a live run.

Requirements

Basics of C#, .Net Core, Docker

Description

Join my exciting course "Getting started with Clean Architecture using .Net Core" and become proficient in building Microservices using the Clean Architecture pattern in .Net Core.

This course covers everything from the basics of Microservices to the intricacies of the Clean Architecture pattern, giving you the skills you need to create a project using the Clean Architecture pattern, implement Domain-Driven Design (DDD) principles, and build and deploy Microservices using Docker and Kubernetes.

This is a hands-on course that provides you with practical experience in Microservices development, helping you master the skills that are essential for building and deploying your own Microservices using .Net Core and Clean Architecture. By the end of the course, you will have a deep understanding of the concepts behind Microservices and Clean Architecture, and be able to apply them to real-world projects.

Whether you're an experienced .Net developer or just starting out with Microservices, this course is perfect for you. We welcome everyone, and our dynamic teaching approach ensures that you'll get the most out of this course.

Microservices are a powerful design pattern that helps you develop independent modules that communicate within well-defined boundaries, making it easier to develop, test, and deploy isolated parts of your application. By joining our course, you'll be able to take advantage of these benefits and learn how to build Microservices using .Net Core, a powerful framework for developing robust and scalable applications.

So what are you waiting for? Sign up today and start your journey towards becoming an expert in Microservices development using .Net Core and Clean Architecture!

Once you are done with basics of clean architecture, then you will be able to switch gears and take the next journey by taking the Microservices learning series.

Who Should Take This Course?

Freshers who want to learn how to build scalable and efficient systems using Microservices architecture.
Junior Developers who are looking to level up their skills and gain experience building real-world Microservices applications.
Mid-Level Developers who want to learn how to build and deploy Microservices using the latest industry-standard tools and practices.
Senior Developers who are looking to stay ahead of the curve and keep their skills up-to-date with the latest trends and technologies.
Software Architects who want to learn how to design and develop scalable, distributed, and fault-tolerant systems using Microservices.
Technical Leads who want to gain a deeper understanding of Microservices architecture and lead their teams in building scalable and efficient systems.

Enroll now and take the next step in your Microservices journey.

This course is part of Microservices series where in you will learn all minute details related to Microservices. During this learning path, you will learn how to connect the dots using different technologies and tooling.

Complete Reference of Microservice includes below topics:

1. Creating .Net Core Microservices using Clean Architecture

2. Securing Microservices using Identity Server 4

3. Implementing Cross Cutting Concerns

4. Versioning Microservices

5. Building Angular Application for MicroServices

6. Deploying Microservices to Kubernetes and AKS

However, this course includes below topics:

Introduction
Introduction
Github Strategy
Layered Vs Domain Centric
Hexagonal Architecture
Onion Architecture
Clean Architecture
CQRS Pattern
Implementation
Project Creation
Adding Project References
Creating Movie Entity
Generic Repository Creation
Creating Custom Movie Repository
Adding Infrastructure Nuget Packages
Adding Movie Context and Seed Data
Implementing Base Repository
Implementing Movie Repository
Adding Nuget Packages Application Project
Create Movie Command and Handler
Implementing Movie Mapper
Implementing Movie Query and Handler
Configuring Services in Startup
Startup File Configuration changes
Program file implementation
Controller Creation
Demo
Bonus Section
Bonus Lecture

Who this course is for:

Beginners, Intermediate or even Advanced level candidates who wanted to refine their Microservices knowledge using .Net core and other tons of different technologies

Getting started with Clean Architecture using .Net Core

What you'll learn

Explore related topics

Course content

Introduction7 lectures • 15min

Implementation18 lectures • 1hr 38min

Bonus Section1 lecture • 6min

Requirements

Description

Who this course is for: