thangchung/clean-architecture-dotnet is a developer-focused project on GitHub with 1.4k stars, written primarily in C#. 🕸 Yet Another .NET Clean Architecture, but for Microservices project. It uses Minimal Clean Architecture with DDD-lite, CQRS-lite, and just enough Cloud-native patterns apply on the simple eCommerce sample and run on Tye with Dapr extension 🍻
Snapshot summary built from the project's own GitHub metadata — there's no written TopGit review yet. The page will update automatically when a full review is published.
WHY NO REVIEW YET
TopGit writes full reviews for the most-starred, most-requested repositories. This page is a snapshot until then — see the READ ME tab for the original README in full.
"Everything should be made as simple as possible, but not simpler." - Albert Einstein
"Mọi thứ đều nên đơn giản, càng đơn giản càng tốt, nhưng không nên đơn giản hơn bản chất của nó." - Vietnamese translated
We know that, and that's a reason we publish these libraries and samples. These are distillations with all best practices, tips, and tricks, and whatever made us spend a lot of time struggling to solve.
In the end of our journey, we would like to give these simplified and effortless libraries and samples as a reward for you. Enjoy the Minimal Clean Architecture, Domain-driven Design Lite, CQRS Lite, and just enough Cloud-native patterns!
DISCLAIMER
IMPORTANT: Because we are constantly evolving towards newly released technologies, .NET 6 is in the preview state so that it might change a lot in every release by the .NET team. So even we're trying to do the best for this OSS. But be careful if you use it for your project, and make sure that you do a stress test, benchmarking these libraries, and refactor them subsequently to adapt to your business carefully.
Feedback with improvements and pull requests from the community will be highly appreciated. Thank you!
⭐ Give a star
If you're using this repository for your learning, samples, workshop, or your project, please give a star. Thanks :+1:
🎇 Business Usecases
🎇 High level context
🎇 ERD
🎇 Minimal DDD, CQRS, and Clean Architecture
Domain-driven Design (a.k.a DDD) demonstrates it can help the business tidy and organized in many years. But it is hard to approach and use, we need to make it easier to use in real projects when we get started.
Command and Query Responsibility Segregation (a.k.a CQRS) helps to separate components into command and query parts, but again it's really hard and might bloat when we get starting some of the project. We need something more lightweight, just like https://github.com/gautema/CQRSlite, but we might not need Event Sourcing in almost all projects.
Clean Architecture helps the project structure easier to refactor and evolve in medium and big projects. Especially in the Microservice world, we always want to do and try with a lot of time in the project lifetime. The thing is boilerplate code in this kind of project to make components lose coupling.
=> When we jump in and set up the project for the Microservice approach. We want to apply all the best practices from the community, and some kind of patterns and architecture above sometimes makes us feel power off when start implements the first line of code which actually solves the business requirements. So the solution is we need something minimal and enough to get starting, and then when our business gets grows by the time, then we go back to add more. That's what's the practical way to go!
clean-architecture-dotnet is a collection of basic building blocks and project structure to help we get starting the project with less code boilerplate and effortless. We focus on the Microservice approach of how can we organize code, the project with the monorepo approach, and you can use it for modular monolith projects as well.
Reference to https://github.com/Sairyss/domain-driven-hexagon
Tan Hoang and Mohammad AlQuraian have confused about tye 0.8.0, and asked to add the guidance so I put it here
Follow the guidance at https://github.com/dotnet/tye/blob/647a608892/docs/getting_started.md#working-with-ci-builds
More specifically, adding dotnet tool install -g Microsoft.Tye --version "0.8.0-*" --add-source https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5/nuget/v3/index.json to your terminal
dapr: 1.2.0
Dev tools:
vscode tye extension
vscode REST Client extension
vscode Markmap extension
:hearts: Technical stacks
✔️ .NET Core 6 - .NET Framework and .NET Core, including ASP.NET and ASP.NET Core
✔️ MVC Versioning API - Set of libraries which add service API versioning to ASP.NET Web API, OData with ASP.NET Web API, and ASP.NET Core
✔️ YARP - A toolkit for developing high-performance HTTP reverse proxy applications
✔️ MediatR - Simple, unambitious mediator implementation in .NET
✔️ EF Core - Modern object-database mapper for .NET. It supports LINQ queries, change tracking, updates, and schema migrations
✔️ FluentValidation - Popular .NET validation library for building strongly-typed validation rules
✔️ Swagger & Swagger UI - Swagger tools for documenting API's built on ASP.NET Core
✔️ serilog - Simple .NET logging with fully-structured events
✔️ Dapr dotnet-sdk - Dapr SDK for .NET
✔️ RestEase - Easy-to-use typesafe REST API client library for .NET Standard 1.1 and .NET Framework 4.5 and higher, which is simple and customisable
✔️ Polly - Polly is a .NET resilience and transient-fault-handling library that allows developers to express policies such as Retry, Circuit Breaker, Timeout, Bulkhead Isolation, and Fallback in a fluent and thread-safe manner
✔️ Scrutor - Assembly scanning and decoration extensions for Microsoft.Extensions.DependencyInjection
✔️ opentelemetry-dotnet - The OpenTelemetry .NET Client
✔️ Blazor - WASM - Client web apps with C#
✔️ BFF - Framework for ASP.NET Core to secure SPAs using the Backend-for-Frontend (BFF) pattern
In medium and large software projects, we normally implement the CRUD actions over and over again. And it might take around 40-50% codebase just to do CRUD in the projects. The question is can we make standardized CRUD APIs, then we can use them in potential projects in the future? That is in my mind for a long time when I started and finished many projects, and I decide to take time to research and define the public interfaces for it as below
✔️ Common
public record ResultModel<T>(T Data, bool IsError = false, string? ErrorMessage = default);
public interface ICommand<T> : IRequest<ResultModel<T>> {}
public interface IQuery<T> : IRequest<ResultModel<T>> {}
✔️ [R]etrieve
// input model for list query (normally using for the table UI control with paging, filtering and sorting)
public interface IListQuery<TResponse> : IQuery<TResponse>
{
public List<string> Includes { get; init; }
public List<FilterModel> Filters { get; init; }
public List<string> Sorts { get; init; }
public int Page { get; init; }
public int PageSize { get; init; }
}
// output model with items, total items, page and page size with serving for binding with the table UI control
public record ListResponseModel<T>(List<T> Items, long TotalItems, int Page, int PageSize);
public interface IItemQuery<TId, TResponse> : IQuery<TResponse>
{
public List<string> Includes { get; init; }
public TId Id { get; init; }
}
✔️ [C]reate
public interface ICreateCommand<TRequest, TResponse> : ICommand<TResponse>, ITxRequest
{
public TRequest Model { get; init; }
}
✔️ [U]pdate
public interface IUpdateCommand<TRequest, TResponse> : ICommand<TResponse>, ITxRequest
{
public TRequest Model { get; init; }
}
✔️ [D]elete
public interface IDeleteCommand<TId, TResponse> : ICommand<TResponse> where TId : struct
{
public TId Id { get; init; }
}
Dapr components
✔️ Service Invocation
RestEase with Dapr handler. More information is at https://dev.to/thangchung/how-to-make-dapr-client-works-well-with-refit-and-restease-40m
public class OutboxEntity
{
[JsonInclude]
public Guid Id { get; private set; }
[JsonInclude]
public DateTime OccurredOn { get; private set; }
[JsonInclude]
public string Type { get; private set; }
[JsonInclude]
public string Data { get; private set; }
public OutboxEntity()
{
// only for System.Text.Json to deserialized data
}
public OutboxEntity(Guid id, DateTime occurredOn, IDomainEvent @event)
{
Id = id.Equals(Guid.Empty) ? Guid.NewGuid() : id;
OccurredOn = occurredOn;
Type = @event.GetType().FullName;
Data = JsonConvert.SerializeObject(@event);
}
public virtual IDomainEvent RecreateMessage(Assembly assembly) => (IDomainEvent)JsonConvert.DeserializeObject(Data, assembly.GetType(Type)!);
}
How active is development on thangchung/clean-architecture-dotnet?
The most recent commit recorded on thangchung/clean-architecture-dotnet was 3.3 years ago, based on the GitHub push timestamp. The repository has 288 forks — one of the better signals of community interest.
How does thangchung/clean-architecture-dotnet compare to other Developer Tools projects?
thangchung/clean-architecture-dotnet is tracked by TopGit in the Developer Tools category, with 1.4k GitHub stars and written in C#. Browse the Developer Tools topic page on TopGit to compare it against similar projects by stars and activity.
How many stars does thangchung/clean-architecture-dotnet have?
thangchung/clean-architecture-dotnet has 1.4k GitHub stars — refresh the page for the live number, or check github.com/thangchung/clean-architecture-dotnet. TopGit mirrors GitHub's count but does not claim minute-by-minute accuracy.
What is thangchung/clean-architecture-dotnet?
thangchung/clean-architecture-dotnet (thangchung/clean-architecture-dotnet) is a C# project on GitHub. From the project's own README: 🕸 Yet Another .NET Clean Architecture, but for Microservices project. It uses Minimal Clean Architecture with DDD-lite, CQRS-lite, and just enough Cloud-native patterns apply on the simple eCommerce sample and run on Tye with Dapr extension 🍻
What language is thangchung/clean-architecture-dotnet written in?
thangchung/clean-architecture-dotnet is written primarily in C#. GitHub's language field is based on the largest share of bytes in the default branch.
What topics is thangchung/clean-architecture-dotnet associated with?
Why is thangchung/clean-architecture-dotnet categorized under Developer Tools?
TopGit places thangchung/clean-architecture-dotnet in the Developer Tools category based on its GitHub topics and description (tagged: "aspnetcore", "blazor-webassembly", "clean-architecture"). Categories are assigned from real repository metadata, not editorial guesswork.
Read full README in the tab above.
Still deciding about clean-architecture-dotnet?
One click hands the question to an AI along with this page — see what it says about clean-architecture-dotnet.
/clean-architecture-dotnet
Reference to https://github.com/Sairyss/domain-driven-hexagon
