DDD

 Qu'est-ce que DDD (Domain-Driven Design) ?

Domain-Driven Design (DDD) est une approche de conception logicielle qui met l'accent sur la modélisation autour du domaine métier. Le but est de créer un logiciel qui reflète fidèlement les concepts et les processus du domaine métier, en collaborant étroitement avec les experts métier pour définir un langage commun appelé Ubiquitous Language.

Principes fondamentaux de DDD

1. Ubiquitous Language (Langage commun) : Un langage partagé entre les développeurs et les experts métier pour décrire le domaine.

2. Domain Model (Modèle de domaine) : Une abstraction qui capture les règles et les concepts du domaine métier.

3. Bounded Context (Contexte délimité) : Une frontière qui délimite où un modèle de domaine spécifique est valide.

4. Entities et Value Objects :

   • Entities : Objets identifiés par leur identité unique (ex. : un client).

   • Value Objects : Objets définis uniquement par leurs propriétés (ex. : une adresse).

1. Aggregates : Regroupements logiques d'entités et de value objects avec une racine d'agrégat.

2. Repositories : Interfaces pour accéder et gérer les agrégats.

3. Domain Services : Services pour les opérations qui ne s'inscrivent pas naturellement dans une entité ou un value object.

Exemple de DDD avec C#

Prenons un exemple basé sur une application de gestion de commandes.

1. Définition du domaine métier

Le domaine métier est la gestion des commandes. Les concepts clés incluent :

• Client (Entity).

• Commande (Entity) contenant plusieurs Lignes de commande (Value Object).

• Règles métier : Une commande ne peut être validée que si elle a au moins un produit.

2. Modélisation en DDD

a. Entities et Value Objects

public class Customer

{

public Guid Id { get; private set; }

public string Name { get; private set; }

public Customer(Guid id, string name)

{

Id = id;

Name = name ?? throw new ArgumentNullException(nameof(name));

}

}

public class Order

{

public Guid Id { get; private set; }

public Customer Customer { get; private set; }

private List<OrderLine> _orderLines = new();

public IReadOnlyCollection<OrderLine> OrderLines => _orderLines.AsReadOnly();

public bool IsSubmitted { get; private set; }

public Order(Customer customer)

{

Id = Guid.NewGuid();

Customer = customer ?? throw new ArgumentNullException(nameof(customer));

}

public void AddOrderLine(OrderLine orderLine)

{

if (IsSubmitted)

throw new InvalidOperationException("Cannot modify a submitted order.");

_orderLines.Add(orderLine);

}

public void Submit()

{

if (!_orderLines.Any())

throw new InvalidOperationException("Cannot submit an order without items.");

IsSubmitted = true;

}

}

public class OrderLine

{

public string ProductName { get; private set; }

public int Quantity { get; private set; }

public OrderLine(string productName, int quantity)

{

ProductName = productName ?? throw new ArgumentNullException(nameof(productName));

Quantity = quantity > 0 ? quantity : throw new ArgumentException("Quantity must be greater than zero.");

}

}

b. Repository

public interface IOrderRepository

{

void Save(Order order);

Order GetById(Guid id);

}

c. Service de domaine

public class OrderService

{

private readonly IOrderRepository _orderRepository;

public OrderService(IOrderRepository orderRepository)

{

_orderRepository = orderRepository;

}

public void SubmitOrder(Guid orderId)

{

var order = _orderRepository.GetById(orderId);

if (order == null)

throw new InvalidOperationException("Order not found.");

order.Submit();

_orderRepository.Save(order);

}

}

3. Exemple d'utilisation

var customer = new Customer(Guid.NewGuid(), "John Doe");

var order = new Order(customer);

order.AddOrderLine(new OrderLine("Laptop", 1));

order.AddOrderLine(new OrderLine("Mouse", 2));

// Repository simulation

IOrderRepository repository = new InMemoryOrderRepository();

repository.Save(order);

// Service usage

var orderService = new OrderService(repository);

orderService.SubmitOrder(order.Id);

Résumé

1. DDD aide à structurer le code autour du domaine métier.

2. Les concepts comme Entities, Value Objects, Aggregates, et Repositories organisent et encapsulent les règles métier.

3. La collaboration avec les experts métier est essentielle pour réussir une implémentation DDD.