Suscripciones ENI: ¡Acceso ilimitado a todos los libros y vídeos de ENI!  Descubrir
Haz tu pedido antes del 21 de diciembre para recibirlo a tiempo antes de Navidad (para entregas en España peninsular)
    1. Libros
    2. Escribir código .NET eficaz - Perfilado, benchmarking y buenas prácticas

Escribir código .NET eficaz Perfilado, benchmarking y buenas prácticas

¡Pronto disponible!
Síganos para estar al tanto de su publicación

Presentación

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.

Índice

  • Introducción
    • 1. Prólogo
    • 2. Los riesgos de la sobreoptimización
    • 3. El principio del perfilado y el benchmarking
    • 4. El reto financiero y ecológico
    • 5. Metodología
    • 6. Entorno necesario
  • Principios de perfilado
    • 1. Una actividad estrictamente regulada
    • 2. Estabilidad de la plataforma
      • 2.1 ¿ Por qué esta regla ?
      • 2.2 ¿ Cómo aplicar esta regla ?
      • 2.3 Extraer los casos particulares
      • 2.4 Relación con la mantenibilidad
    • 3. Neutralidad del entorno
      • 3.1 El principio
      • 3.2 Virtualización
        • 3.2.1 Virtualización pesada
        • 3.2.2 Virtualización ligera
      • 3.3 Transferencia de la visualización
      • 3.4 Efectos de cachés externas
      • 3.5 Procesos externos
      • 3.6 Servicios diversos
      • 3.7 Comparación con la nanotecnología
    • 4. Establecer objetivos antes del análisis
    • 5. Mejoras cuantificables
      • 5.1 ¿ Por qué esta regla ?
      • 5.2 ¿ Cómo aplicar esta regla ?
    • 6. Granularidad descendente
      • 6.1 Empecemos con una parábola
      • 6.2 Un ejemplo
      • 6.3 Advertencia
      • 6.4 ¿ Quién es responsable ?
  • Perfilar una aplicación .NET
    • 1. Gestión de la memoria de la parte de .NET
      • 1.1 Principios de base
      • 1.2 Gestión automatizada de memoria y rendimiento
      • 1.3 El caso particular del tiempo real
        • 1.3.1 Aclarar un malentendido
        • 1.3.2 El no determinismo de los recolectores de basura
      • 1.4 Asignar memoria
      • 1.5 Cómo nos ayuda .NET
      • 1.6 Tipos por valores y referencias
        • 1.6.1 Funcionamiento de una pila
        • 1.6.2 Regresar al código IL
        • 1.6.3 Diferencia entre valor y referencia
        • 1.6.4 El caso particular de las estructuras
        • 1.6.5 Vincular al rendimiento
      • 1.7 Calcular el tamaño de la memoria a asignar
        • 1.7.1 El caso del código gestionado al 100 %
        • 1.7.2 El caso de objetos sujetos a interoperabilidad
      • 1.8 Recolección de la memoria
        • 1.8.1 Criterios para la recolección de la memoria
        • 1.8.2 Mecanismo de compactación
        • 1.8.3 Memoria fija y fragmentación
        • 1.8.4 Activar y ejecutar el recolector de basura
        • 1.8.5 Noción de generación
        • 1.8.6 Impacto de la codificación en el rendimiento
        • 1.8.7 Elegir el recolector de basura
      • 1.9 Boxing, unboxing y el rendimiento asociado
        • 1.9.1 ¿ Cuál es el problema ?
        • 1.9.2 El boxing/unboxing y el rendimiento
        • 1.9.3 El remedio
      • 1.10 Gestión de la memoria y finalización
        • 1.10.1 ¡Dejemos que .NET lo haga!
        • 1.10.2 Liberar los recursos externos durante la ejecución del GC
        • 1.10.3 Funcionamiento del finalizador
        • 1.10.4 Liberar los recursos lo antes posible
        • 1.10.5 Combinar las dos operaciones
      • 1.11 Una observación final
    • 2. Particularidades de las funciones en línea
      • 2.1 Mecanismo de las funciones en línea
      • 2.2 Problemática de rendimiento y funciones en línea (online)
      • 2.3 Impacto en los perfiladores
    • 3. Impacto de la gestión de la memoria en el rendimiento
      • 3.1 Una gran diversidad en los impactos
      • 3.2 Uso de la memoria virtual
      • 3.3 Fugas de memoria
      • 3.4 Montón especial para los objetos grandes y la fragmentación de memoria
    • 4. Otros recursos que hay que vigilar
      • 4.1 La memoria no lo es todo
      • 4.2 La CPU
      • 4.3 Las entradas/salidas
      • 4.4 Espacio de disco disponible
      • 4.5 Ancho de banda
  • Aplicación de prueba
    • 1. Preámbulo
      • 1.1 Una migración histórica
    • 2. Criterios de elección
      • 2.1 ¿ Por qué esta aplicación ?
      • 2.2 Utilizar la retroalimentación
      • 2.3 La elección de la transparencia
      • 2.4 Los límites de la transparencia
    • 3. Aplicación seleccionada
      • 3.1 Campo de uso
      • 3.2 Arquitectura
      • 3.3 Interfaz
      • 3.4 Descripción de la actividad
    • 4. Detalles de la aplicación
      • 4.1 Encontrar la aplicación
      • 4.2 Instalar la base de datos
        • 4.2.1 Crear manualmente
        • 4.2.2 Usar los scripts de generación
      • 4.3 Instalar la aplicación
        • 4.3.1 Abrir la solución
        • 4.3.2 Configurar el proyecto
        • 4.3.3 Ejecutar la aplicación
      • 4.4 Detalles de los ensambles
      • 4.5 Arquitectura del cliente
      • 4.6 Estructura de los servicios web
      • 4.7 Estructura de la base de datos
    • 5. Explicación sobre la complejidad de la aplicación
    • 6. Método recomendado
  • Presentación de las herramientas
    • 1. Elegir las herramientas
    • 2. Visual Studio 2022
      • 2.1 Ventana de diagnóstico
      • 2.2 Sesión de perfilado
    • 3. Contadores de rendimiento
      • 3.1 Terminología
      • 3.2 Windows
      • 3.3 Linux y macOS
    • 4. BenchmarkdotNet
      • 4.1 Crear un proyecto de benchmark
      • 4.2 Crear un benchmark
      • 4.3 Ejecutar el benchmark
    • 5. Herramientas alternativas
  • Perfilado
    • 1. ¿ Por dónde empezar ?
    • 2. Escenarios de perfilado
      • 2.1 Primer escenario: mostrar los datos de una persona
      • 2.2 Segundo escenario: mostrar y editar un contrato
    • 3. Ejecutar un perfilado
      • 3.1 Perfilar la API: primer escenario
        • 3.1.1 Ejecutar con el perfilador
        • 3.1.2 Primera optimización
        • 3.1.3 Prueba de carga
        • 3.1.4 Segunda optimización
      • 3.2 Refactorizar tras las optimizaciones
        • 3.2.1 Mezcla de responsabilidades
        • 3.2.2 Suprimir static
        • 3.2.3 Usar la inyección de dependencias
        • 3.2.4 Perfilar la API: primer escenario tras la refactorización
      • 3.3 Perfilar la API: segundo escenario
        • 3.3.1 Análisis del consumo de memoria
        • 3.3.2 Primera optimización
        • 3.3.3 Benchmark de la descompresión del archivo de contrato
        • 3.3.4 Segunda optimización
        • 3.3.5 Implementar el pooling
    • 4. Conclusión
  • Más allá del perfilado
    • 1. Introducción
    • 2. Pistas de mejora restantes
      • 2.1 Introducción
      • 2.2 Mejorar la experiencia
      • 2.3 Tiempo de carga de la aplicación
      • 2.4 Procesamiento asíncrono
      • 2.5 Marcar los cambios de aplicación
      • 2.6 Algunas cuestiones finales
        • 2.6.1 Gestión correcta de las trazas
        • 2.6.2 Duplicar las consultas SQL
        • 2.6.3 Evitar el exceso de arquitectura
        • 2.6.4 Paginar los resultados
        • 2.6.5 El recolector de basura lleva tiempo
        • 2.6.6 Limitar las excepciones
        • 2.6.7 Funciones Equals y GetHashCode
        • 2.6.8 AddRange
        • 2.6.9 Concatenar cadenas
    • 3. Tuning
      • 3.1 Cuidado
      • 3.2 Compilar en release
      • 3.3 El cursor de la consistencia
        • 3.3.1 BASE en lugar de ACID
        • 3.3.2 Un segundo ejemplo
        • 3.3.3 Pasar el código de PROFI a BASE
      • 3.4 Asincronía globalizada
      • 3.5 Utilizar referencias débiles
      • 3.6 Cuidado con el tuning extremo
        • 3.6.1 Límites del tuning
        • 3.6.2 Struct en lugar de class
        • 3.6.3 Instanciación tardía y suspensión precoz
        • 3.6.4 ¿ Byte en lugar de int en Enum ?
    • 4. Ir más lejos mediante la rearquitectura
      • 4.1 Problemática
      • 4.2 Escalabilidad
        • 4.2.1 Concepto
        • 4.2.2 Modos de escalabilidad
        • 4.2.3 Paralelización de los procesamientos
        • 4.2.4 Mejores prácticas para la escalabilidad
        • 4.2.5 Parallel Linq
      • 4.3 Institucionalizar la caché
      • 4.4 Pensar Lean/Agile
        • 4.4.1 IMDB
        • 4.4.2 NoSQL
        • 4.4.3 CQRS
        • 4.4.4 Prevalencia
      • 4.5 Rendimiento de las nuevas arquitecturas
        • 4.5.1 Problemática
        • 4.5.2 Scale Out
        • 4.5.3 Paralelización
        • 4.5.4 Movilidad
        • 4.5.5 SOA/EDA/ESB
      • 4.6 Y para ir aún más lejos
  • Conclusión
    • 1. Todo puede causar problemas
    • 2. Lista de verificación
    • 3. Las causas de los errores
    • 4. Codificar ligero
    • 5. Conclusión
    • índice

