Dottrace .NET Core (Cómo funciona para desarrolladores)

Presentamos Dottrace .NET Core, una potente herramienta del ecosistema .NET que sirve como herramienta esencial .NET para la creación de perfiles de rendimiento. Como perfilador de rendimiento de .NET, la herramienta de rastreo de .NET permite a los desarrolladores capturar archivos de rastreo detallados que proporcionan información sobre los eventos en tiempo de ejecución de un proceso en ejecución. Esta herramienta es indispensable para optimizar las aplicaciones creadas en el marco .NET.

Tanto si está realizando pruebas unitarias como integrando compilaciones de integración continua, Dottrace le permite supervisar y analizar eficazmente el rendimiento de sus aplicaciones. Aprovechando esta herramienta, puede obtener un conocimiento más profundo del comportamiento de su aplicación, garantizando el máximo rendimiento y fiabilidad.

ironPDF es una completa biblioteca para trabajar con archivos PDF en aplicaciones .NET. Permite crear, editar y extraer contenido de archivos PDF. IronPDF admite funciones como la conversión de HTML a PDF, la fusión y la división de PDF. Esta biblioteca es una valiosa herramienta para cualquier aplicación que necesite generar o manipular documentos PDF. Este artículo utilizará esta biblioteca junto con Dottrace para expresar una aplicación real de la eficacia de Dottrace y IronPDF.

Primeros pasos con Dottrace .NET Core

Configuración de Dottrace .NET Core en proyectos .NET

En primer lugar, debe instalar Dottrace .NET Core mediante NuGet. Abra Visual Studio y siga estos pasos:

1. Abre Visual Studio.
2. Seleccione Crear un nuevo proyecto.
3. Seleccione Console App (.NET Core) y haga clic en Siguiente.
4. Nombra tu proyecto DottraceExample y haz clic en Crear.
5. En el Explorador de soluciones, haga clic con el botón derecho en el proyecto y seleccione Administrar paquetes NuGet.
6. En el gestor de paquetes NuGet, busque JetBrains.dotTrace.CommandLineTools.

7. Seleccione el paquete y haga clic en Instalar.

   Esto instala Dottrace como una dependencia en su proyecto.

   

Creación de perfiles de una aplicación de consola sencilla

Vamos a crear una aplicación de consola básica para perfilar. Reemplaza el código en Program.cs con lo siguiente:

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Starting application...");
        Thread.Sleep(5000); // Simulating a time-consuming operation
        Console.WriteLine("Application finished.");
    }
}

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Starting application...");
        Thread.Sleep(5000); // Simulating a time-consuming operation
        Console.WriteLine("Application finished.");
    }
}

Imports System
Imports System.Threading
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Console.WriteLine("Starting application...")
		Thread.Sleep(5000) ' Simulating a time-consuming operation
		Console.WriteLine("Application finished.")
	End Sub
End Class

Construye y ejecuta tu aplicación pulsando F5. Una vez que la aplicación se esté ejecutando, necesitará su ID de proceso para la creación de perfiles. Puede encontrar el ID del proceso utilizando la ventana Herramientas de diagnóstico de Visual Studio o consultando el Administrador de tareas.

Para perfilar su aplicación utilizando Dottrace, abra una ventana de terminal o la Consola del Gestor de Paquetes en Visual Studio y ejecute:

dotnet trace collect --process-id <your-process-id> --output trace.nettrace

Sustituya <su-id-proceso> por el ID real del proceso de su aplicación en ejecución.

Una vez finalizada tu aplicación, tendrás un fichero trace.nettrace. Este archivo contiene todos los datos de perfil recogidos durante la ejecución de la aplicación. Puede analizar este archivo en Visual Studio. Sigue estos pasos:

1. Abre Visual Studio.
2. Vaya a Archivo > Abrir > Archivo.

3. Seleccione el archivo trace.nettrace y haga clic en Abrir.

   Visual Studio mostrará datos de rendimiento detallados, lo que le permitirá identificar y solucionar los cuellos de botella en el rendimiento.

   Ahora que ha configurado Dottrace y creado un ejemplo básico de creación de perfiles, puede pasar a implementar funciones más avanzadas.

