Este libro está dirigido tanto a desarrolladores principiantes como experimentados que tienen que enfrentarse a problemas de rendimiento en sus desarrollos con código .NET.

En él los autores se dedican a desmitificar el rendimiento del código .NET; no le llevarán por las empinadas cuestas de la puesta a punto, sino que le darán métodos sencillos para perfilar una aplicación y encontrar rápidamente el 20% de los errores del código que corresponden al 80% de la ralentización. Le mostrarán todas las herramientas teóricas necesarias para saber exactamente dónde buscar los problemas de rendimiento y cómo solucionarlos.

Tras explicar el método y las herramientas, los autores se apoyan en una aplicación de demostración (escrita en C#), basada en un paquete de software industrial real, para mostrarle los métodos de encontrar los cuellos de botella. Esta aplicación ha sido diseñada específicamente para contener una amplia gama de los errores de código que tradicionalmente causan problemas de rendimiento. El libro le mostrará cómo detectar estos diferentes errores en los resultados de una herramienta de «perfilado de .NET», para luego analizarlos en detalle y finalmente solucionarlos. La aplicación corresponde a las arquitecturas web modernas, con un cliente (en Blazor WebAssembly) y una API (en ASP.NET 6). Auxiliándose con Visual Studio 2022, la última versión del IDE de Microsoft, podrá descubrir cómo la herramienta puede extraer métricas que le permiten encontrar los problemas rápidamente.

Encontrará elementos complementarios para su descarga en www.ediciones-eni.com.


¡Nuevo! Rondas de preguntas disponibles con la versión online.

¡Ronda de preguntas
incluida en
la versión online !

• Ponga a prueba sus conocimientos al final de cada capítulo
• Evalúe sus competencias

Descargas

• Descargar los ejemplos del libro (365 Ko)

Introducción

1. 1. Prólogo
2. 2. Los riesgos de la sobreoptimización
3. 3. El principio del perfilado y el benchmarking
4. 4. El reto financiero y ecológico
5. 5. Metodología
6. 6. Entorno necesario

Principios de perfilado

1. 1. Una actividad estrictamente regulada
2. 2. Estabilidad de la plataforma
   1. 2.1 ¿ Por qué esta regla ?
   2. 2.2 ¿ Cómo aplicar esta regla ?
   3. 2.3 Extraer los casos particulares
   4. 2.4 Relación con la mantenibilidad
3. 3. Neutralidad del entorno
   1. 3.1 El principio
   2. 3.2 Virtualización
      1. 3.2.1 Virtualización pesada
      2. 3.2.2 Virtualización ligera
   3. 3.3 Transferencia de la visualización
   4. 3.4 Efectos de cachés externas
   5. 3.5 Procesos externos
   6. 3.6 Servicios diversos
   7. 3.7 Comparación con la nanotecnología
4. 4. Establecer objetivos antes del análisis
5. 5. Mejoras cuantificables
   1. 5.1 ¿ Por qué esta regla ?
   2. 5.2 ¿ Cómo aplicar esta regla ?
6. 6. Granularidad descendente
   1. 6.1 Empecemos con una parábola
   2. 6.2 Un ejemplo
   3. 6.3 Advertencia
   4. 6.4 ¿ Quién es responsable ?

Perfilar una aplicación .NET

1. 1. Gestión de la memoria de la parte de .NET
   1. 1.1 Principios de base
   2. 1.2 Gestión automatizada de memoria y rendimiento
   3. 1.3 El caso particular del tiempo real
      1. 1.3.1 Aclarar un malentendido
      2. 1.3.2 El no determinismo de los recolectores de basura
   4. 1.4 Asignar memoria
   5. 1.5 Cómo nos ayuda .NET
   6. 1.6 Tipos por valores y referencias
      1. 1.6.1 Funcionamiento de una pila
      2. 1.6.2 Regresar al código IL
      3. 1.6.3 Diferencia entre valor y referencia
      4. 1.6.4 El caso particular de las estructuras
      5. 1.6.5 Vincular al rendimiento
   7. 1.7 Calcular el tamaño de la memoria a asignar
      1. 1.7.1 El caso del código gestionado al 100 %
      2. 1.7.2 El caso de objetos sujetos a interoperabilidad
   8. 1.8 Recolección de la memoria
      1. 1.8.1 Criterios para la recolección de la memoria
      2. 1.8.2 Mecanismo de compactación
      3. 1.8.3 Memoria fija y fragmentación
      4. 1.8.4 Activar y ejecutar el recolector de basura
      5. 1.8.5 Noción de generación
      6. 1.8.6 Impacto de la codificación en el rendimiento
      7. 1.8.7 Elegir el recolector de basura
   9. 1.9 Boxing, unboxing y el rendimiento asociado
      1. 1.9.1 ¿ Cuál es el problema ?
      2. 1.9.2 El boxing/unboxing y el rendimiento
      3. 1.9.3 El remedio
   10. 1.10 Gestión de la memoria y finalización
       1. 1.10.1 ¡Dejemos que .NET lo haga!
       2. 1.10.2 Liberar los recursos externos durante la ejecución del GC
       3. 1.10.3 Funcionamiento del finalizador
       4. 1.10.4 Liberar los recursos lo antes posible
       5. 1.10.5 Combinar las dos operaciones
   11. 1.11 Una observación final
2. 2. Particularidades de las funciones en línea
   1. 2.1 Mecanismo de las funciones en línea
   2. 2.2 Problemática de rendimiento y funciones en línea (online)
   3. 2.3 Impacto en los perfiladores
3. 3. Impacto de la gestión de la memoria en el rendimiento
   1. 3.1 Una gran diversidad en los impactos
   2. 3.2 Uso de la memoria virtual
   3. 3.3 Fugas de memoria
   4. 3.4 Montón especial para los objetos grandes y la fragmentación de memoria
4. 4. Otros recursos que hay que vigilar
   1. 4.1 La memoria no lo es todo
   2. 4.2 La CPU
   3. 4.3 Las entradas/salidas
   4. 4.4 Espacio de disco disponible
   5. 4.5 Ancho de banda

Aplicación de prueba

1. 1. Preámbulo
   1. 1.1 Una migración histórica
2. 2. Criterios de elección
   1. 2.1 ¿ Por qué esta aplicación ?
   2. 2.2 Utilizar la retroalimentación
   3. 2.3 La elección de la transparencia
   4. 2.4 Los límites de la transparencia
3. 3. Aplicación seleccionada
   1. 3.1 Campo de uso
   2. 3.2 Arquitectura
   3. 3.3 Interfaz
   4. 3.4 Descripción de la actividad
4. 4. Detalles de la aplicación
   1. 4.1 Encontrar la aplicación
   2. 4.2 Instalar la base de datos
      1. 4.2.1 Crear manualmente
      2. 4.2.2 Usar los scripts de generación
   3. 4.3 Instalar la aplicación
      1. 4.3.1 Abrir la solución
      2. 4.3.2 Configurar el proyecto
      3. 4.3.3 Ejecutar la aplicación
   4. 4.4 Detalles de los ensambles
   5. 4.5 Arquitectura del cliente
   6. 4.6 Estructura de los servicios web
   7. 4.7 Estructura de la base de datos
5. 5. Explicación sobre la complejidad de la aplicación
6. 6. Método recomendado

Presentación de las herramientas

1. 1. Elegir las herramientas
2. 2. Visual Studio 2022
   1. 2.1 Ventana de diagnóstico
   2. 2.2 Sesión de perfilado
3. 3. Contadores de rendimiento
   1. 3.1 Terminología
   2. 3.2 Windows
   3. 3.3 Linux y macOS
4. 4. BenchmarkdotNet
   1. 4.1 Crear un proyecto de benchmark
   2. 4.2 Crear un benchmark
   3. 4.3 Ejecutar el benchmark
5. 5. Herramientas alternativas

Perfilado

1. 1. ¿ Por dónde empezar ?
2. 2. Escenarios de perfilado
   1. 2.1 Primer escenario: mostrar los datos de una persona
   2. 2.2 Segundo escenario: mostrar y editar un contrato
3. 3. Ejecutar un perfilado
   1. 3.1 Perfilar la API: primer escenario
      1. 3.1.1 Ejecutar con el perfilador
      2. 3.1.2 Primera optimización
      3. 3.1.3 Prueba de carga
      4. 3.1.4 Segunda optimización
   2. 3.2 Refactorizar tras las optimizaciones
      1. 3.2.1 Mezcla de responsabilidades
      2. 3.2.2 Suprimir static
      3. 3.2.3 Usar la inyección de dependencias
      4. 3.2.4 Perfilar la API: primer escenario tras la refactorización
   3. 3.3 Perfilar la API: segundo escenario
      1. 3.3.1 Análisis del consumo de memoria
      2. 3.3.2 Primera optimización
      3. 3.3.3 Benchmark de la descompresión del archivo de contrato
      4. 3.3.4 Segunda optimización
      5. 3.3.5 Implementar el pooling
4. 4. Conclusión

Más allá del perfilado

1. 1. Introducción
2. 2. Pistas de mejora restantes
   1. 2.1 Introducción
   2. 2.2 Mejorar la experiencia
   3. 2.3 Tiempo de carga de la aplicación
   4. 2.4 Procesamiento asíncrono
   5. 2.5 Marcar los cambios de aplicación
   6. 2.6 Algunas cuestiones finales
      1. 2.6.1 Gestión correcta de las trazas
      2. 2.6.2 Duplicar las consultas SQL
      3. 2.6.3 Evitar el exceso de arquitectura
      4. 2.6.4 Paginar los resultados
      5. 2.6.5 El recolector de basura lleva tiempo
      6. 2.6.6 Limitar las excepciones
      7. 2.6.7 Funciones Equals y GetHashCode
      8. 2.6.8 AddRange
      9. 2.6.9 Concatenar cadenas
3. 3. Tuning
   1. 3.1 Cuidado
   2. 3.2 Compilar en release
   3. 3.3 El cursor de la consistencia
      1. 3.3.1 BASE en lugar de ACID
      2. 3.3.2 Un segundo ejemplo
      3. 3.3.3 Pasar el código de PROFI a BASE
   4. 3.4 Asincronía globalizada
   5. 3.5 Utilizar referencias débiles
   6. 3.6 Cuidado con el tuning extremo
      1. 3.6.1 Límites del tuning
      2. 3.6.2 Struct en lugar de class
      3. 3.6.3 Instanciación tardía y suspensión precoz
      4. 3.6.4 ¿ Byte en lugar de int en Enum ?
4. 4. Ir más lejos mediante la rearquitectura
   1. 4.1 Problemática
   2. 4.2 Escalabilidad
      1. 4.2.1 Concepto
      2. 4.2.2 Modos de escalabilidad
      3. 4.2.3 Paralelización de los procesamientos
      4. 4.2.4 Mejores prácticas para la escalabilidad
      5. 4.2.5 Parallel Linq
   3. 4.3 Institucionalizar la caché
   4. 4.4 Pensar Lean/Agile
      1. 4.4.1 IMDB
      2. 4.4.2 NoSQL
      3. 4.4.3 CQRS
      4. 4.4.4 Prevalencia
   5. 4.5 Rendimiento de las nuevas arquitecturas
      1. 4.5.1 Problemática
      2. 4.5.2 Scale Out
      3. 4.5.3 Paralelización
      4. 4.5.4 Movilidad
      5. 4.5.5 SOA/EDA/ESB
   6. 4.6 Y para ir aún más lejos

Conclusión

1. 1. Todo puede causar problemas
2. 2. Lista de verificación
3. 3. Las causas de los errores
4. 4. Codificar ligero
5. 5. Conclusión
8. índice