var commandes = db.CdeClients
    .Include(c => c.Lignes)
    .Include(c => c.Paiements)
    .ToList();

var commandes = db.CdeClients
    .Include(c => c.Lignes)
    .Include(c => c.Paiements)
    .AsSplitQuery()
    .ToList();

var commandes = db.CdeClients
    .Include(c => c.Lignes)
    .AsSingleQuery()
    .ToList();

services.AddDbContext<AppDbContext>(options =>
    options.UseSqlServer(connectionString, sqlOptions =>
        sqlOptions.UseQuerySplittingBehavior(QuerySplittingBehavior.SplitQuery)));

using var transaction = await db.Database.BeginTransactionAsync();

var commandes = await db.CdeClients
    .Include(c => c.Lignes)
    .Include(c => c.Paiements)
    .AsSplitQuery()
    .ToListAsync();

await transaction.CommitAsync();

// Attention : combinaison potentiellement problématique
var commandes = db.CdeClients
    .Include(c => c.Lignes)
    .OrderBy(c => c.Date)
    .Skip(10).Take(5)   // pagination sur l'entité principale
    .AsSplitQuery()     // peut générer un avertissement ou une erreur
    .ToList();

var query = db.CdeClients
    .Include(c => c.Lignes)
    .Include(c => c.Paiements)
    .AsSplitQuery();

Console.WriteLine(query.ToQueryString());

builder.Services.AddDbContextPool<AppDbContext>(options =>
{
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"));

    options.LogTo(Console.WriteLine, LogLevel.Information)
           .EnableDetailedErrors();
});

if (builder.Environment.IsDevelopment())
{
    options.EnableSensitiveDataLogging();
}

var products = await _db.Products
    .TagWith("ProductsController.GetByCategory")
    .AsNoTracking()
    .Where(p => p.CategoryId == categoryId)
    .OrderBy(p => p.Name)
    .Select(p => new ProductDto(p.Id, p.Name, p.Price))
    .ToListAsync(ct);

using System.Diagnostics;

var correlationId = httpContext.TraceIdentifier;
var traceId = Activity.Current?.TraceId.ToString() ?? "no-trace";

var products = await _db.Products
    .TagWith($"op=Products.GetByCategory;corr={correlationId};trace={traceId}")
    .AsNoTracking()
    .Where(p => p.CategoryId == categoryId)
    .Select(p => new ProductDto(p.Id, p.Name, p.Price))
    .ToListAsync(ct);

var products = await _db.Products
    .TagWithCallSite("Products query")
    .AsNoTracking()
    .Where(p => p.CategoryId == categoryId)
    .Select(p => new ProductDto(p.Id, p.Name, p.Price))
    .ToListAsync(ct);

using System.Data.Common;
using System.Diagnostics;
using Microsoft.EntityFrameworkCore.Diagnostics;

public sealed class CorrelationCommandInterceptor : DbCommandInterceptor
{
    private readonly IHttpContextAccessor _httpContextAccessor;

    public CorrelationCommandInterceptor(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

    private void AddComment(DbCommand command)
    {
        var corr = _httpContextAccessor.HttpContext?.TraceIdentifier ?? "no-corr";
        var trace = Activity.Current?.TraceId.ToString() ?? "no-trace";

        command.CommandText = $"-- corr:{corr}; trace:{trace} \n{command.CommandText}";
    }

    public override InterceptionResult<DbDataReader> ReaderExecuting(
        DbCommand command,
        CommandEventData eventData,
        InterceptionResult<DbDataReader> result)
    {
        AddComment(command);
        return base.ReaderExecuting(command, eventData, result);
    }

    public override InterceptionResult<object> ScalarExecuting(
        DbCommand command,
        CommandEventData eventData,
        InterceptionResult<object> result)
    {
        AddComment(command);
        return base.ScalarExecuting(command, eventData, result);
    }

    public override InterceptionResult<int> NonQueryExecuting(
        DbCommand command,
        CommandEventData eventData,
        InterceptionResult<int> result)
    {
        AddComment(command);
        return base.NonQueryExecuting(command, eventData, result);
    }
}

builder.Services.AddHttpContextAccessor();
builder.Services.AddScoped<CorrelationCommandInterceptor>();

builder.Services.AddDbContextPool<AppDbContext>((sp, options) =>
{
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"));
    options.AddInterceptors(sp.GetRequiredService<CorrelationCommandInterceptor>());
});

builder.Services
    .AddOpenTelemetry()
    .WithTracing(tracing =>
    {
        tracing
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation()
            .AddSqlClientInstrumentation();
    });

using Microsoft.EntityFrameworkCore;

public static class ProductQueries
{
	// Requête asynchrone compilée et réutilisable
	public static readonly Func<AppDbContext, int, IAsyncEnumerable<ProductDto>>
		GetActiveProductById = EF.CompileAsyncQuery(
			(AppDbContext db, int id) =>
				db.Products
					.AsNoTracking()
					.Where(p => p.Id == id && p.IsActive)
					.Select(p => new ProductDto(p.Id, p.Name, p.Price))
		);
}

public sealed record ProductDto(int Id, string Name, decimal Price);

var dto = await ProductQueries
	.GetActiveProductById(context, productId)
	.FirstOrDefaultAsync(cancellationToken);

using Microsoft.Extensions.Caching.Memory;

public class ProductReadService
{
	private readonly AppDbContext _db;
	private readonly IMemoryCache _cache;