Características de Dottrace .NET Core

Análisis del uso de la CPU

Una de las características clave de Dottrace .NET Core es el análisis del uso de la CPU. Esto le ayuda a identificar qué partes de su código consumen más recursos de CPU. He aquí cómo hacerlo:

En primer lugar, inicie su aplicación en Visual Studio. A continuación, en el terminal o Consola del Gestor de Paquetes, ejecute:

dotnet trace collect --process-id <your-process-id> --output cpu_usage.nettrace

Sustituya <su-id-proceso> por el ID real del proceso de su aplicación. Una vez finalizada la sesión de perfilado, abra el archivo cpu_usage.nettrace en Visual Studio:

using System;
using System.Diagnostics;
class Program
{
    static void Main(string[] args)
    {
        var sw = new Stopwatch();
        sw.Start();
        // Simulate a CPU-intensive operation
        for (int i = 0; i < 1000000000; i++) { }
        sw.Stop();
        Console.WriteLine($"Elapsed Time: {sw.ElapsedMilliseconds} ms");
    }
}

using System;
using System.Diagnostics;
class Program
{
    static void Main(string[] args)
    {
        var sw = new Stopwatch();
        sw.Start();
        // Simulate a CPU-intensive operation
        for (int i = 0; i < 1000000000; i++) { }
        sw.Stop();
        Console.WriteLine($"Elapsed Time: {sw.ElapsedMilliseconds} ms");
    }
}

Imports System
Imports System.Diagnostics
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim sw = New Stopwatch()
		sw.Start()
		' Simulate a CPU-intensive operation
		For i As Integer = 0 To 999999999
		Next i
		sw.Stop()
		Console.WriteLine($"Elapsed Time: {sw.ElapsedMilliseconds} ms")
	End Sub
End Class

Este código simula una operación intensiva de la CPU. Cuando analices el archivo cpu_usage.nettrace, verás que el bucle consume una cantidad significativa de tiempo de CPU.

Supervisión de la asignación de memoria

Dottrace .NET Core también puede ayudarle a supervisar la asignación de memoria en su aplicación. Esto es crucial para identificar fugas de memoria y optimizar su uso.

Ejecute su aplicación y recopile los datos de asignación de memoria:

dotnet trace collect --process-id <your-process-id> --output memory_allocation.nettrace

Después de la sesión, abra el archivo memory_allocation.nettrace en Visual Studio:

using System;
class Program
{
    static void Main(string[] args)
    {
        for (int i = 0; i < 10000; i++)
        {
            var data = new byte[1024]; // Allocate 1KB
        }
        Console.WriteLine("Memory allocation completed.");
    }
}

using System;
class Program
{
    static void Main(string[] args)
    {
        for (int i = 0; i < 10000; i++)
        {
            var data = new byte[1024]; // Allocate 1KB
        }
        Console.WriteLine("Memory allocation completed.");
    }
}

Imports System
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		For i As Integer = 0 To 9999
			Dim data = New Byte(1023){} ' Allocate 1KB
		Next i
		Console.WriteLine("Memory allocation completed.")
	End Sub
End Class

Este código asigna memoria en un bucle. El análisis del archivo memory_allocation.nettrace mostrará cuánta memoria se asigna y dónde ocurre en su código.

Creación de perfiles de operaciones de E/S

Otra característica esencial es la creación de perfiles de las operaciones de E/S. Le ayuda a comprender el impacto en el rendimiento de la lectura y escritura de archivos.

Inicia tu aplicación y recoge los datos de E/S:

dotnet trace collect --process-id <your-process-id> --output io_operations.nettrace

Abra el archivo io_operations.nettrace en Visual Studio para analizarlo:

using System;
using System.IO;
class Program
{
    static void Main(string[] args)
    {
        var filePath = "test.txt";
        // Write to file
        using (var writer = new StreamWriter(filePath))
        {
            for (int i = 0; i < 1000; i++)
            {
                writer.WriteLine("This is a test line.");
            }
        }
        // Read from file
        using (var reader = new StreamReader(filePath))
        {
            while (reader.ReadLine() != null) { }
        }
        Console.WriteLine("I/O operations completed.");
    }
}

