Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Writing High-Performance .NET Code

Writing High-Performance .NET Code

Accélérez les applications .NET en repérant les coûts qui comptent, sans renoncer au code managé.
par Ben Watson 2014 280 pages
4.30
291 évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

Points clés

Considérez l’environnement d’exécution de .NET comme un partenaire, et non comme un coût de performance.

Code managé ne signifie pas code lent. .NET fournit des services tels que le ramasse-miettes, la sécurité des types et la compilation à la volée, mais leur coût est souvent inférieur à ce qu’on suppose. Selon l’auteur, une mauvaise conception de l’application, des structures de données inadaptées et un code inefficace sont plus souvent en cause que l’environnement d’exécution. Le code managé peut même aider: l’allocation rapide, le compactage du tas et le placement du code peuvent profiter aux applications. Le code natif se justifie lorsqu’un besoin réel l’exige, par exemple pour accéder directement au matériel ou contrôler l’organisation de la mémoire, et non simplement parce qu’on le croit plus rapide.

Optimisez en fonction de l’environnement d’exécution. Le CLR a ses règles et ses attentes, notamment concernant la durée de vie des objets, l’allocation et la concurrence. Un code qui les respecte peut conserver la sécurité et la productivité de .NET tout en offrant de hautes performances. La bonne question n’est pas de savoir si le code managé a un surcoût, mais si ce surcoût compte dans la charge de travail mesurée.

Analyse

Le meilleur argument en faveur du code managé n’est pas que ses coûts disparaissent, mais que le coût global de l’ingénierie comprend les défauts, le débogage et la maintenance, et pas seulement le nombre d’instructions. Cela rappelle la distinction entre optimisation locale et optimisation à l’échelle du système : un léger coût lié à l’environnement d’exécution peut être compensé par une réduction des erreurs mémoire et une simplification du développement. Cette nuance est importante. Le comportement de l’environnement d’exécution varie selon les versions et le matériel ; ni l’affirmation que .NET est rapide ni celle qu’il est lent ne saurait remplacer des tests dans l’environnement de déploiement réel.

Fixez des objectifs mesurables, puis optimisez le chemin déterminant le plus lent.

Commencez par fixer un objectif. Une exigence comme « réactif » ne donne à une équipe aucun seuil vérifiable. Un objectif concret, par exemple maintenir une opération de l’interface utilisateur sous les 20 millisecondes, peut orienter l’implémentation et sa vérification. Les mesures doivent aussi préciser les conditions: la mémoire de travail sous une charge de pointe définie est plus utile qu’une limite mémoire sans explication. L’auteur raconte qu’une équipe serveur suivait les octets privés avant de découvrir qu’une grande partie de cette mémoire avait été paginée. Le passage à la mémoire de travail a permis de préciser la ressource réellement en cause.

Mesurez avant de modifier le code. Utilisez des profils et des tests de performance pour localiser le goulot d’étranglement, puis donnez la priorité à l’architecture et aux algorithmes plutôt qu’aux petites retouches du code. La loi d’Amdahl explique pourquoi: accélérer une faible part du travail total impose une limite stricte à l’amélioration globale. Les tests de performance nécessitent un préchauffage, des versions Release, un environnement isolé et suffisamment d’échantillons pour tenir compte du bruit.

Analyse

Il s’agit de l’ingénierie des performances conçue comme une boucle de rétroaction : définir l’état souhaité, observer le système, l’ajuster, puis observer à nouveau. Le choix de la mesure détermine ce que l’équipe voit ; un indicateur indirect peut donc donner une fausse impression de sécurité. Les octets privés et la mémoire de travail, par exemple, répondent à des questions différentes. Les percentiles comptent également, car les moyennes peuvent masquer des ralentissements ponctuels. Les tests de performance aident à isoler les causes, mais le comportement en production comprend la contention, les entrées-sorties et les variations de charge, que les microtests délibérément restreints excluent.

