Accès illimité 24h/24 à tous nos livres & vidéos ! Découvrez la Bibliothèque Numérique ENI. Cliquez ici.
  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)

  • En stock
  • Expédié en 24h00
  • Livraison à partir de 0,01 €
  • Version en ligne offerte pendant 1 an
  • 1 h d'accès gratuit à tous nos livres et vidéos pour chaque commande
  • Accessible immédiatement et pour une durée de 10 ans
  • Version HTML
  • Accès illimité 24h/24, 7J/7
  • Accès illimité 24h/24, 7J/7
  • Tous les livres en ligne, les vidéos et les cours enregistrés ENI
  • Plus de 10 nouveautés livres et vidéos chaque mois
  • Les nouveautés disponibles le jour de leur sortie
  • Accès 100% en ligne

Présentation

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

Table des matières

  • Introduction
    • 1. Avant-propos
    • 2. Les risques de la suroptimisation
    • 3. Le principe du profilage et du benchmarking
    • 4. L'enjeu financier et écologique
    • 5. Méthodologie
    • 6. Environnement nécessaire
  • Principes du profilage
    • 1. Une activité strictement régulée
    • 2. Stabilité de la plate-forme
      • 2.1 Pourquoi cette règle ?
      • 2.2 Comment appliquer cette règle ?
      • 2.3 Extraire les cas particuliers
      • 2.4 Lien avec la maintenabilité
    • 3. Neutralité de l’environnement
      • 3.1 Le principe
      • 3.2 Virtualisation
        • 3.2.1 Virtualisation lourde
        • 3.2.2 Virtualisation légère
      • 3.3 Déport d’affichage
      • 3.4 Effets de caches externes
      • 3.5 Processus externe
      • 3.6 Services divers
      • 3.7 Comparaison avec la nano-technologie
    • 4. Objectifs fixés avant l’analyse
    • 5. Améliorations mesurables
      • 5.1 Pourquoi cette règle ?
      • 5.2 Comment appliquer cette règle ?
    • 6. Granularité descendante
      • 6.1 Commençons par une parabole
      • 6.2 Un exemple
      • 6.3 Avertissement
      • 6.4 Qui est responsable ?
  • Profilage d’une application .NET
    • 1. Gestion de la mémoire par .NET
      • 1.1 Principes de base
      • 1.2 Gestion de mémoire automatisée et performances
      • 1.3 Le cas particulier du temps réel
        • 1.3.1 Lever un malentendu
        • 1.3.2 Non-déterminisme des ramasse-miettes
      • 1.4 Affectation de la mémoire
      • 1.5 Comment .NET nous aide
      • 1.6 Types valeurs et références
        • 1.6.1 Fonctionnement d'une pile
        • 1.6.2 Retour sur le code IL
        • 1.6.3 Différence entre valeur et référence
        • 1.6.4 Cas particulier des structures
        • 1.6.5 Lien à la performance
      • 1.7 Calcul de la taille mémoire à affecter
        • 1.7.1 Cas du code 100 % géré
        • 1.7.2 Cas des objets sujets à interopérabilité
      • 1.8 Collecte de la mémoire
        • 1.8.1 Critères de collecte de la mémoire
        • 1.8.2 Mécanisme de compactage
        • 1.8.3 Mémoire fixée et fragmentation
        • 1.8.4 Déclenchement et exécution du ramasse-miettes
        • 1.8.5 Notion de génération
        • 1.8.6 Impact sur le codage pour la performance
        • 1.8.7 Choix du ramasse-miettes
      • 1.9 Boxing, unboxing et performances associées
        • 1.9.1 Quel est le problème ?
        • 1.9.2 Le boxing/unboxing et les performances
        • 1.9.3 Le remède
      • 1.10 Gestion de mémoire et finalisation
        • 1.10.1 Laissons faire .NET !
        • 1.10.2 Relâcher des ressources externes lors du passage du GC
        • 1.10.3 Fonctionnement du finaliseur
        • 1.10.4 Relâcher les ressources au plus tôt
        • 1.10.5 Combiner les deux opérations
      • 1.11 Une dernière remarque
    • 2. Particularité des fonctions inline
      • 2.1 Mécanisme des fonctions inline
      • 2.2 Problématiques de performance et fonctions inline
      • 2.3 Impact sur les profileurs
    • 3. Impact de la gestion mémoire sur la performance
      • 3.1 Une grande diversité dans les impacts
      • 3.2 Utilisation de la mémoire virtuelle
      • 3.3 Fuites mémoire
      • 3.4 Tas spécial pour les gros objets et fragmentation mémoire
    • 4. Les autres ressources à surveiller
      • 4.1 La mémoire n'est pas tout
      • 4.2 Le CPU
      • 4.3 Les entrées/sorties
      • 4.4 L'espace disque disponible
      • 4.5 La bande passante
  • Application de test
    • 1. Préambule
      • 1.1 Une migration historique
    • 2. Critères de choix
      • 2.1 Pourquoi cette application ?
      • 2.2 Utiliser des retours d'expérience
      • 2.3 Le choix de la transparence
      • 2.4 Les limites de la transparence
    • 3. Application choisie
      • 3.1 Domaine d'utilisation
      • 3.2 Architecture
      • 3.3 Interface
      • 3.4 Description du métier
    • 4. Détail de l'application
      • 4.1 Trouver l'application
      • 4.2 Installation de la base de données
        • 4.2.1 Création manuelle
        • 4.2.2 Utilisation des scripts de génération
      • 4.3 Installation de l'application
        • 4.3.1 Ouverture de la solution
        • 4.3.2 Configuration des projets
        • 4.3.3 Exécution de l'application
      • 4.4 Détails des assemblages
      • 4.5 Architecture du client
      • 4.6 Structure des services web
      • 4.7 Structure de la base de données
    • 5. Explication de la lourdeur de l'application
    • 6. Méthode recommandée
  • Présentation des outils
    • 1. Choix des outils
    • 2. Visual Studio 2022
      • 2.1 Fenêtre de diagnostic
      • 2.2 Session de profilage
    • 3. Compteurs de performance
      • 3.1 Terminologique
      • 3.2 Windows
      • 3.3 Linux et macOS
    • 4. BenchmarkdotNet
      • 4.1 Création du projet de benchmark
      • 4.2 Création d'un benchmark
      • 4.3 Exécuter le benchmark
    • 5. Outils alternatifs
  • Profilage
    • 1. Par où commencer ?
    • 2. Scénarios de profilage
      • 2.1 Premier scénario : afficher le détail d'une personne
      • 2.2 Deuxième scénario : afficher et éditer un contrat
    • 3. Lancement du profilage
      • 3.1 Profilage de l'API : premier scénario
        • 3.1.1 Exécution avec profiler
        • 3.1.2 Première optimisation
        • 3.1.3 Test de charge
        • 3.1.4 Seconde optimisation
      • 3.2 Refactoring suite aux optimisations
        • 3.2.1 Mélange des responsabilités
        • 3.2.2 Suppression du static
        • 3.2.3 Utilisation de l'injection de dépendances
        • 3.2.4 Profilage de l'API : premier scénario, après refactoring
      • 3.3 Profilage de l'API : deuxième scénario
        • 3.3.1 Analyse de la consommation mémoire
        • 3.3.2 Première optimisation
        • 3.3.3 Benchmark du dézippage du fichier contrat
        • 3.3.4 Seconde optimisation
        • 3.3.5 Mise en place du pooling
    • 4. Conclusion
  • Au-delà du profilage
    • 1. Introduction
    • 2. Pistes d'amélioration restantes
      • 2.1 Introduction
      • 2.2 Amélioration du ressenti
      • 2.3 Temps de chargement de l’application
      • 2.4 Asynchronisme des traitements
      • 2.5 Marquer les changements d'application
      • 2.6 Quelques dernières problématiques
        • 2.6.1 Gestion correcte des traces
        • 2.6.2 Duplication des requêtes SQL
        • 2.6.3 Éviter la sur-architecture
        • 2.6.4 Pagination des résultats
        • 2.6.5 Le ramasse-miettes prend du temps
        • 2.6.6 Limiter les exceptions
        • 2.6.7 Fonctions Equals et GetHashCode
        • 2.6.8 AddRange
        • 2.6.9 Concaténation de chaînes
    • 3. Tuning
      • 3.1 Caveat
      • 3.2 Compiler en release
      • 3.3 Le curseur de la consistance
        • 3.3.1 BASE au lieu d'ACID
        • 3.3.2 Un second exemple
        • 3.3.3 Passer le code de PROFI en BASE
      • 3.4 Asynchronisme globalisé
      • 3.5 Utiliser des références faibles
      • 3.6 Attention au tuning extrême
        • 3.6.1 Limites du tuning
        • 3.6.2 Struct au lieu de class
        • 3.6.3 Instanciation tardive et déréférencement précoce
        • 3.6.4 Byte au lieu de int dans Enum ?
    • 4. Aller plus loin en réarchitecturant
      • 4.1 Problématique
      • 4.2 Scalabilité
        • 4.2.1 Concept
        • 4.2.2 Modes de scalabilité
        • 4.2.3 Parallélisation des traitements
        • 4.2.4 Bonnes pratiques pour la scalabilité
        • 4.2.5 Parallel Linq
      • 4.3 Institutionnaliser le cache
      • 4.4 Penser Lean/Agile
        • 4.4.1 IMDB
        • 4.4.2 NoSQL
        • 4.4.3 CQRS
        • 4.4.4 Prévalence
      • 4.5 Performance des nouvelles architectures
        • 4.5.1 Problématique
        • 4.5.2 Scale Out
        • 4.5.3 Parallélisation
        • 4.5.4 Mobilité
        • 4.5.5 SOA/EDA/ESB
      • 4.6 Et pour aller encore plus loin
  • Conclusion
    • 1. Tout peut poser problème
    • 2. Checklist
    • 3. Les causes des erreurs
    • 4. Coder léger
    • 5. Conclusion
    • Index

