Dottrace .NET Core (Funktionsweise für Entwickler)

Einrichten von Dottrace .NET Core in .NET-Projekten

Zuerst müssen Sie Dottrace .NET Core über NuGet installieren. Öffnen Sie Visual Studio und folgen Sie diesen Schritten:

1. Öffnen Sie Visual Studio.
2. Wählen Sie Neues Projekt erstellen aus.
3. Wählen Sie Konsolenanwendung (.NET Core) und klicken Sie auf Weiter.
4. Benennen Sie Ihr Projekt DottraceExample und klicken Sie auf Erstellen.
5. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf das Projekt und wählen Sie NuGet-Pakete verwalten.
6. Suchen Sie im NuGet-Paket-Manager nach JetBrains.dotTrace.CommandLineTools.
7. Wählen Sie das Paket aus und klicken Sie auf Installieren.

Dies installiert Dottrace als Abhängigkeit in Ihrem Projekt.

Profilierung einer einfachen Konsolenanwendung

Erstellen wir eine grundlegende Konsolenanwendung zum Profilieren. Ersetzen Sie den Code in Program.cs durch den folgenden:

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

Erstellen und führen Sie Ihre Anwendung aus, indem Sie F5 drücken. Sobald die Anwendung läuft, benötigen Sie ihre Prozess-ID zum Profilieren. Sie können die Prozess-ID im Diagnosetools-Fenster von Visual Studio oder durch Überprüfung des Task-Managers finden.

Um Ihre Anwendung mit Dottrace zu profilieren, öffnen Sie ein Terminalfenster oder die Package Manager Console in Visual Studio und führen Sie aus:

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

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

Ersetzen Sie <your-process-id> durch die tatsächliche Prozess-ID Ihrer laufenden Anwendung.

Nachdem Ihre Anwendung beendet ist, haben Sie eine trace.nettrace-Datei. Diese Datei enthält alle während der Ausführung der Anwendung gesammelten Profildaten. Sie können diese Datei in Visual Studio analysieren. Folgen Sie diesen Schritten:

1. Öffnen Sie Visual Studio.
2. Gehen Sie zu Datei > Öffnen > Datei.
3. Wählen Sie die trace.nettrace-Datei aus und klicken Sie auf Öffnen.

Visual Studio zeigt detaillierte Leistungsdaten an, mit denen Sie Performance-Engpässe identifizieren und beheben können.

Da Sie nun Dottrace eingerichtet und ein einfaches Profiling-Beispiel erstellt haben, können Sie sich an die Implementierung fortgeschrittenerer Funktionen machen.

Analyse der CPU-Auslastung

Eine der Hauptfunktionen von Dottrace .NET Core ist die Analyse der CPU-Auslastung. Dies hilft Ihnen dabei, herauszufinden, welche Teile Ihres Codes die meisten CPU-Ressourcen verbrauchen. So geht's:

Starten Sie zuerst Ihre Anwendung in Visual Studio. Führen Sie dann im Terminal oder der Package Manager Console aus:

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

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

Ersetzen Sie <your-process-id> durch die tatsächliche Prozess-ID Ihrer Anwendung. Öffnen Sie nach Abschluss der Profilerstellungssitzung die cpu_usage.nettrace-Datei in 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

Dieser Code simuliert eine CPU-intensive Operation. Wenn Sie die cpu_usage.nettrace-Datei analysieren, werden Sie sehen, dass die Schleife eine erhebliche Menge an CPU-Zeit beansprucht.

Überwachung der Speicherzuweisung

Dottrace .NET Core kann Ihnen auch helfen, die Speicherallokation in Ihrer Anwendung zu überwachen. Dies ist entscheidend, um Speicherlecks zu identifizieren und die Speichernutzung zu optimieren.

Führen Sie Ihre Anwendung aus und sammeln Sie Speicherallokationsdaten:

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

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

Öffnen Sie nach der Sitzung die memory_allocation.nettrace-Datei in 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

