How to add a new microservice to clean-architecture-dotnet?

Follow the sample product service structure, which includes separate projects for API, AppCore, and Infrastructure layers, and integrate with the existing building blocks and Dapr components. Use the provided CRUD interfaces and modular libraries to ensure consistency across services.

Clean-architecture-dotnet vs Ardalis Clean Architecture - what's the difference?

Clean-architecture-dotnet is tailored for microservices with cloud-native tools like Dapr and Tye, focusing on minimal boilerplate and 'lite' patterns. Ardalis Clean Architecture is more comprehensive for monolithic applications with stricter Clean Architecture adherence, without built-in cloud-native features.

Does clean-architecture-dotnet support server-side rendering or only APIs?

It primarily targets APIs and microservices, but includes samples with Blazor WASM for frontend integration, indicating a backend-focused approach. Server-side rendering isn't emphasized; the project is optimized for distributed, cloud-native backends.

What are the performance costs of using Dapr with this template?

Dapr adds an abstraction layer for service invocation and events, which can introduce latency, but it provides resilience and scalability benefits. The project leverages Dapr for transactional outbox and event bus, so performance trade-offs should be evaluated based on distributed system needs.

Can I use clean-architecture-dotnet without Tye for local development?

Tye is recommended for orchestration, but you can run services individually; however, features like service discovery and multi-service management might require manual configuration without Tye, increasing development overhead.

How to handle database migrations in clean-architecture-dotnet?

Use Entity Framework Core migrations as shown in the Infrastructure layer samples, with DbContextDesignFactoryBase for design-time support. The project includes migration scripts and hosted services for automated database updates in cloud environments.

Open-Awesome

clean-architecture-dotnet

MITC#SNAPSHOT-v0.0.3

A minimal .NET clean architecture template for microservices, applying DDD-lite, CQRS-lite, and cloud-native patterns to a sample eCommerce project.

GitHub

1.3k stars289 forks0 contributors

What is clean-architecture-dotnet?

clean-architecture-dotnet is a .NET-based project template and set of libraries that implement a minimalistic version of Clean Architecture, combined with lightweight Domain-Driven Design (DDD) and Command Query Responsibility Segregation (CQRS) patterns. It is designed specifically for building microservices, providing a structured yet flexible foundation with built-in cloud-native capabilities using Dapr and Tye. The project includes a sample eCommerce application to demonstrate real-world usage.

Target Audience

.NET developers and architects who are building or modernizing microservices-based applications and want a pragmatic, production-ready starting point with established architectural patterns.

Value Proposition

It reduces the initial complexity and boilerplate associated with implementing Clean Architecture, DDD, and CQRS in microservices, offering a 'just enough' approach that accelerates development while maintaining scalability and maintainability. The integration with Dapr and Tye provides ready-to-use cloud-native features out of the box.

Overview

🕸 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 🍻

Use Cases

Best For

Starting new .NET microservices projects with a proven architectural foundation
Teams adopting Clean Architecture and DDD but seeking a simplified, practical implementation
Developing cloud-native applications with service discovery, event-driven communication, and resilience patterns
Building modular monoliths that can later be decomposed into microservices
Educational purposes or workshops on .NET microservices architecture
Standardizing CRUD operations and project structure across multiple services

Not Ideal For

Simple CRUD applications where the overhead of Clean Architecture and microservices is unnecessary
Teams not using or planning to adopt Dapr and Tye for cloud-native development
Projects requiring advanced DDD patterns like full tactical modeling or event sourcing beyond the 'lite' implementations

Pros & Cons

Pros

Minimal Boilerplate

Reduces repetitive code with predefined project structures and standardized CRUD interfaces, as shown in the public interfaces for Create, Read, Update, and Delete operations in the README.

Cloud-Native Integration

Built-in support for Dapr and Tye provides ready-to-use features like service invocation, event bus, and local development orchestration, streamlining microservices setup as detailed in the technical stacks.

Pragmatic Architecture

Implements 'just enough' Clean Architecture, DDD-lite, and CQRS-lite, making complex patterns accessible without over-engineering, as emphasized in the philosophy of reducing initial complexity.

Modular Reusability

Offers reusable building blocks for logging, validation, API versioning, and OpenTelemetry tracing, which are organized into separate libraries like N8T.Core and N8T.Infrastructure for easy integration.

Cons

Preview Technology Risk

Relies on .NET 6 preview, which the README warns can change frequently, potentially causing breaking changes and requiring stress testing for production use, as noted in the disclaimer.

Complex Initial Setup

Requires installation of multiple tools like Dapr, Tye, and specific .NET SDK versions, increasing the learning curve and setup time for new developers, as outlined in the prerequisites section.

Limited Pattern Depth

The 'lite' implementations of DDD and CQRS may not cover advanced scenarios like complex domain modeling or event sourcing, which could necessitate custom extensions for larger projects.

Frequently Asked Questions

Related Projects

eShopOnWeb

Sample ASP.NET Core 8.0 reference application, now community supported: https://github.com/NimblePros/eShopOnWeb

Stars10,667

Forks5,980

Last commit1 year ago

eShopOnBlazor

A reference .NET application implementing an eCommerce site

Stars10,483

Forks3,637

Last commit20 days ago

EquinoxProject

Web Application ASP.NET 9 using Clean Architecture, DDD, CQRS, Event Sourcing and a lot of good practices

Stars6,772

Forks1,650

Last commit1 month ago

NorthwindTraders

Northwind Traders is a sample application built using ASP.NET Core and Entity Framework Core.

Stars5,019

Forks1,570

Last commit2 years ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub