Q/A Performance et Optimisation

---

🔹 1. Utiliser le cache en mémoire en ASP.NET Core

✅ MemoryCache

• IMemoryCache permet de stocker des objets en mémoire pour réduire les accès répétés aux sources lentes (DB, API, calculs lourds).

• Exemple d’enregistrement et utilisation :

// Dans Program.cs
builder.Services.AddMemoryCache();

// Dans un service
public class TradeService
{
    private readonly IMemoryCache _cache;
    public TradeService(IMemoryCache cache) => _cache = cache;

    public double GetPrice(string symbol)
    {
        return _cache.GetOrCreate(symbol, entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(5);
            return FetchPriceFromMarket(symbol); // appel lourd
        });
    }
}

✅ Points clés :

• AbsoluteExpirationRelativeToNow : durée avant expiration

• SlidingExpiration : réinitialise le délai à chaque accès

• Idéal pour données fréquentes mais non critiques en temps réel

---

🔹 2. Response Compression en ASP.NET Core

• Objectif : réduire la taille des réponses HTTP pour améliorer le throughput et la latence.

• Activation simple :

builder.Services.AddResponseCompression(options =>
{
    options.Providers.Add<GzipCompressionProvider>();
    options.EnableForHttps = true;
});

app.UseResponseCompression();

• Configure le niveau de compression :

builder.Services.Configure<GzipCompressionProviderOptions>(options =>
{
    options.Level = System.IO.Compression.CompressionLevel.Fastest;
});

✅ Utile pour API REST, SignalR ou dashboards temps réel.

---

🔹 3. Diagnostiquer et améliorer les performances d’une application .NET Core

✅ Étapes principales :

1. Mesurer avant d’optimiser : utiliser Stopwatch, counters, diagnostics.

2. Profiler : identifier hot paths et contention.

3. Optimisation mémoire :

   • Minimiser allocations temporaires

   • Réutiliser buffers (ArrayPool<T>)

   • Eviter boxing/unboxing

4. Optimisation CPU :

   • Parallelism contrôlé (Task.Run, Parallel.ForEach)

   • Lock-free ou ConcurrentCollections pour concurrence

5. Optimisation I/O :

   • Async/await pour appels DB, API, fichiers

   • Compression et caching

6. Monitoring en production :

   • EventCounters, Metrics, Logging, AppInsights

---

🔹 4. Configurer le logging en .NET Core

• ILogger (intégré) :

public class TradeService
{
    private readonly ILogger<TradeService> _logger;
    public TradeService(ILogger<TradeService> logger) => _logger = logger;
    public void ExecuteTrade(string symbol)
    {
        _logger.LogInformation("Trade executed for {Symbol}", symbol);
    }
}

• Serilog :

Log.Logger = new LoggerConfiguration()
    .WriteTo.Console()
    .WriteTo.File("logs/trades.txt")
    .CreateLogger();

builder.Host.UseSerilog();

• NLog :

builder.Logging.ClearProviders();
builder.Logging.AddNLog("nlog.config");

✅ Permet de centraliser et filtrer les logs par niveau (Info, Warning, Error) pour diagnostic et analyse perf.

---

🔹 5. Outils pour profiler une application .NET Core

Outil	Description
Visual Studio Profiler	CPU, mémoire, allocation, contention, hot paths
dotTrace / dotMemory (JetBrains)	Profiling avancé, analyse heap et threads
PerfView	Analyse GC, allocations, CPU, thread contention
BenchmarkDotNet	Micro-benchmark pour comparer implémentations
dotnet-counters / dotnet-trace / dotnet-dump	Outils CLI pour diagnostics runtime
Application Insights / Prometheus / Grafana	Monitoring en production

✅ Bonnes pratiques :

• Profiler en environnement représentatif (load test ou staging)

• Identifier hot paths avant d’optimiser

• Mesurer l’impact des optimisations

---

📘 Résumé des pratiques de performance et optimisation

Domaine	Bonnes pratiques
Caching	IMemoryCache, expiration relative/sliding, ArrayPool
Compression	Gzip/ Brotli via ResponseCompression
Monitoring	Stopwatch, counters, EventCounters
Profiling	Visual Studio Profiler, dotTrace, PerfView
Logging	ILogger, Serilog, NLog, structured logs
Async/Parallélisme	Task.Run, Parallel, async/await, lock-free
I/O	Async DB/HTTP, batching, compression
Allocation mémoire	Minimiser GC pressure, reuse buffers, avoid boxing

---