Autores

Christophe MOMMERMás información

Ingeniero informático y programador apasionado, Christophe MOMMER tiene varias certificaciones de las tecnologías .NET y Azure emitidas por Microsoft. Como freelance, acompaña a los equipos de producción en la creación de código eficaz con un gran valor añadido. En sus libros comparte sus conocimientos para dominar la programación con las tecnologías .NET.

Jean-Philippe GOUIGOUXMás información

Jean-Philippe GOUIGOUX es ingeniero de sistemas mecánicos (Universidad de Tecnología de Compiègne) y licenciado por la Universidad de Cranfield en Inglaterra (Master of Science, Advanced Automation and Design). Certificado TOGAF, hoy en día director técnico de un grupo de editores de software empresarial, se especializa en la urbanización de los sistemas de información y sabe valorizar su certificación tanto en su entorno profesional con la implementación de API estandarizadas que permiten integraciones potentes y económicas, como en el contexto de la investigación académica sobre arquitecturas de microservicios. Jean-Philippe GOUIGOUX es un Microsoft MVP (Most Valuable Professional) en varias especialidades desde 2011. Interviene regularmente en universidades y conferencias sobre diversos temas de TI, como la gestión de datos, Docker o el rendimiento en .NET. Apasionado por compartir sus conocimientos, es autor de varios libros y vídeos publicados por Ediciones ENI.

Ingeniero informático y desarrollador apasionado, Christophe MOMMER cuenta con varias certificaciones de Microsoft en tecnologías .NET y Azure. En tanto que autónomo, asiste a los equipos de producción en la creación de código de alto rendimiento y valor añadido. En sus libros comparte sus conocimientos sobre cómo dominar el desarrollo con tecnologías .NET.

Características

  • Nivel Experto a Medio
  • Publicación febrero 2023
    • Encuadernación rústica - 17 x 21 cm
    • ISBN: 978-2-409-03984-3
    • EAN: 9782409039843
    • Ref. ENI: EIT2ECR

Descargas

  • Descargar los ejemplos del libro (365 Ko)