Dottrace .NET Core (Como funciona para desenvolvedores)

Configurando o Dottrace .NET Core em projetos .NET

Primeiro, você precisa instalar o Dottrace .NET Core usando o NuGet. Abra o Visual Studio e siga estes passos:

1. Abra o Visual Studio.
2. Selecione Criar um novo projeto .
3. Escolha Aplicativo de console (.NET Core) e clique em Avançar .
4. Dê o nome de DottraceExample ao seu projeto e clique em Criar .
5. No Solution Explorer , clique com o botão direito do mouse no projeto e selecione Gerenciar Pacotes NuGet .
6. No Gerenciador de Pacotes NuGet , procure por JetBrains.dotTrace.CommandLineTools.
7. Selecione o pacote e clique em Instalar .

Isso instala o Dottrace como uma dependência em seu projeto.

Analisando o desempenho de um aplicativo de console simples

Vamos criar um aplicativo de console básico para realizar o profiling. Substitua o código em Program.cs pelo seguinte:

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 e execute sua aplicação pressionando F5 . Após a aplicação estar em execução, você precisará do ID do processo para realizar a criação de perfis. Você pode encontrar o ID do processo usando a janela Ferramentas de Diagnóstico do Visual Studio ou verificando o Gerenciador de Tarefas .

Para criar um perfil da sua aplicação usando o Dottrace, abra uma janela de terminal ou o Console do Gerenciador de Pacotes no Visual Studio e execute:

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

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

Substitua <your-process-id> pelo ID do processo real do seu aplicativo em execução.

Após a conclusão da sua aplicação, você terá um arquivo trace.nettrace. Este arquivo contém todos os dados de perfil coletados durante a execução da aplicação. Você pode analisar este arquivo no Visual Studio. Siga estes passos:

1. Abra o Visual Studio.
2. Vá para Arquivo > Abrir > Arquivo .
3. Selecione o arquivo trace.nettrace e clique em Abrir .

O Visual Studio exibirá dados de desempenho detalhados, permitindo que você identifique e corrija gargalos de desempenho.

Agora que você configurou o Dottrace e criou um exemplo básico de perfilamento, pode prosseguir para a implementação de recursos mais avançados.

Analisando o uso da CPU

Uma das principais funcionalidades do Dottrace .NET Core é a análise do uso da CPU. Isso ajuda você a identificar quais partes do seu código consomem mais recursos da CPU. Eis como fazer:

Primeiro, inicie sua aplicação no Visual Studio. Em seguida, no terminal ou no Console do Gerenciador de Pacotes , execute:

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

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

Substitua <your-process-id> pelo ID de processo real do seu aplicativo. Após a conclusão da sessão de criação de perfil, abra o arquivo cpu_usage.nettrace no 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 uma operação que exige muito da CPU. Ao analisar o arquivo cpu_usage.nettrace, você verá que o loop consome uma quantidade significativa de tempo de CPU.

Monitoramento da alocação de memória

O Dottrace .NET Core também pode ajudar você a monitorar a alocação de memória em seu aplicativo. Isso é crucial para identificar vazamentos de memória e otimizar o uso da memória.

Execute sua aplicação e colete dados de alocação de memória:

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

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

Após a sessão, abra o arquivo memory_allocation.nettrace no 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 aloca memória em um loop. Analisar o arquivo memory_allocation.nettrace mostrará quanta memória é alocada e onde isso ocorre no seu código.

Criação de perfis de operações de E/S

A criação de perfis de operações de E/S é outro recurso essencial. Isso ajuda você a entender o impacto no desempenho da leitura e da gravação de arquivos.

Inicie sua aplicação e colete dados de entrada/saída:

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 o arquivo io_operations.nettrace no Visual Studio para análise:

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 lê e escreve em um arquivo. A análise do arquivo io_operations.nettrace revelará o tempo gasto em operações de entrada/saída.

Identificando gargalos de desempenho

Identificar gargalos de desempenho é um dos principais objetivos do uso do Dottrace. Ao analisar os arquivos de rastreamento coletados, você pode identificar as partes lentas do seu código.

Inicie sua aplicação e colete dados de desempenho:

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 o arquivo performance_bottlenecks.nettrace no 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 um atraso na aplicação. A análise do arquivo performance_bottlenecks.nettrace mostrará onde o tempo é gasto com mais frequência, ajudando você a otimizar essas partes.

Estes exemplos abrangem os principais recursos do Dottrace .NET Core. Agora você pode analisar o uso da CPU, monitorar a alocação de memória, criar perfis de operações de E/S, identificar gargalos de desempenho e criar perfis em ambientes de produção. Cada recurso ajuda você a otimizar e melhorar seus aplicativos .NET Core.

Introdução ao IronPDF

IronPDF é uma poderosa biblioteca .NET que permite gerar, editar e gerenciar PDFs facilmente em seus aplicativos C#. Seja para criar novos PDFs do zero, converter HTML para PDF ou manipular PDFs existentes, o IronPDF oferece um conjunto completo de recursos para realizar essas tarefas com eficiência. É benéfico para aplicações que exigem geração e processamento de PDFs, como sistemas de relatórios, soluções de gerenciamento de documentos e aplicações web.

Caso de uso da fusão do IronPDF com o Dottrace

Considere um cenário em que você tenha um aplicativo web que gera relatórios em PDF para os usuários. Ao utilizar o Dottrace, você pode monitorar o desempenho do processo de geração de PDFs, identificar problemas de desempenho por meio do arquivo de rastreamento e implementar melhorias para aprimorar a experiência do usuário. Essa integração é particularmente valiosa para aplicações que lidam com grandes volumes de documentos PDF ou que exigem processamento de alto desempenho.

Exemplo de código de caso de uso

Abaixo, segue um exemplo de código completo que demonstra como integrar o IronPDF com o Dottrace. Este exemplo cria uma conversão simples de HTML para PDF e usa o Dottrace para monitorar o desempenho da operação.

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

Neste exemplo, começamos criando um TraceEventSession para capturar dados de desempenho usando o Dottrace. Em seguida, geramos um PDF a partir de uma simples string HTML usando o IronPDF. Após salvar o PDF, encerramos a sessão de rastreamento.

Isso nos permite monitorar o desempenho do processo de geração de PDFs e obter informações valiosas sobre sua execução.