using System;
using System.IO;
class Program
{
    static void Main(string[] args)
    {
        var filePath = "test.txt";
        // Write to file
        using (var writer = new StreamWriter(filePath))
        {
            for (int i = 0; i < 1000; i++)
            {
                writer.WriteLine("This is a test line.");
            }
        }
        // Read from file
        using (var reader = new StreamReader(filePath))
        {
            while (reader.ReadLine() != null) { }
        }
        Console.WriteLine("I/O operations completed.");
    }
}

Imports System
Imports System.IO
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim filePath = "test.txt"
		' Write to file
		Using writer = New StreamWriter(filePath)
			For i As Integer = 0 To 999
				writer.WriteLine("This is a test line.")
			Next i
		End Using
		' Read from file
		Using reader = New StreamReader(filePath)
			Do While reader.ReadLine() IsNot Nothing
			Loop
		End Using
		Console.WriteLine("I/O operations completed.")
	End Sub
End Class

Este código escribe y lee de un archivo. El análisis del archivo io_operations.nettrace revelará el tiempo empleado en las operaciones de E/S.

Identificación de cuellos de botella en el rendimiento

Identificar los cuellos de botella en el rendimiento es uno de los principales objetivos del uso de Dottrace. Analizando los archivos de rastreo recopilados, puede localizar las partes lentas de su código.

Inicie su aplicación y recopile datos de rendimiento:

dotnet trace collect --process-id <your-process-id> --output performance_bottlenecks.nettrace

Abra el archivo performance_bottlenecks.nettrace en Visual Studio:

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Starting application...");
        // Simulate a time-consuming operation
        Thread.Sleep(5000);
        Console.WriteLine("Application finished.");
    }
}

using System;
using System.Threading;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Starting application...");
        // Simulate a time-consuming operation
        Thread.Sleep(5000);
        Console.WriteLine("Application finished.");
    }
}

Imports System
Imports System.Threading
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Console.WriteLine("Starting application...")
		' Simulate a time-consuming operation
		Thread.Sleep(5000)
		Console.WriteLine("Application finished.")
	End Sub
End Class

Este código simula un retraso en la aplicación. El análisis del archivo performance_bottlenecks.nettrace mostrará dónde se emplea la mayor parte del tiempo, lo que le ayudará a optimizar esas partes.

Estos ejemplos cubren las características clave de Dottrace .NET Core. Ahora puede analizar el uso de la CPU, supervisar la asignación de memoria, perfilar las operaciones de E/S, identificar cuellos de botella en el rendimiento y realizar perfiles en entornos de producción. Cada función le ayuda a optimizar y mejorar sus aplicaciones .NET Core.

Integración de Dottrace con IronPDF

Introducción a IronPDF

ironPDF es una potente biblioteca .NET que le permite generar, editar y gestionar archivos PDF fácilmente en sus aplicaciones C#. Tanto si necesita crear nuevos PDF desde cero, convertir HTML a PDF o manipular PDF existentes, IronPDF le ofrece un amplio conjunto de funciones para realizar estas tareas con eficacia. Es beneficioso para las aplicaciones que requieren la generación y el procesamiento de PDF, como los sistemas de generación de informes, las soluciones de gestión de documentos y las aplicaciones web.

Caso práctico de fusión de IronPDF con Dottrace

Considere un escenario en el que tiene una aplicación web que genera informes PDF para los usuarios. Mediante el uso de Dottrace, puede realizar un seguimiento del rendimiento del proceso de generación de PDF, identificar problemas de rendimiento utilizando el archivo de seguimiento y realizar mejoras para mejorar la experiencia del usuario. Esta integración es especialmente valiosa para aplicaciones que manejan grandes volúmenes de documentos PDF o requieren un procesamiento de alto rendimiento.

Ejemplo de código del caso de uso