Gardez les objets ordinaires à courte durée de vie et réutilisez les grands tampons.

Allouer coûte peu; survivre coûte cher. Le ramasse-miettes, ou GC, alloue rapidement la plupart des petits objets dans la génération 0, la zone la plus jeune du tas. Les objets qui restent accessibles au moment d’une collecte peuvent être promus dans des générations plus anciennes, dont la collecte est plus coûteuse. La règle pratique du livre consiste à laisser mourir rapidement les objets temporaires, tout en réutilisant ceux qui, naturellement, survivent à plusieurs collectes. Les grands objets, généralement des tableaux, sont placés dans le tas des grands objets (LOH) à partir d’environ 85 000 octets et sont collectés avec la génération 2; les allocations répétées de grands objets sont donc particulièrement problématiques.

Un exemple en production rend ce coût concret. Un serveur a découvert que les tampons MemoryStream représentaient près de 90 % des allocations et que le GC consommait environ 25 % du temps processeur. Une solution de remplacement fondée sur un pool a réduit de 99 % les allocations d’objets volumineux et ramené le temps consacré au GC à moins de 1 %. Les pools doivent être limités et les objets réinitialisés de manière sûre, faute de quoi la réutilisation peut se transformer en fuite mémoire déguisée.

Analyse

La distinction essentielle est celle entre le volume d’allocations et la mémoire occupée par les objets vivants. Une vague d’objets temporaires peut être relativement inoffensive si ces objets disparaissent avant la collecte ; un plus petit nombre d’objets conservés peut rendre la collecte coûteuse, car le ramasse-miettes doit les parcourir. Cela correspond à la conception de la gestion mémoire générationnelle. Le pooling n’est toutefois pas toujours préférable. Il remplace la récupération automatique par une gestion explicite de la durée de vie, de la synchronisation et de la réinitialisation. Un pool ne justifie sa complexité que si le profilage montre que la réutilisation apporte une amélioration significative.

Faites en sorte que chaque thread soit utile en remplaçant l’attente par un flux asynchrone.

L’attente mobilise inutilement des ressources. Un thread bloqué en attendant le réseau, le disque ou le résultat d’une tâche ne peut accomplir aucun travail utile. Sous charge, les workers du pool de threads bloqués peuvent inciter le pool à créer des threads supplémentaires, ce qui augmente le coût de l’ordonnancement et des changements de contexte. Pour les entrées-sorties, utilisez de véritables API asynchrones qui renvoient des tâches, au lieu d’envelopper des lectures synchrones dans Task.Run. Le système d’exploitation peut terminer des entrées-sorties asynchrones sans réserver un thread worker qui resterait inactif.

Utilisez les tâches avec méthode. La bibliothèque parallèle de tâches (TPL) planifie le travail au moyen du pool de threads et prend en charge les continuations, l’annulation et la gestion des erreurs. La syntaxe async et await rend le code fondé sur les tâches plus facile à suivre, mais ne rend pas le blocage inoffensif. Évitez d’appeler systématiquement Wait ou d’accéder au résultat avant que la tâche soit terminée. Dans les boucles parallèles, attribuez un état local à chaque worker et regroupez les résultats par lots. L’exemple du livre a ramené une boucle d’un milliard d’éléments d’environ 108 secondes à moins d’une seconde, en partitionnant le travail et en évitant une mise à jour partagée à chaque itération.

Analyse

L’asynchronisme et le parallélisme répondent à des problèmes différents. L’asynchronisme libère un thread pendant qu’un travail attend un événement externe ; le parallélisme répartit les calculs entre les processeurs. Les combiner sans précaution peut ajouter des coûts d’ordonnancement des tâches et de coordination sans augmenter le débit. La théorie des files d’attente explique pourquoi le blocage devient particulièrement dommageable à l’approche de la capacité maximale : lorsque les workers sont occupés, les nouveaux travaux attendent plus longtemps, et ajouter des workers peut accroître la contention au lieu d’augmenter le débit de traitement. La bonne conception dépend du fait que la charge est limitée par les entrées-sorties, par le processeur ou par une ressource partagée saturée.