	public ProductReadService(AppDbContext db, IMemoryCache cache)
	{
		_db = db;
		_cache = cache;
	}

	public async Task<ProductDto?> GetByIdAsync(int id, CancellationToken ct)
	{
		var cacheKey = $"product:{id}";

		if (_cache.TryGetValue(cacheKey, out ProductDto? cached))
		{
			return cached;
		}

		var dto = await _db.Products
			.AsNoTracking()
			.Where(p => p.Id == id && p.IsActive)
			.Select(p => new ProductDto(p.Id, p.Name, p.Price))
			.FirstOrDefaultAsync(ct);

		if (dto is null)
		{
			return null;
		}

		_cache.Set(cacheKey, dto, new MemoryCacheEntryOptions
		{
			SlidingExpiration = TimeSpan.FromMinutes(5),
			AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30)
		});

		return dto;
	}
}

builder.Services.AddDbContextPool<AppDbContext>(options =>
{
	options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"));
});

public async Task<ProductDto?> GetProductFastAsync(int id, CancellationToken ct)
{
	var key = $"product:{id}";

	if (_cache.TryGetValue(key, out ProductDto? dto))
	{
		return dto;
	}

	dto = await ProductQueries
		.GetActiveProductById(_db, id)
		.FirstOrDefaultAsync(ct);

	if (dto is not null)
	{
		_cache.Set(key, dto, TimeSpan.FromMinutes(10));
	}

	return dto;
}

// Fragile : séparateur en dur, non portable Linux/Windows
var path = baseDir + "\\" + "subfolder" + "\\" + "file.txt";

// Fragile : les slashes peuvent ne pas correspondre à l'OS
var path = baseDir + "/subfolder/file.txt";

var path = Path.Combine(baseDir, "subfolder", "file.txt");

Path.Combine("C:\\data", "C:\\other", "file.txt"); // → "C:\\other\\file.txt"

var path = Path.Join(baseDir, "subfolder", "file.txt");

// Avec des Span<char> pour éviter les allocations
var path = Path.Join(baseDir.AsSpan(), "subfolder".AsSpan(), "file.txt".AsSpan());

// Résout les ".." et les doubles séparateurs
var normalized = Path.GetFullPath(path);

// Résoudre relativement à une base
var full = Path.GetFullPath("../config.json", baseDir);

// Lecture complète
string content = await File.ReadAllTextAsync(path, Encoding.UTF8);
byte[] bytes    = await File.ReadAllBytesAsync(path);
string[] lines  = await File.ReadAllLinesAsync(path, Encoding.UTF8);

// Écriture complète
await File.WriteAllTextAsync(path, content, Encoding.UTF8);
await File.WriteAllBytesAsync(path, bytes);
await File.WriteAllLinesAsync(path, lines, Encoding.UTF8);

await using var reader = new StreamReader(path, Encoding.UTF8);
while (!reader.EndOfStream)
{
    var line = await reader.ReadLineAsync();
    // traiter line
}

await using var writer = new StreamWriter(path, append: false, Encoding.UTF8);
await writer.WriteLineAsync("première ligne");
await writer.WriteLineAsync("deuxième ligne");
// flush automatique à la fin du using

await using var fs = new FileStream(
    path,
    FileMode.Create,
    FileAccess.Write,
    FileShare.None,
    bufferSize: 4096,
    useAsync: true);

await fs.WriteAsync(buffer.AsMemory(0, bytesRead));

// Synchrone
using var stream = File.OpenRead(path);

// Asynchrone — préférez await using
await using var stream = File.OpenReadAsync(path);

var stream = File.OpenRead(path);
// ... oubli de Dispose → le fichier reste verrouillé

// Crée physiquement un fichier de 0 octet dans le dossier Temp de l'OS
// et retourne son chemin — risque de collision si mal géré
var tempFile = Path.GetTempFileName();

var tempPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.tmp");
try
{
    await File.WriteAllTextAsync(tempPath, content);
    // ... traitements
}
finally
{
    File.Delete(tempPath); // garanti même en cas d'exception
}

public sealed class TempFile : IDisposable
{
    public string Path { get; } = System.IO.Path.Combine(
        System.IO.Path.GetTempPath(),
        $"{Guid.NewGuid()}.tmp");

    public void Dispose()
    {
        if (File.Exists(Path))
            File.Delete(Path);
    }
}

// Utilisation
using var temp = new TempFile();
await File.WriteAllTextAsync(temp.Path, data);
// Suppression automatique à la sortie du using

// BOM inclus par défaut avec new UTF8Encoding(true)
await File.WriteAllTextAsync(path, content, Encoding.UTF8);

// Sans BOM (courant pour les échanges inter-systèmes)
await File.WriteAllTextAsync(path, content, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));

// Fichier
if (File.Exists(path))
{
    // ...
}

// Répertoire
if (Directory.Exists(dirPath))
{
    // ...
}

// Créer le répertoire si absent (idempotent)
Directory.CreateDirectory(dirPath);

var filePath = Path.Join(baseDir, "reports", "2026", "rapport.pdf");

// Crée tous les répertoires intermédiaires en une seule instruction (idempotent)
Directory.CreateDirectory(Path.GetDirectoryName(filePath)!);

await File.WriteAllBytesAsync(filePath, pdfBytes);

public static async Task WriteAllTextSafeAsync(string filePath, string content, Encoding? encoding = null)
{
    Directory.CreateDirectory(Path.GetDirectoryName(filePath)!);
    await File.WriteAllTextAsync(filePath, content, encoding ?? Encoding.UTF8);
}

public string GetSecurePath(string baseDir, string userInput)
{
    // Normaliser pour résoudre les ".."
    var fullPath = Path.GetFullPath(Path.Join(baseDir, userInput));

    // Vérifier que le chemin résultant reste sous baseDir
    if (!fullPath.StartsWith(Path.GetFullPath(baseDir) + Path.DirectorySeparatorChar,
                              StringComparison.OrdinalIgnoreCase))
    {
        throw new UnauthorizedAccessException("Accès refusé : chemin hors du répertoire autorisé.");
    }

    return fullPath;
}

using var watcher = new FileSystemWatcher(dirPath)
{
    Filter = "*.json",
    NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName,
    IncludeSubdirectories = false,
    EnableRaisingEvents = true
};

watcher.Changed += (_, e) => Console.WriteLine($"Modifié : {e.FullPath}");
watcher.Created += (_, e) => Console.WriteLine($"Créé    : {e.FullPath}");
watcher.Deleted += (_, e) => Console.WriteLine($"Supprimé: {e.FullPath}");

// Éviter les événements en double (le Changed se déclenche parfois deux fois)
watcher.Changed += OnChangedDebounced;

// Lister les fichiers (non récursif)
var files = Directory.GetFiles(dirPath, "*.txt");

// Lister récursivement sans tout charger en mémoire
foreach (var file in Directory.EnumerateFiles(dirPath, "*.txt", SearchOption.AllDirectories))
{
    // traiter file
}

// Copier un répertoire entier (non intégré nativement avant .NET 8)
// À partir de .NET 8 :
// Pas d'API built-in, mais on peut utiliser DirectoryInfo
new DirectoryInfo(sourceDir).CopyTo(destinationDir); // ⚠ n'existe pas

// Pattern manuel
foreach (var file in Directory.EnumerateFiles(sourceDir, "*", SearchOption.AllDirectories))
{
    var relativePath = Path.GetRelativePath(sourceDir, file);
    var destFile     = Path.Join(destinationDir, relativePath);
    Directory.CreateDirectory(Path.GetDirectoryName(destFile)!);
    File.Copy(file, destFile, overwrite: true);
}

// Emplacement portable pour les données d'application
var appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
var configPath = Path.Join(appData, "MonApp", "config.json");

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDaprClient();

var app = builder.Build();

// Activer le middleware CloudEvents (désérialisation automatique)
app.UseCloudEvents();

// Enregistrer les souscriptions auprès du sidecar
app.MapSubscribeHandler();

app.Run();

public class OrderService
{
    private readonly DaprClient _daprClient;
    private const string PubSubName = "pubsub";

    public OrderService(DaprClient daprClient)
    {
        _daprClient = daprClient;
    }

    public async Task CreateOrderAsync(Order order)
    {
        // Logique de création de commande...
        order.Status = "Created";

        // Publier l'événement sur le topic "orders"
        await _daprClient.PublishEventAsync(PubSubName, "orders", new OrderCreated
        {
            OrderId = order.Id,
            CustomerId = order.CustomerId,
            TotalAmount = order.TotalAmount,
            CreatedAt = DateTime.UtcNow
        });
    }
}

app.MapPost("/orders", async (Order order, DaprClient dapr) =>
{
    order.Id = Guid.NewGuid().ToString();
    order.Status = "Created";

    // Sauvegarder la commande (state store)
    await dapr.SaveStateAsync("statestore", $"order-{order.Id}", order);

    // Publier l'événement
    await dapr.PublishEventAsync("pubsub", "orders", new OrderCreated
    {
        OrderId = order.Id,
        CustomerId = order.CustomerId,
        TotalAmount = order.TotalAmount,
        CreatedAt = DateTime.UtcNow
    });

    return Results.Created($"/orders/{order.Id}", order);
});

var metadata = new Dictionary<string, string>
{
    { "ttlInSeconds", "600" },      // Le message expire après 10 minutes
    { "rawPayload", "false" }       // Utiliser le format CloudEvents (par défaut)
};

await _daprClient.PublishEventAsync("pubsub", "orders", orderCreated, metadata);

app.MapPost("/order-created", [Topic("pubsub", "orders")] (OrderCreated evt) =>
{
    Console.WriteLine($"Commande reçue : {evt.OrderId}, montant : {evt.TotalAmount}€");
    // Traitement de l'événement...
    return Results.Ok();
});

[ApiController]
[Route("[controller]")]
public class NotificationsController : ControllerBase
{
    private readonly ILogger<NotificationsController> _logger;

    public NotificationsController(ILogger<NotificationsController> logger)
    {
        _logger = logger;
    }

    [Topic("pubsub", "orders")]
    [HttpPost("order-created")]
    public async Task<IActionResult> HandleOrderCreated(OrderCreated evt)
    {
        _logger.LogInformation("Notification pour commande {OrderId}", evt.OrderId);

        // Envoyer un email, une notification push, etc.
        await SendNotificationAsync(evt);

        return Ok();
    }

    private Task SendNotificationAsync(OrderCreated evt)
    {
        // Logique de notification...
        return Task.CompletedTask;
    }
}

var metadata = new Dictionary<string, string>
{
    { "rawPayload", "true" }
};

await _daprClient.PublishEventAsync("pubsub", "orders", orderCreated, metadata);

app.MapPost("/order-created", [Topic("pubsub", "orders")] async (
    OrderCreated evt, DaprClient dapr) =>
{
    // Vérifier si l'événement a déjà été traité (idempotence)
    var alreadyProcessed = await dapr.GetStateAsync<bool>(
        "statestore", $"processed-{evt.OrderId}");

    if (alreadyProcessed)
    {
        // Déjà traité, on retourne OK pour acquitter le message
        return Results.Ok();
    }

    // Traiter l'événement...
    await ProcessOrderAsync(evt);

    // Marquer comme traité
    await dapr.SaveStateAsync("statestore", $"processed-{evt.OrderId}", true);

    return Results.Ok();
});

app.MapPost("/order-created", [Topic("pubsub", "orders")] (OrderCreated evt) =>
{
    try
    {
        ProcessOrder(evt);
        return Results.Ok(new { status = "SUCCESS" });
    }
    catch (InvalidOperationException)
    {
        // Message invalide, ne pas réessayer
        return Results.Ok(new { status = "DROP" });
    }
    catch (Exception)
    {
        // Erreur temporaire, réessayer
        return Results.StatusCode(500);
    }
});

app.MapPost("/dead-letters", [Topic("pubsub", "orders-deadletter")] (
    CloudEvent<OrderCreated> deadLetter) =>
{
    Console.WriteLine($"Message en échec : {deadLetter.Data?.OrderId}");
    // Logger, alerter, stocker pour investigation...
    return Results.Ok();
});

// Route par défaut
app.MapPost("/orders/default",
    [Topic("pubsub", "orders", isDefault: true)]
    (OrderEvent evt) =>
{
    Console.WriteLine($"Événement ordre non classifié : {evt.OrderId}");
    return Results.Ok();
});

