DDD stratégique

// ---- Ventes/Program.cs
var encours = new EncoursClient(plafond: 5000m);

var premiere = new Commande(total: 4200m);
premiere.Valider(encours);
Console.WriteLine(premiere.Etat); // Validee

var seconde = new Commande(total: 1500m);
seconde.Valider(encours);
Console.WriteLine(seconde.Etat); // EnAttenteAccordCredit

public enum EtatCommande
{
    Brouillon,
    Validee,
    EnAttenteAccordCredit,
}

// « L'encours, c'est ce que le client nous doit deja, commandes validees
//   comprises. Il ne depasse pas le plafond accorde par le credit client. »
public sealed class EncoursClient(decimal plafond)
{
    public decimal Plafond { get; } = plafond;

    public decimal Montant { get; private set; }

    public bool PeutReserver(decimal montant) => Montant + montant <= Plafond;

    public void Reserver(decimal montant) => Montant += montant;
}

// « Quand le commercial valide une commande, on reserve son montant sur
//   l'encours du client. Si cela depasse le plafond, la commande attend
//   l'accord du credit client. »
public sealed class Commande(decimal total)
{
    public decimal Total { get; } = total;

    public EtatCommande Etat { get; private set; } = EtatCommande.Brouillon;

    public void Valider(EncoursClient encours)
    {
        if (encours.PeutReserver(Total))
        {
            encours.Reserver(Total);
            Etat = EtatCommande.Validee;
        }
        else
        {
            Etat = EtatCommande.EnAttenteAccordCredit;
        }
    }
}

// Le meme comportement en jargon technique, aussi correct, et muet :
//   if (customer.Balance + order.Amount <= customer.Limit)
//   {
//       customer.Balance += order.Amount;
//       order.Status = 2;
//   }
//   else
//   {
//       order.Status = 5;
//   }

// ---- Boutique/Program.cs
var client = new Client
{
    Id = Guid.NewGuid(),
    RaisonSociale = "Atelier Martin",
    PlafondEncours = 5000m,
    Adresse = "12 rue des Forges, 69007 Lyon",
};

// L'expedition : le client demande que ses colis arrivent sur son chantier.
client.Adresse = "Chantier ZAC Nord, 69100 Villeurbanne";

// La facturation, a la fin du mois.
Console.WriteLine($"Facture envoyee a : {client.Adresse}");
// Facture envoyee a : Chantier ZAC Nord, 69100 Villeurbanne

// Un seul Client pour toute la boutique : chaque service y a ajoute ce dont
// il avait besoin, et Adresse sert a deux services qui n'y mettent pas le
// meme sens.
public sealed class Client
{
    public Guid Id { get; init; }

    public string RaisonSociale { get; set; } = "";

    // Ventes
    public decimal PlafondEncours { get; set; }

    // Facturation : ou envoyer la facture. Expedition : ou livrer.
    public string Adresse { get; set; } = "";

    // Expedition
    public string? PointRelais { get; set; }
}

// ---- Boutique/Program.cs
using Expedition = Boutique.Expedition;
using Facturation = Boutique.Facturation;
using Ventes = Boutique.Ventes;

var id = Guid.NewGuid();
var client = new Ventes.Client(id, "Atelier Martin", PlafondEncours: 5000m);
var destinataire = new Expedition.Destinataire(id, "12 rue des Forges, 69007 Lyon");
var tiers = new Facturation.Client(id, "Atelier Martin", "12 rue des Forges, 69007 Lyon");

destinataire.LivrerA("Chantier ZAC Nord, 69100 Villeurbanne");

Console.WriteLine($"Colis livres a : {destinataire.AdresseLivraison}");
// Colis livres a : Chantier ZAC Nord, 69100 Villeurbanne
Console.WriteLine($"Facture envoyee a : {tiers.AdresseFacturation}");
// Facture envoyee a : 12 rue des Forges, 69007 Lyon
Console.WriteLine(client.Id == destinataire.ClientId && client.Id == tiers.Id); // True

// Trois contextes, trois modeles. Dans une vraie solution, trois projets ;
// ici, trois espaces de noms pour tenir dans un fichier.
namespace Boutique.Ventes
{
    // Pour les ventes, un client est une entreprise a qui l'on accorde un plafond.
    public sealed record Client(Guid Id, string RaisonSociale, decimal PlafondEncours);
}