Examinez le travail effectué par les abstractions avant de les placer sur les chemins critiques.

Une syntaxe pratique peut masquer du travail réel. Un appel d’API peut allouer de la mémoire, effectuer du boxing (encapsulation d’une valeur dans un objet), invoquer la réflexion ou entraîner une répartition supplémentaire, même si le code source paraît simple. Dans un test, une transformation LINQ a pris environ 20 fois plus de temps qu’une boucle directe et a alloué de la mémoire. Dans l’exemple, l’invocation d’une méthode par réflexion était environ 100 fois plus lente qu’un appel via une interface connue. Ces ratios ne sont pas universels, mais montrent pourquoi les chemins critiques méritent d’être examinés.

Examinez les couches générées. Utilisez le profilage pour repérer les méthodes coûteuses, puis examinez l’IL ou l’implémentation du framework afin d’en comprendre la raison. Parmi les exemples: éviter de convertir plusieurs fois des chaînes en majuscules ou minuscules pour les comparer, utiliser TryParse plutôt que Parse lorsque des entrées invalides sont attendues, et ne pas se servir des exceptions comme mécanisme ordinaire de contrôle du flux. Conservez les abstractions lorsqu’elles améliorent la clarté; ne les supprimez ou ne les remplacez que si les mesures montrent que leur coût compte.

Analyse

C’est une forme utile de compréhension des abstractions. La leçon n’est pas que les outils expressifs sont mauvais, mais que leur coût peut inclure des allocations, des répartitions et des copies de données invisibles à l’endroit de l’appel. Les optimisations du compilateur et de l’environnement d’exécution peuvent éliminer certains coûts ; les soupçons fondés uniquement sur le code source ne sont donc pas fiables. Une bonne revue de performance s’intéresse à la fois aux avantages de l’abstraction et au travail qu’elle génère. Les meilleurs systèmes préservent la clarté de haut niveau en dehors des chemins critiques, tout en concentrant les détails d’implémentation soigneusement optimisés là où les éléments observés le justifient.

Choisissez des organisations de données adaptées au processeur, et pas seulement à l’API.

La représentation détermine les performances. Une instance de classe comporte un surcoût d’objet et est accessible par une référence. Une structure peut stocker les valeurs de façon contiguë, ce qui peut réduire l’utilisation de la mémoire et améliorer la localité du cache, surtout dans de grands tableaux. Le livre compare un million de valeurs de 16 octets: un tableau de structures utilise environ 16 Mo, tandis que des objets de classe distincts accompagnés de références en utilisent environ 28 Mo dans un processus 32 bits, et plus de 40 Mo dans un processus 64 bits. Les structures ne remplacent pas les classes dans tous les cas: la copie de grandes valeurs peut annuler le gain, et les structures mutables peuvent être difficiles à manier.

Choisissez les collections en fonction de leur comportement. Les tableaux et List<T> favorisent l’accès séquentiel compact. Un dictionnaire offre un accès moyen en temps constant, tandis que les structures triées échangent de la mémoire et des coûts d’insertion contre un accès ordonné. Préallouez les collections lorsque leur capacité prévue est connue. Évitez les anciennes collections non génériques, qui exigent des conversions et peuvent entraîner du boxing pour les types valeur. Pour les charges numériques appropriées, les vecteurs SIMD peuvent traiter plusieurs valeurs par instruction, mais l’exemple montre que tous les algorithmes n’en tirent pas profit.

Analyse