// Route pour les créations
app.MapPost("/orders/created",
    [Topic("pubsub", "orders", "event.data.status == \"created\"", 1)]
    (OrderEvent evt) =>
{
    Console.WriteLine($"Commande créée : {evt.OrderId}");
    return Results.Ok();
});

// Route pour les expéditions
app.MapPost("/orders/shipped",
    [Topic("pubsub", "orders", "event.data.status == \"shipped\"", 2)]
    (OrderEvent evt) =>
{
    Console.WriteLine($"Commande expédiée : {evt.OrderId}");
    return Results.Ok();
});

public async Task PublishOrdersBatchAsync(IEnumerable<OrderCreated> events)
{
    var bulkEvents = events.Select(e =>
        new BulkPublishEntry<OrderCreated>(
            entryId: Guid.NewGuid().ToString(),
            @event: e,
            contentType: "application/json")).ToList();

    var response = await _daprClient.BulkPublishEventAsync(
        "pubsub", "orders", bulkEvents);

    if (response.FailedEntries.Count > 0)
    {
        Console.WriteLine($"{response.FailedEntries.Count} messages en échec.");
        foreach (var failed in response.FailedEntries)
        {
            Console.WriteLine($"  - {failed.Entry.EntryId} : {failed.ErrorMessage}");
        }
    }
}

app.MapPost("/orders/bulk", (BulkSubscribeMessage<OrderCreated> bulkMessage) =>
{
    var statuses = new List<BulkSubscribeAppResponseEntry>();

    foreach (var entry in bulkMessage.Entries)
    {
        try
        {
            ProcessOrder(entry.Event);
            statuses.Add(new BulkSubscribeAppResponseEntry(
                entry.EntryId, BulkSubscribeAppResponseStatus.SUCCESS));
        }
        catch (Exception)
        {
            statuses.Add(new BulkSubscribeAppResponseEntry(
                entry.EntryId, BulkSubscribeAppResponseStatus.RETRY));
        }
    }

    return Results.Ok(new BulkSubscribeAppResponse(statuses));
});

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDaprClient();
var app = builder.Build();

app.MapPost("/orders", async (CreateOrderRequest request, DaprClient dapr) =>
{
    var order = new Order
    {
        Id = Guid.NewGuid().ToString(),
        CustomerId = request.CustomerId,
        Items = request.Items,
        TotalAmount = request.Items.Sum(i => i.Price * i.Quantity),
        Status = "Created",
        CreatedAt = DateTime.UtcNow
    };

    // Sauvegarder la commande
    await dapr.SaveStateAsync("statestore", $"order-{order.Id}", order);

    // Publier l'événement
    await dapr.PublishEventAsync("pubsub", "orders", new OrderCreated
    {
        OrderId = order.Id,
        CustomerId = order.CustomerId,
        Items = order.Items,
        TotalAmount = order.TotalAmount,
        CreatedAt = order.CreatedAt
    });

    return Results.Created($"/orders/{order.Id}", order);
});

app.Run();

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDaprClient();
var app = builder.Build();

app.UseCloudEvents();
app.MapSubscribeHandler();

app.MapPost("/order-created",
    [Topic("pubsub", "orders")] async (OrderCreated evt, DaprClient dapr) =>
{
    foreach (var item in evt.Items)
    {
        // Décrémenter le stock
        var stock = await dapr.GetStateAsync<int>("statestore", $"stock-{item.ProductId}");
        stock -= item.Quantity;

        if (stock < 0)
        {
            // Publier un événement de rupture de stock
            await dapr.PublishEventAsync("pubsub", "stock-alerts", new StockAlert
            {
                ProductId = item.ProductId,
                CurrentStock = stock,
                OrderId = evt.OrderId
            });
        }

        await dapr.SaveStateAsync("statestore", $"stock-{item.ProductId}", stock);
    }

    return Results.Ok();
});

app.Run();

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDaprClient();
var app = builder.Build();

app.UseCloudEvents();
app.MapSubscribeHandler();

// Notification de commande
app.MapPost("/order-created",
    [Topic("pubsub", "orders")] async (OrderCreated evt) =>
{
    Console.WriteLine($"📧 Email envoyé au client {evt.CustomerId} " +
                      $"pour la commande {evt.OrderId} ({evt.TotalAmount}€)");

    await SendEmailAsync(evt.CustomerId,
        $"Votre commande {evt.OrderId} a été confirmée !");

    return Results.Ok();
});