namespace Boutique.Expedition
{
    // Pour l'expedition, le client est un destinataire : un lieu ou livrer.
    public sealed class Destinataire(Guid clientId, string adresseLivraison)
    {
        public Guid ClientId { get; } = clientId;

        public string AdresseLivraison { get; private set; } = adresseLivraison;

        public void LivrerA(string adresse) => AdresseLivraison = adresse;
    }
}

namespace Boutique.Facturation
{
    // Pour la facturation, un client est un tiers a qui l'on envoie des factures.
    public sealed record Client(Guid Id, string RaisonSociale, string AdresseFacturation);
}

<!-- Boutique.slnx : un executable, quatre contextes -->
<Solution>
  <Folder Name="/Coeur/">
    <!-- La prise de commande entre entreprises, et son plafond d'encours. -->
    <Project Path="src/Ventes/Ventes.csproj" />
  </Folder>
  <Folder Name="/Support/">
    <!-- Propres a la boutique, necessaires, sans avantage sur ses concurrents. -->
    <Project Path="src/Retours/Retours.csproj" />
    <Project Path="src/Expedition/Expedition.csproj" />
  </Folder>
  <Folder Name="/Generique/">
    <!-- La facturation vit dans un progiciel : ce projet lui parle, rien de plus. -->
    <Project Path="src/Facturation.Integration/Facturation.Integration.csproj" />
  </Folder>
  <!-- Le noyau que Ventes et Retours partagent, et l'hote qui assemble le tout. -->
  <Project Path="src/Boutique.Noyau/Boutique.Noyau.csproj" />
  <Project Path="src/Boutique.Hote/Boutique.Hote.csproj" />
</Solution>

// ---- Boutique.Noyau/Noyau.cs : reference par Ventes et par Retours, et par eux seuls
namespace Boutique.Noyau;

// Le noyau partage : ce que les deux equipes ont convenu d'avoir en commun,
// petit et explicitement delimite. Aucune equipe ne le change sans consulter
// l'autre, et chaque modification fait tourner les tests des deux contextes.
public readonly record struct ClientId(Guid Valeur);

public readonly record struct CommandeId(Guid Valeur);

// Le Montant du cours sur le DDD tactique, reduit a l'essentiel.
public sealed record Montant
{
    public Montant(decimal valeur, string devise)
    {
        ArgumentOutOfRangeException.ThrowIfNegative(valeur);
        if (devise is not { Length: 3 } || !devise.All(char.IsAsciiLetterUpper))
        {
            throw new ArgumentException("Code ISO 4217 attendu, par exemple EUR.", nameof(devise));
        }

        Valeur = valeur;
        Devise = devise;
    }

    public decimal Valeur { get; }

    public string Devise { get; }
}

// ---- Ventes.Contrats/CommandeV1.cs
namespace Ventes.Contrats;

/// <summary>Une commande, telle que Ventes la publie. La V1 ne change plus.</summary>
/// <param name="Numero">Numero lisible, par exemple C-2026-0042.</param>
/// <param name="Client">Identifiant du client, le meme dans tous les contextes.</param>
/// <param name="Etat">brouillon ou validee.</param>
/// <param name="TotalHt">Total hors taxes.</param>
/// <param name="Devise">Code ISO 4217.</param>
/// <param name="ValideeLe">Date de validation, absente tant que la commande est un brouillon.</param>
public sealed record CommandeV1(
    string Numero,
    Guid Client,
    string Etat,
    decimal TotalHt,
    string Devise,
    DateOnly? ValideeLe);

// ---- Ventes.Contrats.Tests/AttentesDeLaFacturation.cs : projet dotnet new xunit, reference Ventes.Contrats
using System.Text.Json;
using Ventes.Contrats;

namespace Ventes.Contrats.Tests;