L’organisation de la mémoire relie la conception logicielle à l’architecture du processeur. Un programme peut effectuer moins d’opérations abstraites et néanmoins s’exécuter plus lentement si ses données provoquent des défauts de cache et des accès indirects par pointeurs. C’est pourquoi un tableau compact de valeurs peut surpasser une collection d’objets alloués individuellement. L’optimisation centrée sur les données doit toutefois préserver la sémantique : les structures sont copiées par valeur, et modifier une représentation publique peut compliquer les API ou nuire à la correction. De même, SIMD favorise les opérations régulières et indépendantes, pas simplement le code qui a l’air mathématique. Il est essentiel de mesurer les performances avec des tailles de données réalistes.

Considérez le démarrage comme un budget de performance distinct de la vitesse en régime établi.

Les premiers appels ont un coût supplémentaire. Le compilateur JIT, ou compilateur à la volée, convertit le langage intermédiaire d’une méthode en code machine lors de sa première exécution. Ce coût de démarrage compte pour les services soumis à des délais stricts pour la première requête, même si de nombreuses applications s’intéressent davantage aux performances en régime établi. Le chargement des assemblys et des types peut également être lent; ne supposez donc pas que le JIT est la cause d’un démarrage long.

Choisissez une solution à partir des résultats. Un préchauffage guidé par le profilage peut préparer le code fréquemment utilisé sur un thread d’arrière-plan. NGEN crée à l’avance des images natives managées, ce qui réduit le travail du JIT, mais peut augmenter la taille des fichiers et nuire à la localité ou à l’optimisation entre assemblys. Un préchauffage explicite peut aider lorsque le trafic réel ne peut tolérer les délais de première utilisation. Le livre recommande de mesurer le temps JIT consommé par les méthodes avant de choisir entre ces options, et de tester séparément le parcours de démarrage et le débit habituel.

Analyse

Les performances au démarrage et en régime établi correspondent à des expériences utilisateur différentes, et optimiser l’une peut nuire à l’autre. C’est un principe général des systèmes : les moyennes calculées sur toute la durée de vie d’un processus peuvent masquer le coût de la première requête, celui que les utilisateurs remarquent le plus. Un budget distinct pour le démarrage rend ce compromis visible. La compilation anticipée peut déplacer le travail vers une étape antérieure sans le supprimer, tandis que le préchauffage peut consommer des ressources avant le traitement du trafic. Le bon choix dépend du déploiement, de la forme du trafic et du fait que la latence au démarrage ou l’efficacité durable constitue la contrainte dominante.

Transformez les connaissances en performance en tests automatisés, en télémétrie et en règles de code.

Faites de la performance une pratique d’équipe. Le livre recommande de fixer des objectifs explicites, de créer des tests de performance reproductibles, de consacrer les revues de code aux chemins critiques et de recueillir automatiquement des métriques. Les régressions de performance doivent être prises aussi au sérieux que les défaillances fonctionnelles. La surveillance en production peut révéler des comportements absents des petits environnements de test, tandis que des comparaisons contrôlées aident à évaluer une version par rapport à la précédente.

Utilisez les bons éléments à chaque échelle. Les compteurs de performance suivent des mesures continues telles que l’activité du processeur, de la mémoire et du GC. Le traçage d’événements pour Windows (ETW) enregistre des événements détaillés que des outils comme PerfView peuvent analyser à l’échelle du CLR, du système d’exploitation et de l’application. Des analyseurs statiques peuvent signaler des motifs tels que le boxing ou l’utilisation d’API disposant de solutions de remplacement plus sûres. L’automatisation réduit la dépendance à la mémoire de quelqu’un qui devrait penser à effectuer un profilage, et les données historiques rendent vérifiables les affirmations d’amélioration.

Analyse