// Alerte de stock
app.MapPost("/stock-alert",
    [Topic("pubsub", "stock-alerts")] async (StockAlert alert) =>
{
    Console.WriteLine($"⚠️ Alerte stock : produit {alert.ProductId}, " +
                      $"stock actuel : {alert.CurrentStock}");

    await NotifyAdminAsync(alert);

    return Results.Ok();
});

app.Run();

async Task SendEmailAsync(string customerId, string message) =>
    await Task.Delay(100); // Simulation

async Task NotifyAdminAsync(StockAlert alert) =>
    await Task.Delay(100); // Simulation

public record OrderCreated
{
    public string OrderId { get; init; } = string.Empty;
    public string CustomerId { get; init; } = string.Empty;
    public List<OrderItem> Items { get; init; } = [];
    public decimal TotalAmount { get; init; }
    public DateTime CreatedAt { get; init; }
}

public record OrderItem
{
    public int ProductId { get; init; }
    public string Name { get; init; } = string.Empty;
    public decimal Price { get; init; }
    public int Quantity { get; init; }
}

public record StockAlert
{
    public int ProductId { get; init; }
    public int CurrentStock { get; init; }
    public string OrderId { get; init; } = string.Empty;
}

var builder = DistributedApplication.CreateBuilder(args);

var pubSub = builder.AddDaprPubSub("pubsub");
var stateStore = builder.AddDaprStateStore("statestore");

builder.AddProject<Projects.OrderService>("order-service")
    .WithDaprSidecar()
    .WithReference(pubSub)
    .WithReference(stateStore);

builder.AddProject<Projects.InventoryService>("inventory-service")
    .WithDaprSidecar()
    .WithReference(pubSub)
    .WithReference(stateStore);

builder.AddProject<Projects.NotificationService>("notification-service")
    .WithDaprSidecar()
    .WithReference(pubSub);

builder.Build().Run();

builder.Services.AddApiVersioning(options =>
{
    options.DefaultApiVersion = new ApiVersion(1, 0);
    options.AssumeDefaultVersionWhenUnspecified = true;
    options.ReportApiVersions = true;
});

// Entité interne — ne pas exposer
public class Order
{
    public Guid Id { get; set; }
    public Guid CustomerId { get; set; }
    public List<OrderLine> Lines { get; set; } = [];
    public decimal Total { get; set; }
    public OrderStatus Status { get; set; }
    public DateTime CreatedAt { get; set; }
}

// DTO de réponse
public record OrderResponse(
    Guid Id,
    decimal Total,
    string Status,
    DateTime CreatedAt
);

// DTO de création
public record CreateOrderRequest(
    Guid CustomerId,
    List<OrderLineRequest> Lines
);

[Mapper]
public partial class OrderMapper
{
    public partial OrderResponse ToResponse(Order order);
}

public record CreateOrderRequest(
    [Required] Guid CustomerId,
    [MinLength(1)] List<OrderLineRequest> Lines
);

public class CreateOrderRequestValidator : AbstractValidator<CreateOrderRequest>
{
    public CreateOrderRequestValidator()
    {
        RuleFor(x => x.CustomerId).NotEmpty();
        RuleFor(x => x.Lines)
            .NotEmpty()
            .WithMessage("Une commande doit contenir au moins une ligne.");
        RuleForEach(x => x.Lines).SetValidator(new OrderLineRequestValidator());
    }
}

builder.Services.AddValidatorsFromAssemblyContaining<CreateOrderRequestValidator>();
builder.Services.AddFluentValidationAutoValidation();

builder.Services.AddProblemDetails();

app.UseExceptionHandler(exceptionHandlerApp =>
{
    exceptionHandlerApp.Run(async context =>
    {
        var exceptionHandlerFeature = context.Features.Get<IExceptionHandlerFeature>();
        var exception = exceptionHandlerFeature?.Error;

        context.Response.StatusCode = exception switch
        {
            NotFoundException  => StatusCodes.Status404NotFound,
            ValidationException => StatusCodes.Status400BadRequest,
            UnauthorizedException => StatusCodes.Status403Forbidden,
            _ => StatusCodes.Status500InternalServerError
        };

        await Results.Problem(
            detail: exception?.Message,
            statusCode: context.Response.StatusCode
        ).ExecuteAsync(context);
    });
});

builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]!))
        };
    });

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AdminOnly", policy => policy.RequireRole("admin"));
    options.AddPolicy("OwnerOrAdmin", policy =>
        policy.RequireAssertion(ctx =>
            ctx.User.IsInRole("admin") || ctx.User.HasClaim("owner", "true")));
});