Auteurs

Christophe MOMMEREn savoir plus

Ingénieur Informatique et développeur passionné, Christophe MOMMER possède plusieurs certifications Microsoft sur les technologies .NET et Azure et est reconnu Microsoft MVP (Most Valuable Professional) dans la catégorie Developer Technologies. 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.

Jean-Philippe GOUIGOUXEn savoir plus

Ingénieur en Génie des Systèmes Mécaniques (Université de Technologie de Compiègne), diplômé de l'université de Cranfield en Angleterre (Master of science, spécialité Advanced Automation and Design), Jean-Philippe GOUIGOUX est aujourd'hui directeur technique d'un groupe d'éditeurs logiciels métier. Certifié TOGAF, il se spécialise en urbanisation des systèmes d'information et sait le valoriser à la fois dans son environnement professionnel avec la mise en place d'API normalisées permettant des intégrations puissantes et peu coûteuses, ainsi que dans le cadre de la recherche académique sur les architectures de microservices. Jean-Philippe GOUIGOUX est reconnu Microsoft MVP (Most Valuable Professional) dans diverses spécialités depuis 2011. Il intervient régulièrement en université ou lors de conférences sur des sujets informatiques variés tels que la gestion de données, Docker ou la performance en .NET. Passionné par le partage de ses connaissances, il est auteur de plusieurs livres et vidéos parus aux Éditions ENI.

Suivez Jean-Philippe GOUIGOUX : 

Caractéristiques

  • Niveau Confirmé à Expert
  • Nombre de pages 326 pages
  • Parution juin 2022
    • Livre (broché) - 17 x 21 cm
    • ISBN : 978-2-409-03613-2
    • EAN : 9782409036132
    • Ref. ENI : EI2ECR
  • Niveau Expert à Confirmé
  • Parution juin 2022
    • HTML
    • ISBN : 978-2-409-03614-9
    • EAN : 9782409036149
    • Ref. ENI : LNEI2ECR

Téléchargements

En complétant ce formulaire, vous acceptez d'être contacté afin de recevoir des informations sur nos produits et services ainsi que nos communications marketing. Vous aurez la possibilité de vous désabonner de nos communications à tout moment. Pour plus d'informations sur notre politique de protection des données, cliquez ici.
  • Des fichiers complémentaires (1 490 Ko)