Le passage de l’expertise individuelle aux infrastructures est lourd de conséquences : un système de mesure peut détecter les régressions même en l’absence du spécialiste qui avait initialement repéré le problème de performance. Cela rappelle l’observabilité dans d’autres systèmes d’ingénierie, où la télémétrie transforme des états internes invisibles en signaux que l’on peut diagnostiquer. Mais davantage de données n’est pas automatiquement préférable. L’instrumentation a un coût, les tableaux de bord peuvent pousser à optimiser des indicateurs indirects, et des tests bruités peuvent éroder la confiance. Un petit ensemble de métriques utiles à la prise de décision, associé à des charges réalistes et à des comparaisons automatisées, vaut mieux qu’une quantité impressionnante de compteurs laissés sans analyse.

Optimisez la latence de queue et les limites de ressources, pas seulement les moyennes.

Les expériences les plus lentes comptent. Un service peut afficher une moyenne respectable alors qu’une part significative des requêtes subit de longs délais. Le livre l’illustre avec les pauses du ramasse-miettes: un échantillon dont la moyenne était de 17 millisecondes affichait une pause au 95e percentile de 50 millisecondes. Les percentiles indiquent la valeur sous laquelle se situe une proportion donnée des observations, ce qui les rend utiles pour les systèmes où la disponibilité est essentielle. L’équipe doit recueillir suffisamment d’échantillons pour le percentile qui l’intéresse; quelques dizaines d’observations ne permettent pas d’avancer avec confiance une conclusion sur les valeurs extrêmes de la queue de distribution.

Définissez aussi la charge de travail. Les objectifs mémoire doivent préciser la métrique et les conditions de fonctionnement, par exemple la mémoire de travail au débit maximal de requêtes, plutôt que de se limiter à dire que la mémoire doit rester sous une certaine valeur. Les limites de ressources concernent le processeur, la mémoire, les entrées-sorties et la synchronisation. Un résultat dépourvu de contexte de charge est difficile à interpréter, à comparer ou à transformer en décision d’ingénierie.

Analyse

Le comportement en queue de distribution résulte souvent d’interactions plutôt que d’une seule fonction lente : le ramasse-miettes, les files d’attente, les entrées-sorties et la contention peuvent se combiner pour retarder une minorité de requêtes. Les percentiles révèlent cette expérience inégale, tandis que les moyennes décrivent l’efficacité globale. Aucun de ces indicateurs ne suffit à lui seul. Les percentiles extrêmes exigent de grands échantillons et des conditions de mesure stables ; chercher à améliorer la dernière fraction d’un percentile peut coûter davantage que ne le justifie l’impact sur les utilisateurs. Il est donc important que le livre insiste sur le fait que les exigences métier déterminent l’objectif : ce n’est pas une excuse pour ignorer les éléments techniques.

Analyse

Il vaut mieux considérer cet ouvrage comme un guide pratique du raisonnement sur les performances des systèmes .NET managés, plutôt que comme un catalogue d’astuces de programmation miraculeuses. Sa thèse centrale est que la surcharge due à l’environnement d’exécution ne constitue qu’une partie des performances d’une application et qu’elle n’est généralement pas le premier élément à incriminer. L’architecture, les algorithmes, les schémas d’allocation, la représentation des données et les blocages ont souvent un impact plus important. Cette priorité donne aux chapitres techniques un fil conducteur cohérent: définir des objectifs mesurables, repérer le goulot d’étranglement, comprendre le comportement de l’environnement d’exécution qui le sous-tend, puis ne modifier que la partie qui aura un effet concret.

L’idée forte qui revient le plus souvent est que les performances résultent des interactions entre différents éléments. La durée de vie des objets influe sur le ramasse-miettes; les schémas d’allocation façonnent la latence; la synchronisation a un effet sur le pool de threads; les abstractions déterminent le code généré et les déplacements de données. Optimiser une méthode isolément peut donc apporter un gain local tout en dégradant le système dans son ensemble. Les appels répétés du livre à profiler et à réaliser des benchmarks ne sont pas de simples formules de prudence: ils constituent la méthode permettant de distinguer les explications plausibles des causes réelles.

