Ce livre sur la performance du code .NET s’adresse aux développeurs débutants comme expérimentés qui ont à faire face à des problèmes de performances sur leurs développements.

Dans ce livre, les auteurs se consacrent à démystifier la performance du code .NET ; il ne vous entraînera pas sur les pentes ardues du tuning, mais vous donnera des méthodes simples pour profiler une application et retrouver rapidement les 20% d’erreurs de code qui correspondent à 80% du ralentissement. Il vous donnera tous les outils théoriques nécessaires pour savoir précisément où chercher les problèmes de performance et comment les corriger.

Après avoir exposé la méthode et les outils, les auteurs s’appuient sur une application de démonstration (écrite en C#), basée sur un progiciel industriel réel, pour vous faire découvrir les méthodes de recherche des goulets d’étranglement. Cette application a été spécialement conçue pour contenir un grand éventail des erreurs de code traditionnellement à l’origine de problèmes de performances. Le livre vous montrera comment détecter ces différentes erreurs dans les résultats d’un outil « profileur .NET », puis les analyser finement et enfin les corriger. L'application correspond aux architectures web modernes, avec un client (en Blazor WebAssembly) et une API (en ASP.NET 6). À l'aide de Visual Studio 2022, la toute dernière version de l'IDE, le lecteur découvrira comment l'outil peut remonter les métriques permettant de trouver les problèmes rapidement.


Quizinclus dans
la version en ligne !

• Testez vos connaissances à l'issue de chaque chapitre
• Validez vos acquis

Téléchargements

• Des fichiers complémentaires (1 490 Ko)

Introduction

1. 1. Avant-propos
2. 2. Les risques de la suroptimisation
3. 3. Le principe du profilage et du benchmarking
4. 4. L'enjeu financier et écologique
5. 5. Méthodologie
6. 6. Environnement nécessaire

Principes du profilage

1. 1. Une activité strictement régulée
2. 2. Stabilité de la plate-forme
   1. 2.1 Pourquoi cette règle ?
   2. 2.2 Comment appliquer cette règle ?
   3. 2.3 Extraire les cas particuliers
   4. 2.4 Lien avec la maintenabilité
3. 3. Neutralité de l’environnement
   1. 3.1 Le principe
   2. 3.2 Virtualisation
      1. 3.2.1 Virtualisation lourde
      2. 3.2.2 Virtualisation légère
   3. 3.3 Déport d’affichage
   4. 3.4 Effets de caches externes
   5. 3.5 Processus externe
   6. 3.6 Services divers
   7. 3.7 Comparaison avec la nano-technologie
4. 4. Objectifs fixés avant l’analyse
5. 5. Améliorations mesurables
   1. 5.1 Pourquoi cette règle ?
   2. 5.2 Comment appliquer cette règle ?
6. 6. Granularité descendante
   1. 6.1 Commençons par une parabole
   2. 6.2 Un exemple
   3. 6.3 Avertissement
   4. 6.4 Qui est responsable ?

Profilage d’une application .NET

1. 1. Gestion de la mémoire par .NET
   1. 1.1 Principes de base
   2. 1.2 Gestion de mémoire automatisée et performances
   3. 1.3 Le cas particulier du temps réel
      1. 1.3.1 Lever un malentendu
      2. 1.3.2 Non-déterminisme des ramasse-miettes
   4. 1.4 Affectation de la mémoire
   5. 1.5 Comment .NET nous aide
   6. 1.6 Types valeurs et références
      1. 1.6.1 Fonctionnement d'une pile
      2. 1.6.2 Retour sur le code IL
      3. 1.6.3 Différence entre valeur et référence
      4. 1.6.4 Cas particulier des structures
      5. 1.6.5 Lien à la performance
   7. 1.7 Calcul de la taille mémoire à affecter
      1. 1.7.1 Cas du code 100 % géré
      2. 1.7.2 Cas des objets sujets à interopérabilité
   8. 1.8 Collecte de la mémoire
      1. 1.8.1 Critères de collecte de la mémoire
      2. 1.8.2 Mécanisme de compactage
      3. 1.8.3 Mémoire fixée et fragmentation
      4. 1.8.4 Déclenchement et exécution du ramasse-miettes
      5. 1.8.5 Notion de génération
      6. 1.8.6 Impact sur le codage pour la performance
      7. 1.8.7 Choix du ramasse-miettes
   9. 1.9 Boxing, unboxing et performances associées
      1. 1.9.1 Quel est le problème ?
      2. 1.9.2 Le boxing/unboxing et les performances
      3. 1.9.3 Le remède
   10. 1.10 Gestion de mémoire et finalisation
       1. 1.10.1 Laissons faire .NET !
       2. 1.10.2 Relâcher des ressources externes lors du passage du GC
       3. 1.10.3 Fonctionnement du finaliseur
       4. 1.10.4 Relâcher les ressources au plus tôt
       5. 1.10.5 Combiner les deux opérations
   11. 1.11 Une dernière remarque
2. 2. Particularité des fonctions inline
   1. 2.1 Mécanisme des fonctions inline
   2. 2.2 Problématiques de performance et fonctions inline
   3. 2.3 Impact sur les profileurs
3. 3. Impact de la gestion mémoire sur la performance
   1. 3.1 Une grande diversité dans les impacts
   2. 3.2 Utilisation de la mémoire virtuelle
   3. 3.3 Fuites mémoire
   4. 3.4 Tas spécial pour les gros objets et fragmentation mémoire
4. 4. Les autres ressources à surveiller
   1. 4.1 La mémoire n'est pas tout
   2. 4.2 Le CPU
   3. 4.3 Les entrées/sorties
   4. 4.4 L'espace disque disponible
   5. 4.5 La bande passante

Application de test

1. 1. Préambule
   1. 1.1 Une migration historique
2. 2. Critères de choix
   1. 2.1 Pourquoi cette application ?
   2. 2.2 Utiliser des retours d'expérience
   3. 2.3 Le choix de la transparence
   4. 2.4 Les limites de la transparence
3. 3. Application choisie
   1. 3.1 Domaine d'utilisation
   2. 3.2 Architecture
   3. 3.3 Interface
   4. 3.4 Description du métier
4. 4. Détail de l'application
   1. 4.1 Trouver l'application
   2. 4.2 Installation de la base de données
      1. 4.2.1 Création manuelle
      2. 4.2.2 Utilisation des scripts de génération
   3. 4.3 Installation de l'application
      1. 4.3.1 Ouverture de la solution
      2. 4.3.2 Configuration des projets
      3. 4.3.3 Exécution de l'application
   4. 4.4 Détails des assemblages
   5. 4.5 Architecture du client
   6. 4.6 Structure des services web
   7. 4.7 Structure de la base de données
5. 5. Explication de la lourdeur de l'application
6. 6. Méthode recommandée

Présentation des outils

1. 1. Choix des outils
2. 2. Visual Studio 2022
   1. 2.1 Fenêtre de diagnostic
   2. 2.2 Session de profilage
3. 3. Compteurs de performance
   1. 3.1 Terminologique
   2. 3.2 Windows
   3. 3.3 Linux et macOS
4. 4. BenchmarkdotNet
   1. 4.1 Création du projet de benchmark
   2. 4.2 Création d'un benchmark
   3. 4.3 Exécuter le benchmark
5. 5. Outils alternatifs

Profilage

1. 1. Par où commencer ?
2. 2. Scénarios de profilage
   1. 2.1 Premier scénario : afficher le détail d'une personne
   2. 2.2 Deuxième scénario : afficher et éditer un contrat
3. 3. Lancement du profilage
   1. 3.1 Profilage de l'API : premier scénario
      1. 3.1.1 Exécution avec profiler
      2. 3.1.2 Première optimisation
      3. 3.1.3 Test de charge
      4. 3.1.4 Seconde optimisation
   2. 3.2 Refactoring suite aux optimisations
      1. 3.2.1 Mélange des responsabilités
      2. 3.2.2 Suppression du static
      3. 3.2.3 Utilisation de l'injection de dépendances
      4. 3.2.4 Profilage de l'API : premier scénario, après refactoring
   3. 3.3 Profilage de l'API : deuxième scénario
      1. 3.3.1 Analyse de la consommation mémoire
      2. 3.3.2 Première optimisation
      3. 3.3.3 Benchmark du dézippage du fichier contrat
      4. 3.3.4 Seconde optimisation
      5. 3.3.5 Mise en place du pooling
4. 4. Conclusion

Au-delà du profilage

1. 1. Introduction
2. 2. Pistes d'amélioration restantes
   1. 2.1 Introduction
   2. 2.2 Amélioration du ressenti
   3. 2.3 Temps de chargement de l’application
   4. 2.4 Asynchronisme des traitements
   5. 2.5 Marquer les changements d'application
   6. 2.6 Quelques dernières problématiques
      1. 2.6.1 Gestion correcte des traces
      2. 2.6.2 Duplication des requêtes SQL
      3. 2.6.3 Éviter la sur-architecture
      4. 2.6.4 Pagination des résultats
      5. 2.6.5 Le ramasse-miettes prend du temps
      6. 2.6.6 Limiter les exceptions
      7. 2.6.7 Fonctions Equals et GetHashCode
      8. 2.6.8 AddRange
      9. 2.6.9 Concaténation de chaînes
3. 3. Tuning
   1. 3.1 Caveat
   2. 3.2 Compiler en release
   3. 3.3 Le curseur de la consistance
      1. 3.3.1 BASE au lieu d'ACID
      2. 3.3.2 Un second exemple
      3. 3.3.3 Passer le code de PROFI en BASE
   4. 3.4 Asynchronisme globalisé
   5. 3.5 Utiliser des références faibles
   6. 3.6 Attention au tuning extrême
      1. 3.6.1 Limites du tuning
      2. 3.6.2 Struct au lieu de class
      3. 3.6.3 Instanciation tardive et déréférencement précoce
      4. 3.6.4 Byte au lieu de int dans Enum ?
4. 4. Aller plus loin en réarchitecturant
   1. 4.1 Problématique
   2. 4.2 Scalabilité
      1. 4.2.1 Concept
      2. 4.2.2 Modes de scalabilité
      3. 4.2.3 Parallélisation des traitements
      4. 4.2.4 Bonnes pratiques pour la scalabilité
      5. 4.2.5 Parallel Linq
   3. 4.3 Institutionnaliser le cache
   4. 4.4 Penser Lean/Agile
      1. 4.4.1 IMDB
      2. 4.4.2 NoSQL
      3. 4.4.3 CQRS
      4. 4.4.4 Prévalence
   5. 4.5 Performance des nouvelles architectures
      1. 4.5.1 Problématique
      2. 4.5.2 Scale Out
      3. 4.5.3 Parallélisation
      4. 4.5.4 Mobilité
      5. 4.5.5 SOA/EDA/ESB
   6. 4.6 Et pour aller encore plus loin

Conclusion

1. 1. Tout peut poser problème
2. 2. Checklist
3. 3. Les causes des erreurs
4. 4. Coder léger
5. 5. Conclusion
8. Index