Dottrace .NET Core (Cómo Funciona para Desarrolladores)

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

Primero, debe instalar Dottrace .NET Core utilizando NuGet. Abra Visual Studio y siga estos pasos:

1. Abre Visual Studio.
2. Seleccione Crear un nuevo proyecto.
3. Elija Aplicación de Consola (.NET Core) y haga clic en Siguiente.
4. Nombre su proyecto DottraceExample y haga clic en Crear.
5. En Explorador de Soluciones, haga clic derecho en el proyecto y seleccione Administrar Paquetes NuGet.
6. En el Administrador 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.

¡Dottrace .NET Core (Cómo Funciona Para Desarrolladores): Figura 1 - El paquete JetBrains.dotTrace para instalar

Perfilado de una aplicación de consola sencilla

Vamos a crear una aplicación de consola básica para perfilar. Reemplace 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...");
        // Simulating 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...");
        // Simulating 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...")
		' Simulating a time-consuming operation
		Thread.Sleep(5000)
		Console.WriteLine("Application finished.")
	End Sub
End Class

Compile y ejecute su aplicación presionando F5. Una vez que la aplicación esté en ejecución, necesitará su ID de proceso para el perfilado. Puede encontrar el ID de proceso utilizando la ventana de Herramientas de Diagnóstico de Visual Studio o verificando el Administrador de Tareas.

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

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

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

Reemplace <your-process-id> con el ID de proceso real de su aplicación en ejecución.

Después de que su aplicación termine, tendrá un archivo trace.nettrace. Este archivo contiene todos los datos de perfilado recopilados durante la ejecución de la aplicación. Puede analizar este archivo en Visual Studio. Siga 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, permitiéndole identificar y corregir cuellos de botella de rendimiento.

Ahora que ha configurado Dottrace y creado un ejemplo básico de perfilado, puede proceder a implementar características más avanzadas.

Analizar el uso de la CPU

Una de las características clave de Dottrace .NET Core es analizar el uso de CPU. Esto le ayuda a identificar qué partes de su código consumen más recursos de CPU. Así es como se hace:

Primero, inicie su aplicación en Visual Studio. Luego, en el terminal o Consola de Administrador de Paquetes, ejecute:

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

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

Reemplace <your-process-id> con el ID de proceso real de su aplicación. Una vez que se complete 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 en CPU. Cuando analice el archivo cpu_usage.nettrace, verá que el bucle consume una cantidad significativa de tiempo de CPU.

Monitorización de la asignación de memoria

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

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

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

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. Analizar el archivo memory_allocation.nettrace mostrará cuánta memoria se asigna y dónde ocurre en su código.

Perfilado de operaciones de E/S

Perfilar operaciones de I/O es otra característica esencial. Le ayuda a entender el impacto en el rendimiento de leer y escribir en archivos.

Inicie su aplicación y recopile datos de I/O:

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

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

Abra el archivo io_operations.nettrace en Visual Studio para su análisis:

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 en y lee de un archivo. Analizar el archivo io_operations.nettrace revelará el tiempo dedicado a las operaciones de I/O.

Identificación de cuellos de botella en el rendimiento

Identificar cuellos de botella de rendimiento es uno de los principales propósitos de usar Dottrace. Al analizar los archivos de traza recopilados, puede identificar 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

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. Analizar el archivo performance_bottlenecks.nettrace mostrará dónde se gasta más tiempo, ayudándole a optimizar esas partes.

Estos ejemplos cubren características clave de Dottrace .NET Core. Ahora puede analizar el uso de CPU, monitorear la asignación de memoria, perfilar operaciones de I/O, identificar cuellos de botella de rendimiento y perfilar en entornos de producción. Cada característica le ayuda a optimizar y mejorar sus aplicaciones .NET Core.

Introducción a IronPDF

¡Dottrace .NET Core (Cómo Funciona Para Desarrolladores): Figura 2 - Página de IronPDF

IronPDF es una poderosa biblioteca .NET que le permite generar, editar y gestionar PDFs fácilmente dentro de sus aplicaciones C#. Ya sea que necesite crear nuevos PDFs desde cero, convertir HTML a PDF o manipular PDFs existentes, IronPDF proporciona un conjunto rico de características para realizar estas tareas eficientemente. Es beneficioso para aplicaciones que requieren generación y procesamiento de PDFs, como sistemas de informes, soluciones de gestión de documentos y aplicaciones web.

Caso de uso de la fusión de IronPDF con Dottrace

Considere un escenario en el que tenga una aplicación web que genera informes PDF para los usuarios. Al usar Dottrace, puede seguir el rendimiento del proceso de generación de PDF, identificar problemas de rendimiento usando el archivo de traza, y hacer mejoras para mejorar la experiencia del usuario. Esta integración es particularmente valiosa para aplicaciones que manejan grandes volúmenes de documentos PDF o requieren procesamiento de alto rendimiento.

Ejemplo de código del caso de uso

A continuación se presenta un ejemplo de código completo que demuestra cómo integrar IronPDF con Dottrace. Este ejemplo crea una conversión sencilla de HTML a PDF y utiliza Dottrace para monitorear 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

¡Dottrace .NET Core (Cómo Funciona Para Desarrolladores): Figura 3 - Salida de consola del ejemplo de código anterior

En este ejemplo, comenzamos creando un TraceEventSession para capturar datos de rendimiento usando Dottrace. Luego generamos un PDF desde una cadena HTML simple usando IronPDF. Después de guardar el PDF, detenemos la sesión de trazado.

¡Dottrace .NET Core (Cómo Funciona Para Desarrolladores): Figura 4 - PDF generado desde el ejemplo de código anterior

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