Topic 18924 min readStructured Tutorial

Clean Architecture in C# - Design Patterns Tutorial

Quick Answer

Clean Architecture in C# is a software design approach that emphasizes separation of concerns, making applications maintainable, testable, and scalable by organizing code into layers with clear dependencies. It uses design patterns like Dependency Injection and Repository to decouple business logic from frameworks and UI.

Learning Objectives

Explain the purpose of Clean Architecture in a practical learning context.
Identify the main ideas, terms, and decisions involved in Clean Architecture.
Apply Clean Architecture in a simple real-world scenario or practice task.

Introduction to Clean Architecture

Clean Architecture is a software design philosophy that helps developers create systems that are easy to maintain, test, and extend.

In C#, applying Clean Architecture involves organizing your code into distinct layers with clear responsibilities and dependencies flowing inward.

This tutorial covers the core concepts, design patterns, and practical examples to implement Clean Architecture effectively.

“The goal of Clean Architecture is to create systems that are independent of frameworks, UI, databases, and any external agency.” – Robert C. Martin

Core Principles of Clean Architecture

Clean Architecture is based on several key principles that guide the structure and dependencies of your application.

Understanding these principles helps you design software that is robust and adaptable to change.

Independence of Frameworks: The architecture does not depend on any specific framework.
Testability: Business rules can be tested without UI, database, or external dependencies.
UI Independence: The UI can change without affecting the core business rules.
Database Independence: The business rules are not tied to any database technology.
Dependency Rule: Source code dependencies point inward, toward higher-level policies.

Layers in Clean Architecture

Clean Architecture organizes code into concentric layers, each with specific responsibilities.

Dependencies flow inward, meaning outer layers depend on inner layers but not vice versa.

Entities: Enterprise-wide business rules and domain objects.
Use Cases (Application Layer): Application-specific business rules.
Interface Adapters: Converters that transform data between layers (e.g., controllers, presenters).
Frameworks and Drivers: UI, database, external interfaces.

Clean Architecture Layers Overview
Layer	Responsibility	Dependency Direction
Entities	Core business logic and domain objects	No dependencies on other layers
Use Cases	Application-specific business rules	Depends on Entities
Interface Adapters	Data transformation and communication	Depends on Use Cases

Implementing Clean Architecture in C#

To implement Clean Architecture in C#, you typically create separate projects or folders for each layer.

This separation enforces boundaries and helps maintain clear dependencies.

Create a Domain project for Entities and business rules.
Create an Application project for Use Cases and interfaces.
Create an Infrastructure project for database and external service implementations.
Create a Presentation project for UI or API controllers.

Dependency Injection

Dependency Injection (DI) is essential in Clean Architecture to invert dependencies and inject implementations at runtime.

In C#, DI frameworks like Microsoft.Extensions.DependencyInjection help manage dependencies cleanly.

Define interfaces in the Application layer.
Implement interfaces in the Infrastructure layer.
Register implementations in the Composition Root (usually in the Presentation layer).

Repository Pattern

The Repository pattern abstracts data access, allowing the domain and application layers to remain independent of data sources.

Repositories expose methods to query and persist domain entities.

Example: Simple Clean Architecture Setup in C#

Here is a simplified example illustrating the structure and code snippets for Clean Architecture in C#.

Domain Layer - Entity

Define a simple entity representing a User.

Application Layer - Use Case and Interface

Define an interface for user repository and a use case to get user details.

Infrastructure Layer - Repository Implementation

Implement the user repository interface with data access logic.

Presentation Layer - Composition Root

Configure dependency injection and invoke the use case.

Practical Example

This class represents the core User entity with Id and Name properties.

Interface defining a method to retrieve a User by ID.

Use case class that uses the repository to get user details.

Concrete implementation of IUserRepository simulating data retrieval.

Setup DI container, register services, and execute the use case.

Examples

Domain Layer - User Entity

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

This class represents the core User entity with Id and Name properties.

Application Layer - IUserRepository Interface

public interface IUserRepository
{
    User GetUserById(int id);
}

Interface defining a method to retrieve a User by ID.

Application Layer - GetUserUseCase

public class GetUserUseCase
{
    private readonly IUserRepository _userRepository;

    public GetUserUseCase(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }

    public User Execute(int id)
    {
        return _userRepository.GetUserById(id);
    }
}

Use case class that uses the repository to get user details.

Infrastructure Layer - UserRepository Implementation

public class UserRepository : IUserRepository
{
    public User GetUserById(int id)
    {
        // Simulate data access
        return new User { Id = id, Name = "John Doe" };
    }
}

Concrete implementation of IUserRepository simulating data retrieval.

Presentation Layer - Dependency Injection Setup

var services = new ServiceCollection();
services.AddTransient<IUserRepository, UserRepository>();
services.AddTransient<GetUserUseCase>();

var serviceProvider = services.BuildServiceProvider();

var useCase = serviceProvider.GetService<GetUserUseCase>();
var user = useCase.Execute(1);
Console.WriteLine($"User: {user.Name}");

Setup DI container, register services, and execute the use case.

Best Practices

Keep business logic independent of frameworks and UI.
Use interfaces to abstract dependencies between layers.
Apply Dependency Injection to manage dependencies cleanly.
Write unit tests for Use Cases and Entities without external dependencies.
Separate projects or folders by layers to enforce boundaries.

Common Mistakes

Mixing UI code with business logic.
Allowing dependencies from inner layers to outer layers.
Tightly coupling domain entities to database or framework classes.
Skipping interfaces and directly instantiating dependencies.
Ignoring testability by embedding external concerns in core logic.

Hands-on Exercise

Create a Simple Clean Architecture Project

Build a small C# console application implementing Clean Architecture with at least Domain, Application, Infrastructure, and Presentation layers.

Expected output: A working console app that retrieves and displays data using Clean Architecture principles.

Hint: Define entities and interfaces first, then implement repositories and use cases, and finally set up dependency injection.

Refactor Existing Code

Take a tightly coupled C# application and refactor it to follow Clean Architecture layering and dependency rules.

Expected output: A modular, testable application with clear separation of concerns.

Hint: Identify business logic, separate it from UI and data access, and introduce interfaces and DI.

Interview Questions

What is the main goal of Clean Architecture?

Interview

The main goal is to create software systems that are independent of frameworks, UI, databases, and external agencies, making them maintainable, testable, and scalable.

How does the Dependency Rule work in Clean Architecture?

Interview

The Dependency Rule states that source code dependencies can only point inward, toward higher-level policies, ensuring inner layers do not depend on outer layers.

Why is Dependency Injection important in Clean Architecture?

Interview

Dependency Injection allows decoupling of components by injecting dependencies at runtime, enabling easier testing and adherence to the Dependency Rule.