Dieser Code allokiert Speicher in einer Schleife. Die Analyse der memory_allocation.nettrace-Datei zeigt, wie viel Speicher allokiert wird und wo es in Ihrem Code geschieht.

Profilierung von E/A-Operationen

Profiling von I/O-Operationen ist eine weitere wichtige Funktion. Es hilft Ihnen, die Leistungsauswirkungen des Lesens und Schreibens von Dateien zu verstehen.

Starten Sie Ihre Anwendung und sammeln Sie I/O-Daten:

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

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

Öffnen Sie die io_operations.nettrace-Datei in Visual Studio zur Analyse:

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

Dieser Code schreibt in eine Datei und liest von ihr. Die Analyse der io_operations.nettrace-Datei wird die für I/O-Operationen aufgewendete Zeit aufzeigen.

Identifizierung von Leistungsengpässen

Die Identifikation von Performance-Engpässen ist eines der Hauptziele der Verwendung von Dottrace. Durch die Analyse der gesammelten Trace-Dateien können Sie die langsamen Teile Ihres Codes genauer bestimmen.

Starten Sie Ihre Anwendung und sammeln Sie Leistungsdaten:

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

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

Öffnen Sie die performance_bottlenecks.nettrace-Datei in 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

Dieser Code simuliert eine Verzögerung in der Anwendung. Die Analyse der performance_bottlenecks.nettrace-Datei zeigt, wo am meisten Zeit verbraucht wird und hilft Ihnen, diese Teile zu optimieren.

Diese Beispiele decken die wesentlichen Funktionen von Dottrace .NET Core ab. Sie können nun die CPU-Auslastung analysieren, die Speicherallokation überwachen, I/O-Operationen profilieren, Leistungsengpässe identifizieren und in Produktionsumgebungen profilieren. Jede Funktion hilft Ihnen, Ihre .NET Core-Anwendungen zu optimieren und zu verbessern.

Einführung in IronPDF

IronPDF ist eine leistungsstarke .NET Bibliothek, die es Ihnen ermöglicht, PDFs einfach in Ihren C#-Anwendungen zu erstellen, zu bearbeiten und zu verwalten. Egal, ob Sie neue PDFs von Grund auf neu erstellen, HTML in PDF konvertieren oder vorhandene PDFs bearbeiten möchten, IronPDF bietet eine Vielzahl von Funktionen, um diese Aufgaben effizient zu erledigen. Es ist vorteilhaft für Anwendungen, die PDF-Erzeugung und -verarbeitung erfordern, wie Berichtssysteme, Dokumentenmanagementlösungen und Webanwendungen.

Benutzungsfall der Zusammenführung von IronPDF mit Dottrace

Betrachten Sie ein Szenario, in dem Sie eine Webanwendung haben, die PDF-Berichte für Benutzer generiert. Durch die Verwendung von Dottrace können Sie die Performance des PDF-Generierungsprozesses verfolgen, Performance-Probleme mit der Trace-Datei identifizieren und Verbesserungen vornehmen, um das Benutzererlebnis zu verbessern. Diese Integration ist besonders wertvoll für Anwendungen, die große Mengen an PDF-Dokumenten verarbeiten oder eine hohe Leistungsfähigkeit erfordern.

Code-Beispiel für Anwendungsfall

Unten finden Sie ein komplettes Codebeispiel, das zeigt, wie Sie IronPDF mit Dottrace integrieren können. Dieses Beispiel erstellt eine einfache HTML-zu-PDF-Konvertierung und verwendet Dottrace, um die Performance des Vorgangs zu überwachen.

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

In diesem Beispiel beginnen wir mit der Erstellung einer TraceEventSession, um Performance-Daten mit Dottrace zu erfassen. Dann erstellen wir ein PDF aus einem einfachen HTML-String mit IronPDF. Nachdem wir das PDF gespeichert haben, beenden wir die Tracing-Sitzung.

Dies ermöglicht es uns, die Performance des PDF-Generierungsprozesses zu überwachen und wertvolle Einblicke in dessen Ausführung zu gewinnen.