Module 5

Changelog — V0.0.1

• Création du deck sur la généricité avancée, les contraintes de types et les pipelines LINQ.

Pipeline de pensée LINQ

Généricité utile, pas décorative

• Une abstraction générique doit exprimer une famille de comportements stable.
• Les contraintes where documentent ce que l'algorithme exige réellement.
• Les génériques réduisent les duplications entre ressources, véhicules, salles, comptes.

public interface IRepository<TAggregate>
    where TAggregate : class, IAggregateRoot
{
    Task<TAggregate?> GetByIdAsync(Guid id, CancellationToken ct);
    Task AddAsync(TAggregate aggregate, CancellationToken ct);
}

Contraintes de types

public static T CreateDefault<T>() where T : class, new()
{
    return new T();
}

• class, struct, notnull, new() et interfaces spécialisent le contrat.
• Une contrainte bien choisie supprime des vérifications dynamiques inutiles.

LINQ: fluent vs query syntax

var overdue = reservations
    .Where(r => r.End < now)
    .GroupBy(r => r.ResourceId)
    .Select(group => new { ResourceId = group.Key, Count = group.Count() });

• La syntaxe fluide domine en C# moderne.
• La query syntax reste utile pour certains join complexes.

IEnumerable vs IQueryable

• IEnumerable: exécution en mémoire, itération paresseuse possible.
• IQueryable: expression traduite vers une source distante, souvent SQL.
• Le danger: croire qu'un pipeline LINQ se comporte pareil côté base et côté mémoire.

Opérateurs avancés à maîtriser

• SelectMany pour aplatir une relation 1-n.
• GroupBy pour agréger.
• Join pour exprimer une corrélation explicite.
• ToDictionary et ToLookup pour accélérer les lectures ultérieures.

Exemple métier

var allocations = resources
    .Join(reservations,
        resource => resource.Id,
        reservation => reservation.ResourceId,
        (resource, reservation) => new { resource.Name, reservation.Start, reservation.End })
    .OrderBy(x => x.Start)
    .ToList();

• Lisible, compact, facilement testable.

Règle de performance

• Mesurer avant d'optimiser.
• Matérialiser (ToList, ToArray) au bon moment.
• Garder en tête le coût caché des requêtes traduites.