[Authorize(Policy = "AdminOnly")]
[HttpDelete("{id}")]
public async Task<IActionResult> Delete(Guid id) { ... }

builder.Services.AddRateLimiter(options =>
{
    options.AddFixedWindowLimiter("fixed", limiterOptions =>
    {
        limiterOptions.PermitLimit = 100;
        limiterOptions.Window = TimeSpan.FromMinutes(1);
        limiterOptions.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
        limiterOptions.QueueLimit = 10;
    });
    options.RejectionStatusCode = StatusCodes.Status429TooManyRequests;
});

app.UseRateLimiter();

[EnableRateLimiting("fixed")]
[HttpGet]
public async Task<IActionResult> GetOrders() { ... }

// À éviter
_logger.LogInformation($"Commande {orderId} créée par {userId}");

// Correct — permet l'indexation dans les outils de log (Seq, Loki, etc.)
_logger.LogInformation("Commande {OrderId} créée par {UserId}", orderId, userId);

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddOtlpExporter())
    .WithMetrics(metrics => metrics
        .AddAspNetCoreInstrumentation()
        .AddOtlpExporter());

// À éviter
public IActionResult GetOrder(Guid id)
{
    var order = _repository.GetById(id); // bloque un thread
    return Ok(order);
}

// Correct
public async Task<IActionResult> GetOrder(Guid id)
{
    var order = await _repository.GetByIdAsync(id);
    return order is null ? NotFound() : Ok(order);
}

public async Task<IActionResult> GetOrder(Guid id, CancellationToken ct)
{
    var order = await _repository.GetByIdAsync(id, ct);
    return order is null ? NotFound() : Ok(order);
}

builder.Services.AddMemoryCache();

// Dans le service
public async Task<OrderResponse?> GetOrderAsync(Guid id, CancellationToken ct)
{
    return await _cache.GetOrCreateAsync($"order:{id}", async entry =>
    {
        entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5);
        var order = await _repository.GetByIdAsync(id, ct);
        return order is null ? null : _mapper.ToResponse(order);
    });
}

builder.Services.AddOutputCache();
app.UseOutputCache();

[OutputCache(Duration = 60)]
[HttpGet("{id}")]
public async Task<IActionResult> GetOrder(Guid id, CancellationToken ct) { ... }

builder.Services.AddOpenApi();

app.MapOpenApi(); // expose /openapi/v1.json

/// <summary>Récupère une commande par son identifiant.</summary>
/// <param name="id">L'identifiant de la commande.</param>
/// <response code="200">La commande demandée.</response>
/// <response code="404">Commande introuvable.</response>
[HttpGet("{id}")]
[ProducesResponseType<OrderResponse>(StatusCodes.Status200OK)]
[ProducesResponseType<ProblemDetails>(StatusCodes.Status404NotFound)]
public async Task<IActionResult> GetOrder(Guid id, CancellationToken ct) { ... }

public class OrderServiceTests
{
    private readonly IOrderRepository _repository = Substitute.For<IOrderRepository>();
    private readonly OrderService _sut;

    public OrderServiceTests() => _sut = new OrderService(_repository);

    [Fact]
    public async Task GetOrder_ReturnsNull_WhenNotFound()
    {
        _repository.GetByIdAsync(Arg.Any<Guid>(), Arg.Any<CancellationToken>())
                   .Returns((Order?)null);

        var result = await _sut.GetOrderAsync(Guid.NewGuid(), default);

        result.Should().BeNull();
    }
}

public class OrdersControllerTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public OrdersControllerTests(WebApplicationFactory<Program> factory)
        => _client = factory.CreateClient();

    [Fact]
    public async Task GetOrder_Returns404_WhenNotFound()
    {
        var response = await _client.GetAsync($"/api/orders/{Guid.NewGuid()}");
        response.StatusCode.Should().Be(HttpStatusCode.NotFound);
    }
}

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddDaprClient();
var app = builder.Build();

app.MapPost("/orders", async (CreateOrderRequest request, DaprClient dapr) =>
{
    var order = new Order
    {
        Id = Guid.NewGuid().ToString(),
        CustomerId = request.CustomerId,
        TotalAmount = request.TotalAmount,
        Status = "Created",
        CreatedAt = DateTime.UtcNow
    };

    await dapr.PublishEventAsync("pubsub", "orders", new OrderCreated
    {
        OrderId = order.Id,
        CustomerId = order.CustomerId,
        TotalAmount = order.TotalAmount,
        CreatedAt = order.CreatedAt
    });

    return Results.Created($"/orders/{order.Id}", order);
});

