Exemple d'Architecture Propre avec .NET 6
L'architecture propre est un modèle architectural qui vise à séparer les différentes couches de votre application pour améliorer la testabilité, la maintenabilité et la flexibilité. Dans cet article, nous allons explorer un exemple simple d'architecture propre avec .NET 6.
Introduction à l'Architecture Propre
L'architecture propre est basée sur l'idée de séparer les responsabilités de l'application en couches distinctes. Ces couches sont organisées de manière à ce que les couches internes soient indépendantes des couches externes. Cela signifie que les couches internes ne doivent pas dépendre de la technologie spécifique utilisée par les couches externes.
Exemple d'Application .NET 6 avec Architecture Propre
Prenons l'exemple d'une application web simple qui gère une liste de tâches. Notre application sera composée des couches suivantes:
- Interface utilisateur (UI): Cette couche est responsable de l'interaction avec l'utilisateur. Dans notre cas, il s'agira d'une application web ASP.NET Core.
- Application: Cette couche contient la logique métier de l'application. Elle est responsable de la gestion des tâches, de la validation des données et de l'interaction avec les autres couches.
- Infrastructure: Cette couche gère les aspects techniques de l'application, tels que l'accès aux données, l'envoi d'e-mails, la journalisation, etc.
Structure du Projet
Pour mettre en œuvre ce modèle d'architecture propre, nous allons organiser notre projet en plusieurs projets distincts :
- Projet d'application: Ce projet contient la couche d'application. Il ne devrait pas dépendre d'autres projets.
- Projet d'infrastructure: Ce projet contient la couche d'infrastructure. Il peut dépendre du projet d'application, mais pas de la couche UI.
- Projet d'interface utilisateur: Ce projet contient la couche UI. Il peut dépendre des deux autres projets.
Dépendances entre les Couches
Il est important de noter que les dépendances entre les couches doivent être unidirectionnelles. La couche UI dépend de la couche d'application, qui dépend de la couche d'infrastructure. Cependant, la couche d'infrastructure ne dépend pas de la couche d'application et la couche d'application ne dépend pas de la couche UI.
Illustration avec un Code Simple
Couche d'application
using System.Collections.Generic;
using Application.Interfaces;
namespace Application
{
public class TaskService : ITaskService
{
private readonly ITaskRepository _taskRepository;
public TaskService(ITaskRepository taskRepository)
{
_taskRepository = taskRepository;
}
public List GetAllTasks()
{
return _taskRepository.GetAll();
}
public void CreateTask(Task task)
{
_taskRepository.Create(task);
}
}
}
Couche d'infrastructure
using Domain;
using Infrastructure.Repositories;
namespace Infrastructure
{
public class TaskRepository : ITaskRepository
{
private readonly TaskDbContext _dbContext;
public TaskRepository(TaskDbContext dbContext)
{
_dbContext = dbContext;
}
public List GetAll()
{
return _dbContext.Tasks.ToList();
}
public void Create(Task task)
{
_dbContext.Tasks.Add(task);
_dbContext.SaveChanges();
}
}
}
Couche UI
using Application.Interfaces;
using Microsoft.AspNetCore.Mvc;
namespace UI.Controllers
{
public class TaskController : Controller
{
private readonly ITaskService _taskService;
public TaskController(ITaskService taskService)
{
_taskService = taskService;
}
public IActionResult Index()
{
var tasks = _taskService.GetAllTasks();
return View(tasks);
}
}
}
Avantages de l'Architecture Propre
L'utilisation de l'architecture propre offre plusieurs avantages:
- Testabilité: Les couches sont facilement testables car elles sont découplées.
- Maintenabilité: L'application est plus facile à maintenir car les changements dans une couche n'affectent pas les autres couches.
- Flexibilité: L'application est plus flexible car les couches peuvent être facilement remplacées par d'autres implémentations.
- Réutilisabilité: Les couches peuvent être réutilisées dans d'autres applications.
Conclusion
L'architecture propre est un modèle architectural puissant qui peut aider à créer des applications .NET 6 robustes, testables et maintenables. En séparant les responsabilités de l'application en couches distinctes, vous pouvez améliorer la qualité de votre code et la faciliter l'évolution de votre application au fil du temps.