Les exemples concrets de l’ouvrage rendent perceptibles des coûts autrement invisibles. Le cas de MemoryStream relie les traces d’allocation à une forte diminution du temps consacré au GC. La boucle partitionnée montre comment la synchronisation peut prendre le pas sur les calculs utiles. Les comparaisons entre LINQ et la réflexion démontrent qu’une syntaxe simple peut dissimuler un travail considérable. Ces exemples sont surtout convaincants lorsqu’on les considère comme des illustrations de mécanismes, et non comme des promesses transposables de gains de vitesse précis.

Le livre aborde aussi les performances sous un angle organisationnel: les métriques automatisées, les tests de non-régression, les revues de code et l’analyse statique réduisent la dépendance à l’égard d’un seul expert. C’est un passage salutaire de l’optimisation héroïque à la maintenance continue. L’ouvrage a toutefois une limite liée à l’époque où il a été écrit. Il décrit certaines versions de .NET Framework, du JIT et des outils, et les API ont évolué depuis sa publication. Certains conseils précis et résultats de benchmarks ne sont peut-être plus applicables tels quels. Son apport durable réside dans la démarche d’investigation: définir la charge de travail, mesurer les résultats pertinents, examiner l’implémentation et préserver la clarté, sauf si les données justifient une plus grande complexité.

Résumé en 30 secondes
Définissez des objectifs de performance explicites, mesurez les résultats dans des conditions de charge réalistes et commencez par corriger le goulot d’étranglement le plus pénalisant. Les objets à courte durée de vie sont généralement peu coûteux, tandis que les allocations volumineuses répétées peuvent alourdir le travail du ramasse-miettes ; le recours à un pool a permis à un serveur de réduire de 99 % ses allocations de grands objets. Les E/S asynchrones libèrent les threads qui, autrement, resteraient en attente, et le partitionnement d’une boucle portant sur un milliard d’éléments a réduit son temps d’exécution d’environ 108 secondes à moins d’une seconde. Examinez les abstractions utilisées dans les chemins critiques, choisissez des structures de données adaptées à la charge et suivez les percentiles en plus des moyennes. Les tests automatisés et la télémétrie en production permettent de détecter les régressions.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.30 sur 5
Moyenne de 291 évaluations de Goodreads et Amazon.

Writing High-Performance .NET Code reçoit des avis positifs, avec une note moyenne de 4,31/5. Les lecteurs apprécient ses conseils pratiques pour optimiser les applications .NET et soulignent son intérêt pour les programmeurs C# expérimentés. Le livre est salué pour la diversité des sujets liés aux performances qu’il aborde, notamment le ramasse-miettes et la compilation JIT. Certains le jugent indispensable pour les systèmes où les performances sont cruciales, tandis que d’autres rappellent que toutes les applications n’ont pas besoin d’un tel niveau d’optimisation. Quelques lecteurs s’attendaient à des analyses plus approfondies compte tenu de l’expérience de l’auteur chez Microsoft, mais, dans l’ensemble, le livre est considéré comme une ressource solide pour les développeurs .NET.

Votre note :
4.6
179 évaluations
Envie de lire le livre complet ?

Glossaire

environnement d’exécution du langage commun (CLR)

Environnement d’exécution du code managé

Environnement qui exécute le code managé .NET et fournit des services tels que le ramasse-miettes, le chargement des types et la compilation juste-à-temps. Le code de l’application s’exécute sous forme d’instructions machine dans cet environnement. Son comportement et sa configuration influent sur les performances ; les développeurs doivent donc comprendre comment leurs choix en matière d’allocation, de threads et d’API interagissent avec lui.

tas des grands objets (LOH)

Tas destiné aux allocations volumineuses

Tas managé utilisé pour les objets dont la taille atteint ou dépasse le seuil des grands objets défini par l’environnement d’exécution, soit environ 85 000 octets dans les versions décrites dans le livre. Les grands objets sont gérés différemment des petites allocations générationnelles et sont collectés avec la génération 2. Ce tas n’est pas compacté automatiquement de la même manière que le tas des petits objets ; des allocations volumineuses répétées peuvent donc entraîner une fragmentation.