app.Run();

using System.Text.Json;
using Dapr.AppCallback.Autogen.Grpc.v1;
using Dapr.Client.Autogen.Grpc.v1;
using Google.Protobuf.WellKnownTypes;
using Grpc.Core;

namespace PaymentService.Services;

public class DaprSubscriberService : AppCallback.AppCallbackBase
{
    private readonly ILogger<DaprSubscriberService> _logger;

    public DaprSubscriberService(ILogger<DaprSubscriberService> logger)
    {
        _logger = logger;
    }

    /// <summary>
    /// Déclaration des souscriptions auprès du sidecar.
    /// Appelée automatiquement par le sidecar au démarrage.
    /// </summary>
    public override Task<ListTopicSubscriptionsResponse> ListTopicSubscriptions(
        Empty request, ServerCallContext context)
    {
        var response = new ListTopicSubscriptionsResponse();

        // S'abonner au topic "orders" du composant "pubsub"
        response.Subscriptions.Add(new TopicSubscription
        {
            PubsubName = "pubsub",
            Topic = "orders",
            DeadLetterTopic = "orders-deadletter"
        });

        // S'abonner au topic "payments" du composant "pubsub"
        response.Subscriptions.Add(new TopicSubscription
        {
            PubsubName = "pubsub",
            Topic = "payments"
        });

        return Task.FromResult(response);
    }

    /// <summary>
    /// Réception d'un événement. Appelée par le sidecar pour chaque message.
    /// </summary>
    public override async Task<TopicEventResponse> OnTopicEvent(
        TopicEventRequest request, ServerCallContext context)
    {
        _logger.LogInformation(
            "Événement reçu - Topic: {Topic}, Source: {Source}, Id: {Id}",
            request.Topic, request.Source, request.Id);

        try
        {
            return request.Topic switch
            {
                "orders" => await HandleOrderCreatedAsync(request),
                "payments" => await HandlePaymentEventAsync(request),
                _ => new TopicEventResponse
                {
                    Status = TopicEventResponse.Types.TopicEventResponseStatus.Drop
                }
            };
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Erreur lors du traitement de l'événement {Id}", request.Id);

            // Demander au sidecar de re-livrer le message
            return new TopicEventResponse
            {
                Status = TopicEventResponse.Types.TopicEventResponseStatus.Retry
            };
        }
    }

    private async Task<TopicEventResponse> HandleOrderCreatedAsync(TopicEventRequest request)
    {
        // Désérialiser le payload depuis les bytes
        var orderCreated = JsonSerializer.Deserialize<OrderCreated>(
            request.Data.ToStringUtf8(),
            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });

        if (orderCreated is null)
        {
            return new TopicEventResponse
            {
                Status = TopicEventResponse.Types.TopicEventResponseStatus.Drop
            };
        }

        _logger.LogInformation(
            "Traitement du paiement pour la commande {OrderId}, montant : {Amount}€",
            orderCreated.OrderId, orderCreated.TotalAmount);

        // Simuler le traitement du paiement
        await Task.Delay(200);

        _logger.LogInformation("Paiement validé pour la commande {OrderId}",
            orderCreated.OrderId);

        return new TopicEventResponse
        {
            Status = TopicEventResponse.Types.TopicEventResponseStatus.Success
        };
    }

    private async Task<TopicEventResponse> HandlePaymentEventAsync(TopicEventRequest request)
    {
        _logger.LogInformation("Événement de paiement reçu : {Data}",
            request.Data.ToStringUtf8());

        await Task.CompletedTask;

        return new TopicEventResponse
        {
            Status = TopicEventResponse.Types.TopicEventResponseStatus.Success
        };
    }
}

using PaymentService.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddGrpc();

var app = builder.Build();

// Enregistrer le service AppCallback pour le sidecar Dapr
app.MapGrpcService<DaprSubscriberService>();

app.Run();

public override Task<ListTopicSubscriptionsResponse> ListTopicSubscriptions(
    Empty request, ServerCallContext context)
{
    var response = new ListTopicSubscriptionsResponse();

    response.Subscriptions.Add(new TopicSubscription
    {
        PubsubName = "pubsub",
        Topic = "orders",
        Routes = new TopicRoutes
        {
            Default = "default",
            Rules =
            {
                new TopicRule
                {
                    Match = "event.data.status == \"created\"",
                    Path = "created"
                },
                new TopicRule
                {
                    Match = "event.data.status == \"paid\"",
                    Path = "paid"
                }
            }
        }
    });

    return Task.FromResult(response);
}