A continuación se muestra un ejemplo de código completo que demuestra cómo integrar IronPDF con Dottrace. Este ejemplo crea una simple conversión de HTML a PDF y utiliza Dottrace para monitorizar el rendimiento de la operación.

using System;
using IronPdf;
using Microsoft.Diagnostics.Tracing;
using Microsoft.Diagnostics.Tracing.Session;
class Program
{
    static void Main(string[] args)
    {
        // Start tracing session
        using (var session = new TraceEventSession("MySession"))
        {
            session.EnableProvider("Microsoft-Windows-DotNETRuntime");
            // Perform PDF generation
            var pdfDocument = GeneratePdf("Hello, world!");
            // Save the PDF to a file
            pdfDocument.SaveAs("example.pdf");
            // Stop tracing session
            session.Stop();
        }
        Console.WriteLine("PDF generated and performance traced successfully.");
    }
    static PdfDocument GeneratePdf(string htmlContent)
    {
        // Create an instance of the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();
        // Convert HTML to PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        return pdfDocument;
    }
}

using System;
using IronPdf;
using Microsoft.Diagnostics.Tracing;
using Microsoft.Diagnostics.Tracing.Session;
class Program
{
    static void Main(string[] args)
    {
        // Start tracing session
        using (var session = new TraceEventSession("MySession"))
        {
            session.EnableProvider("Microsoft-Windows-DotNETRuntime");
            // Perform PDF generation
            var pdfDocument = GeneratePdf("Hello, world!");
            // Save the PDF to a file
            pdfDocument.SaveAs("example.pdf");
            // Stop tracing session
            session.Stop();
        }
        Console.WriteLine("PDF generated and performance traced successfully.");
    }
    static PdfDocument GeneratePdf(string htmlContent)
    {
        // Create an instance of the HtmlToPdf renderer
        var renderer = new ChromePdfRenderer();
        // Convert HTML to PDF
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        return pdfDocument;
    }
}

Imports System
Imports IronPdf
Imports Microsoft.Diagnostics.Tracing
Imports Microsoft.Diagnostics.Tracing.Session
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Start tracing session
		Using session = New TraceEventSession("MySession")
			session.EnableProvider("Microsoft-Windows-DotNETRuntime")
			' Perform PDF generation
			Dim pdfDocument = GeneratePdf("Hello, world!")
			' Save the PDF to a file
			pdfDocument.SaveAs("example.pdf")
			' Stop tracing session
			session.Stop()
		End Using
		Console.WriteLine("PDF generated and performance traced successfully.")
	End Sub
	Private Shared Function GeneratePdf(ByVal htmlContent As String) As PdfDocument
		' Create an instance of the HtmlToPdf renderer
		Dim renderer = New ChromePdfRenderer()
		' Convert HTML to PDF
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		Return pdfDocument
	End Function
End Class

En este ejemplo, empezamos creando una TraceEventSession para capturar datos de rendimiento utilizando Dottrace. A continuación, generamos un PDF a partir de una simple cadena HTML utilizando IronPDF. Después de guardar el PDF, detenemos la sesión de rastreo.

Esto nos permite supervisar el rendimiento del proceso de generación de PDF y obtener información valiosa sobre su ejecución.

Conclusión

Al integrar Dottrace con IronPDF, puede mejorar significativamente el rendimiento y la fiabilidad de sus procesos de generación de PDF. Esta integración proporciona información valiosa sobre el modo en que su aplicación gestiona las tareas de PDF, lo que le ayuda a optimizar las operaciones y a garantizar una experiencia de usuario fluida. IronPDF ofrece un completo conjunto de funciones para trabajar con archivos PDF, lo que lo convierte en una herramienta esencial para cualquier desarrollador .NET.

IronPDF ofrece una versión de prueba gratuita, y las licencias cuestan a partir de 749 dólares, lo que le permite evaluar sus capacidades antes de realizar una compra. La combinación de la potencia de Dottrace e IronPDF puede ayudarle a crear aplicaciones eficientes y de alto rendimiento que satisfagan las necesidades de sus usuarios.