traçage d’événements pour Windows (ETW)

Système de traçage des événements Windows

Fonctionnalité du système d’exploitation qui permet de produire et de collecter des événements de diagnostic typés provenant des applications, du CLR et des composants Windows. Les événements peuvent être filtrés par fournisseur, niveau et mots-clés, puis analysés avec les piles d’appels et les données temporelles. Le livre présente ETW comme un outil fondamental pour les investigations détaillées sur les performances et l’instrumentation personnalisée des applications.

bibliothèque parallèle de tâches (TPL)

API de concurrence fondées sur les tâches

Bibliothèque .NET permettant de planifier du travail et de coordonner des opérations asynchrones à l’aide d’objets Task. Elle utilise le pool de threads managés et fournit des continuations, l’annulation, des boucles parallèles et d’autres fonctionnalités de coordination. Les tâches peuvent éviter la gestion manuelle des threads, mais attendre leurs résultats en bloquant ou planifier un trop grand nombre de tâches minuscules peut gaspiller des ressources.

NGEN

Compilation managée anticipée

Le générateur d’images natives crée à l’avance des images natives à partir d’assemblages .NET, réduisant ainsi la quantité de compilation juste-à-temps nécessaire à l’exécution. Le code obtenu reste managé et s’exécute toujours sous le CLR. NGEN peut accélérer le démarrage, mais il peut augmenter l’espace disque utilisé et ne pas bénéficier de certaines optimisations disponibles avec la compilation JIT à l’exécution.

compilation JIT multicœur (Multicore JIT)

Compilation en arrière-plan guidée par profil

Optimisation du démarrage de .NET qui enregistre les méthodes utilisées pendant l’exécution d’une application et se sert de ce profil lors des lancements suivants pour compiler sur un thread distinct le code susceptible d’être nécessaire. Elle vise à réduire les délais lors de la première utilisation tout en conservant les avantages de la compilation JIT à l’exécution. Les applications ayant différents modes d’exécution peuvent utiliser des profils distincts.

loi d’Amdahl

Limite de l’accélération totale

Principe selon lequel la partie d’un programme qui reste inchangée limite l’amélioration maximale obtenue en optimisant ou en parallélisant une autre partie. Si une opération lente ne représente qu’une faible proportion du temps d’exécution total, l’accélérer considérablement ne procure qu’un gain global modeste. Ce principe aide à prioriser les interventions sur les goulots d’étranglement qui influent réellement sur les performances globales.

boxing (encapsulation d’une valeur dans un objet)

Encapsulation d’un type valeur dans le tas

Conversion d’un type valeur, comme un entier ou une structure, en référence à un objet. L’environnement d’exécution crée un objet dans le tas et y copie la valeur. Le boxing répété multiplie les allocations et la charge du ramasse-miettes, et peut également nuire à la localité des données. Il peut se produire implicitement lorsqu’un type valeur est transmis à une API qui attend un objet ou une interface.

À propos de l'auteur

Ben Watson est ingénieur logiciel chez Microsoft depuis 2008, spécialisé dans les applications serveur à hautes performances. Il a largement contribué à la plateforme Bing, en développant un système basé sur .NET qui traite un grand volume de requêtes à faible latence sur des milliers de machines. Son expertise en optimisation des performances .NET se reflète dans les deux ouvrages techniques qu’il a écrits. En dehors de son travail, il s’intéresse à de nombreux domaines, notamment le géocaching, la lecture, la musique classique et les moments en famille. Son expérience chez Microsoft et son rôle dans la création de systèmes efficaces à grande échelle ont fait de lui une référence en matière d’optimisation des performances .NET.

Télécharger le PDF

Pour garder le résumé de Writing High-Performance .NET Code pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Writing High-Performance .NET Code sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 25 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
1M+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...