// Ecrit avec l'equipe qui integre la facturation, range dans la suite de
// Ventes et joue par son integration continue : un champ du contrat renomme
// ou supprime echoue ici, chez le fournisseur. Ce test ne couvre que le
// contrat : ce que VersV1 y met et la configuration JSON de l'hote demandent
// un test de l'endpoint.
public class AttentesDeLaFacturation
{
    [Fact]
    public void Une_commande_validee_porte_ce_que_la_facturation_lit()
    {
        var commande = new CommandeV1(
            "C-2026-0042",
            Guid.Parse("3f2b8c1e-5d4a-4e6f-9a7b-2c1d0e9f8a76"),
            "validee",
            1250.00m,
            "EUR",
            new DateOnly(2026, 9, 26));

        // Les options Web sont celles qu'ASP.NET Core emploie par defaut pour ses reponses.
        var json = JsonSerializer.SerializeToElement(commande, JsonSerializerOptions.Web);

        Assert.Equal("C-2026-0042", json.GetProperty("numero").GetString());
        Assert.Equal("validee", json.GetProperty("etat").GetString());
        Assert.Equal(1250.00m, json.GetProperty("totalHt").GetDecimal());
        Assert.Equal("EUR", json.GetProperty("devise").GetString());
        Assert.Equal("2026-09-26", json.GetProperty("valideeLe").GetString());
    }
}

// ---- Transporteur.Api/SuiviColis.cs : le paquet du transporteur, tel qu'il le livre
namespace Transporteur.Api;

// Statut : PEC pris en charge ; LIV livre, a l'adresse ou depose en point
// relais ; RET retire en point relais. DateEvenement : aaaammjj.
public sealed record SuiviColis(
    string NumeroColis,
    string Statut,
    string DateEvenement,
    string? CodePointRelais);

public interface IClientSuivi
{
    SuiviColis Suivre(string numeroColis);
}

// ---- Retours.Domaine/PolitiqueRetour.cs : reference Transporteur.Api
using System.Globalization;
using Transporteur.Api;

namespace Retours.Domaine;

public static class PolitiqueRetour
{
    // « Un produit se retourne dans les quatorze jours qui suivent sa livraison. »
    // Le transporteur dit LIV pour livre : la regle reprend son mot.
    public static bool RetourPossible(SuiviColis suivi, DateOnly aujourdhui) =>
        suivi.Statut == "LIV"
        && aujourdhui
            <= DateOnly
                .ParseExact(suivi.DateEvenement, "yyyyMMdd", CultureInfo.InvariantCulture)
                .AddDays(14);
}

// ---- Retours.Console/Program.cs : reference Retours.Domaine
using Retours.Domaine;
using Transporteur.Api;

var aujourdhui = new DateOnly(2026, 9, 26);
var transporteur = new TransporteurSimule();

// Retire par le client au point relais il y a trois jours.
Console.WriteLine(PolitiqueRetour.RetourPossible(transporteur.Suivre("CP-1001"), aujourdhui)); // False
// Depose au point relais avant-hier, pas encore retire.
Console.WriteLine(PolitiqueRetour.RetourPossible(transporteur.Suivre("CP-1002"), aujourdhui)); // True

// Ce que le transporteur repond pour ces deux colis.
sealed class TransporteurSimule : IClientSuivi
{
    public SuiviColis Suivre(string numeroColis) =>
        numeroColis switch
        {
            "CP-1001" => new SuiviColis("CP-1001", "RET", "20260923", "RELAIS-042"),
            "CP-1002" => new SuiviColis("CP-1002", "LIV", "20260924", "RELAIS-042"),
            _ => throw new ArgumentException("Colis inconnu.", nameof(numeroColis)),
        };
}

// ---- Retours.Domaine/PolitiqueRetour.cs : ne reference plus rien
namespace Retours.Domaine;

// La langue du service apres-vente : le client a recu son colis, tel jour.
public sealed record Reception(DateOnly Le);

// Le port, declare par le domaine, dans ses mots.
public interface IReceptions
{
    Reception? DeColis(string numeroColis);
}

public static class PolitiqueRetour
{
    public const int DelaiEnJours = 14;

    // « Un produit se retourne dans les quatorze jours qui suivent sa livraison. »
    public static bool RetourPossible(Reception? reception, DateOnly aujourdhui) =>
        reception is not null && aujourdhui <= reception.Le.AddDays(DelaiEnJours);
}

// ---- Retours.Infrastructure/ReceptionsTransporteur.cs : reference Retours.Domaine et Transporteur.Api
using System.Globalization;
using Retours.Domaine;
using Transporteur.Api;

namespace Retours.Infrastructure;

// La couche anticorruption : la seule classe qui connait les deux modeles.
// Elle parle au transporteur par son interface telle qu'elle est, et traduit.
public sealed class ReceptionsTransporteur(IClientSuivi transporteur) : IReceptions
{
    public Reception? DeColis(string numeroColis) => Traduire(transporteur.Suivre(numeroColis));

