Blog ENI : Toute la veille numérique !
En raison d'une opération de maintenance, le site Editions ENI sera inaccessible le mardi 10 décembre, en début de journée. Nous vous invitons à anticiper vos achats. Nous nous excusons pour la gêne occasionnée
En raison d'une opération de maintenance, le site Editions ENI sera inaccessible le mardi 10 décembre, en début de journée. Nous vous invitons à anticiper vos achats. Nous nous excusons pour la gêne occasionnée
  1. Livres et vidéos
  2. Ecrire du code .NET performant - Profilage, benchmarking et bonnes pratiques (2e édition)

Ecrire du code .NET performant Profilage, benchmarking et bonnes pratiques (2e édition)

Informations

Livraison possible dès le 11 décembre 2024
  • Livraison à partir de 0,01 €
  • Version en ligne offerte pendant 1 an
Livres rédigés par des auteurs francophones et imprimés à Nantes

Caractéristiques

  • Livre (broché) - 17 x 21 cm
  • ISBN : 978-2-409-03613-2
  • EAN : 9782409036132
  • Ref. ENI : EI2ECR

Informations

  • Consultable en ligne immédiatement après validation du paiement et pour une durée de 10 ans.
  • Version HTML
Livres rédigés par des auteurs francophones et imprimés à Nantes

Caractéristiques

  • HTML
  • ISBN : 978-2-409-03614-9
  • EAN : 9782409036149
  • Ref. ENI : LNEI2ECR
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...
Consulter des extraits du livre en ligne Aperçu du livre papier
  • Niveau Confirmé à Expert
  • Nombre de pages 326 pages
  • Parution juin 2022
  • Niveau Confirmé à Expert
  • Parution juin 2022
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

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
  6. Index
Auteur : Christophe MOMMER

Christophe MOMMER

Ingénieur Informatique et développeur passionné, Christophe MOMMER possède plusieurs certifications Microsoft sur les technologies .NET et Azure. Il est reconnu Most Valuable Professional (MVP) dans la catégorie Développeur expert C#/Blazor. En tant que freelance, il accompagne des équipes de production dans la création de code performant à forte valeur ajoutée, il partage dans ses livres ses connaissances pour maîtriser le développement avec les technologies .NET.

En savoir plus
Auteur : Jean-Philippe GOUIGOUX

Jean-Philippe GOUIGOUX

Ingénieur avec un double diplôme en Génie des Systèmes Mécaniques et automatisation de l'Université de Technologie de Compiègne et de Cranfield University, Jean-Philippe GOUIGOUX travaille aujourd'hui pour Salvia Développement en tant que directeur technique d'un groupe de six business units, ce qui lui permet de mettre en œuvre son approche d'industrialisation de l'édition logicielle. Jean-Philippe GOUIGOUX est reconnu Microsoft MVP (Most Valuable Professional) dans diverses spécialités depuis 2011, et certifié TOGAF. Il intervient régulièrement en conférences sur des sujets informatiques variés allant de la gestion de données à Docker, en passant par la performance en .NET. Passionné par le partage de ses connaissances, il est auteur de plusieurs livres et vidéos parus aux Éditions ENI.
En savoir plus

Nos nouveautés

voir plus