    private static Reception? Traduire(SuiviColis suivi) =>
        (suivi.Statut, suivi.CodePointRelais) switch
        {
            ("PEC", _) => null,
            // Livre a l'adresse : le client a le colis en main.
            ("LIV", null) => new Reception(Date(suivi)),
            // Depose en point relais : livre pour le transporteur, pas pour le client.
            ("LIV", _) => null,
            ("RET", _) => new Reception(Date(suivi)),
            _ => throw new InvalidOperationException(
                $"Statut du transporteur inconnu : {suivi.Statut}."),
        };

    private static DateOnly Date(SuiviColis suivi) =>
        DateOnly.ParseExact(suivi.DateEvenement, "yyyyMMdd", CultureInfo.InvariantCulture);
}

// ---- Retours.Console/Program.cs : reference Retours.Infrastructure
// Transporteur.Api : inchange, celui de la version precedente.
using Retours.Domaine;
using Retours.Infrastructure;

var aujourdhui = new DateOnly(2026, 9, 26);
IReceptions receptions = new ReceptionsTransporteur(new TransporteurSimule());

Console.WriteLine(PolitiqueRetour.RetourPossible(receptions.DeColis("CP-1001"), aujourdhui)); // True
Console.WriteLine(PolitiqueRetour.RetourPossible(receptions.DeColis("CP-1002"), aujourdhui)); // False

// ---- Retours.Console/TransporteurSimule.cs : la classe de la version precedente, dans son fichier
using Transporteur.Api;

sealed class TransporteurSimule : IClientSuivi
{
    public SuiviColis Suivre(string numeroColis) =>
        numeroColis switch
        {
            "CP-1001" => new SuiviColis("CP-1001", "RET", "20260923", "RELAIS-042"),
            "CP-1002" => new SuiviColis("CP-1002", "LIV", "20260924", "RELAIS-042"),
            _ => throw new ArgumentException("Colis inconnu.", nameof(numeroColis)),
        };
}

// ---- Ventes.Api/Program.cs : projet dotnet new web, reference Ventes.Contrats
using Ventes.Contrats;

var app = WebApplication.CreateBuilder(args).Build();

// Le service ouvert de Ventes : un protocole, le meme pour tous les
// contextes qui s'integrent, et sa version dans l'URL.
app.MapGet(
    "/v1/commandes/{numero}",
    (string numero) =>
        Commandes.Trouver(numero) is { } commande
            ? Results.Ok(commande.VersV1())
            : Results.NotFound());

app.Run();

// Le modele interne, qui ne sort pas du contexte.
sealed record Ligne(string Reference, int Quantite, decimal PrixUnitaire);

sealed class Commande(string numero, Guid client, IReadOnlyList<Ligne> lignes)
{
    public string Numero { get; } = numero;

    public Guid Client { get; } = client;

    public IReadOnlyList<Ligne> Lignes { get; } = lignes;

    public DateOnly? ValideeLe { get; private set; }

    public void Valider(DateOnly le) => ValideeLe = le;

    // La traduction vers la langue publiee : le seul endroit qui connait les deux.
    public CommandeV1 VersV1() =>
        new(
            Numero,
            Client,
            ValideeLe is null ? "brouillon" : "validee",
            Lignes.Sum(l => l.Quantite * l.PrixUnitaire),
            "EUR",
            ValideeLe);
}

static class Commandes
{
    private static readonly Commande Exemple = Creer();

    public static Commande? Trouver(string numero) => numero == Exemple.Numero ? Exemple : null;

    private static Commande Creer()
    {
        var commande = new Commande(
            "C-2026-0042",
            Guid.Parse("3f2b8c1e-5d4a-4e6f-9a7b-2c1d0e9f8a76"),
            [new("ECRAN-27", 3, 300.00m), new("CABLE-HDMI", 14, 25.00m)]);
        commande.Valider(new DateOnly(2026, 9, 26));
        return commande;
    }
}

# Ventes.Api (ASP.NET Core 10), lance avec --urls http://localhost:5651
curl -s http://localhost:5651/v1/commandes/C-2026-0042
{"numero":"C-2026-0042","client":"3f2b8c1e-5d4a-4e6f-9a7b-2c1d0e9f8a76","etat":"validee","totalHt":1250.00,"devise":"EUR","valideeLe":"2026-09-26"}

# Un numero inconnu : 404, sans corps.
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:5651/v1/commandes/C-2026-9999
404