Was ist OpenTelemetry und wie verbessert es .NET-Anwendungen?

OpenTelemetry ist ein anbieterneutrales Observability-Framework, das für Cloud-native Anwendungen entwickelt wurde. Es verbessert .NET-Anwendungen, indem es standardisierte APIs und SDKs zum Erfassen von Logs, Traces und Metriken bereitstellt, die bei der Fehlerdiagnose, der Identifizierung von Leistungsengpässen und dem umfassenden Verständnis des Anwendungsverhaltens helfen.

Wie kann OpenTelemetry mit ASP.NET Core für automatische Instrumentierung integriert werden?

OpenTelemetry kann mit ASP.NET Core integriert werden, indem Dienste und Middleware in der Datei `Startup.cs` konfiguriert werden, um eine automatische Instrumentierung zu ermöglichen. Dazu gehört das Einrichten von Tracing und Exportern wie Jaeger, um Telemetriedaten zu übertragen und die Anwendungsleistung zu überwachen.

Welche Rolle spielt IronPDF bei der PDF-Erstellung for .NET-Anwendungen?

IronPDF ist eine .NET-Bibliothek, die die Erstellung und Bearbeitung von PDFs in .NET-Anwendungen vereinfacht. Sie unterstützt die Umwandlung von HTML in PDF, das Extrahieren von Texten aus PDFs und das Hinzufügen von Funktionen wie Wasserzeichen und Verschlüsselung, was sie zu einem vielseitigen Werkzeug für den Umgang mit PDF-Dokumenten macht.

Wie können Entwickler PDF-Erstellungsprozesse mit OpenTelemetry nachverfolgen und analysieren?

Entwickler können PDF-Erstellungsprozesse nachverfolgen und analysieren, indem sie OpenTelemetry.NET mit IronPDF integrieren. Diese Integration ermöglicht es, Telemetriedaten zu sammeln und zu analysieren, um Einblicke in die PDF-Erstellungsworkflows zu gewinnen und die Anwendungsleistung zu optimieren.

Welche Vorteile bietet die Verwendung von OpenTelemetry mit IronPDF in .NET-Anwendungen?

Die Verwendung von OpenTelemetry mit IronPDF in .NET-Anwendungen bietet mehrere Vorteile, einschließlich verbesserter Anwendungs-Skalierbarkeit, verbesserter Leistungsanalyse und optimierter PDF-Erstellungsworkflows. Diese Kombination ermöglicht es Entwicklern, die Gesundheit ihrer Anwendungen effektiv zu überwachen und zu verbessern.

Wie können Entwickler in einer ASP.NET Core-Anwendung ein PDF mit IronPDF erstellen?

In einer ASP.NET Core-Anwendung können Entwickler ein PDF erstellen, indem sie die `HtmlToPdf`-Klasse in einen Controller injizieren, HTML-Inhalt als PDF rendern und dann das erstellte PDF als Datei für den Download zurückgeben.

Welche Exporter werden von OpenTelemetry für Backend-Systeme unterstützt?

OpenTelemetry unterstützt eine Vielzahl von Exportern für Backend-Systeme, einschließlich Jaeger für Tracing, Prometheus für Metriken und Zipkin für Tracing. Diese Exporter ermöglichen die Speicherung und Analyse von Telemetriedaten über verschiedene Systeme hinweg.

What role do exporters play in OpenTelemetry?

Exporters in OpenTelemetry are responsible for transferring collected telemetry data to backend systems. They enable developers to store and analyze telemetry data using familiar tools like Jaeger for tracing, Prometheus for metrics, and Zipkin for tracing.

How does IronPDF simplify PDF creation for developers?

IronPDF simplifies PDF creation with its easy-to-use API that supports converting HTML to PDF, adding content to existing PDFs, and manipulating PDF documents. It enables developers to produce high-quality PDFs quickly and efficiently within their .NET applications.

Is it possible to manually instrument .NET applications with OpenTelemetry?

Yes, OpenTelemetry provides a robust API for manual instrumentation, allowing developers to capture specific metrics and traces related to unique application logic. This method offers granular control when automatic instrumentation does not cover all needs.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

Einführung

Jacob Mellor

Updated: 18. Januar 2026

Die Erstellung dynamischer, datengesteuerter und reichhaltiger PDF-Dokumente ist eine typische Anforderung in vielen Bereichen der modernen Softwareentwicklung. Unternehmen sind stark auf ihre Fähigkeit angewiesen, schnell hochwertige PDFs zu erstellen, sei es zur Erstellung von Rechnungen, Berichten oder Dokumentationen. Jedoch wird es unerlässlich, die Effektivität der PDF-Produktionsprozesse zu verfolgen und zu verstehen, um die Gesundheit der Anwendungen zu bewahren und die Benutzerzufriedenheit zu gewährleisten, wenn sie komplexer und umfangreicher werden.

Dieser Artikel zielt darauf ab, zu erörtern, wie Entwickler die PDF-Erzeugung verbessern und wertvolle Einblicke in die Anwendungsleistung gewinnen können, indem sie die Funktionen von IronPDF und OpenTelemetry.NET nutzen. Wir werden die Merkmale und Vorteile beider Technologien erforschen und zeigen, wie sie harmonisch zusammenarbeiten können, um die Erstellung und Überwachung von PDFs in .NET-Anwendungen zu optimieren.

Was ist OpenTelemetry?

OpenTelemetry ist ein anbieterneutrales Beobachtungs-Framework, das speziell für Cloud-native Apps entwickelt wurde. Die automatische Instrumentierung von OpenTelemetry bietet eine einzige API für die Erfassung von Telemetriedaten, einschließlich Protokollen, Tracing und Metriken. Mit Hilfe dieser umfangreichen Daten können Entwickler Probleme effektiv debuggen, Leistungsengpässe identifizieren und ein vollständiges Verständnis des Programmverhaltens erlangen. OpenTelemetry unterstützt sowohl automatische als auch manuelle Instrumentierung für eine umfassende und flexible Sammlung von Telemetriedaten.

Schlüsselkomponenten von OpenTelemetry

API: OpenTelemetry definiert einen standardisierten Satz von APIs zur Instrumentierung von Anwendungen und zur Generierung von Telemetriedaten. Dies vereinfacht die Instrumentierung und gewährleistet Konsistenz über verschiedene Programmiersprachen hinweg.
SDKs: Für die Instrumentierung von Anwendungen bietet OpenTelemetry SDKs an, die auf bestimmte Programmiersprachen zugeschnitten sind. Entwickler können die Funktionalität von OpenTelemetry mit Hilfe des .NET SDKs problemlos in ihre .NET-Projekte integrieren.
Exporter: Diese Teile sind für die Übermittlung der gesammelten Telemetriedaten an Backend-Systeme zuständig, damit diese gespeichert und analysiert werden können. Viele Exporter von weit verbreiteten Backend-Systemen, wie Zipkin (Tracing), Prometheus (Metriken) und Jaeger (Tracing), werden von OpenTelemetry unterstützt.
Automatische Instrumentierung: Diese Methode vereinfacht den Prozess for .NET Core Anwendungen. OpenTelemetry-Bibliotheken können automatisch Daten für häufige Vorgänge innerhalb Ihrer Webanwendung oder Ihres Dienstes erfassen. Dies beseitigt manuelle Codeänderungen und rationalisiert den Integrationsprozess.
Manuelle Instrumentierung: Für eine detaillierte Kontrolle der Datenerfassung bietet OpenTelemetry eine robuste API für die manuelle Instrumentierung. Mit diesem Ansatz können Sie spezifische Metriken und Traces erfassen, die mit Ihrer einzigartigen Anwendungslogik zusammenhängen. Es ist besonders nützlich für .NET Framework-Anwendungen oder Szenarien, in denen automatische Instrumentierung Ihre spezifischen Bedürfnisse nicht abdeckt.

Vorteile der Verwendung von OpenTelemetry in .NET

Die Integration von OpenTelemetry in Ihre .NET-Anwendungen bietet mehrere Vorteile:

Herstellerneutralität: OpenTelemetry bietet Flexibilität und macht Ihre Anwendung zukunftssicher, indem es sich mühelos in eine Vielzahl von Backend-Systemen integrieren lässt. Ihr Instrumentierungscode muss nicht geändert werden, um das Backend-System zu wechseln.
Standardisierter Ansatz: Die einheitliche API erleichtert die Instrumentierung verschiedener Bereiche Ihrer Anwendung. Entwickler können dieselbe API verwenden, um Protokolle, Traces und Metriken zu sammeln, was zu einem leichter lesbaren und wartbaren Code führt.
Detaillierte Leistungsanalyse: OpenTelemetry bietet eine Fülle von Daten (Metriken, Traces und Protokolle) für eine umfassende Leistungsanalyse. Sie können Bereiche zur Optimierung lokalisieren und die grundlegende Ursache von Problemen mit dieser umfassenden Perspektive feststellen.
Bessere Fehlersuche: Entwickler können Probleme leichter erkennen und beheben, indem sie den Weg der Anfragen durch ihre Anwendung mithilfe der umfangreichen Tracing-Daten, die OpenTelemetry erfasst, verfolgen.
Verbesserte Skalierbarkeit: Die Komplexität Ihrer Anwendung beeinträchtigt nicht die Skalierbarkeit von OpenTelemetry. Neue Funktionen oder Dienste können problemlos instrumentiert werden, ohne dass umfangreiche Codeänderungen erforderlich sind.

Erstellen und Konfigurieren von OpenTelemetry

OpenTelemetry in der ASP.NET-Anwendung konfigurieren

OpenTelemetry muss in Ihrer Anwendung konfiguriert werden; Für ASP.NET Core-Anwendungen wird dies normalerweise in der ConfigureServices-Methode Ihrer Startup.cs-Datei durchgeführt. Dies ist eine Illustration einer Jaeger-Exporter-Konfiguration:

using OpenTelemetry.Trace;
using OpenTelemetry.Exporter.Jaeger;
using OpenTelemetry.Resources;

public void ConfigureServices(IServiceCollection services)
{
    // Configure OpenTelemetry
    services.AddOpenTelemetry().WithTracing(builder =>
    {
        // Configure Jaeger exporter. The 'serviceName' can be read from environment variables
        builder
            .SetResourceBuilder(
                ResourceBuilder.CreateDefault()
                    .AddService("YourServiceName"))
            .AddAspNetCoreInstrumentation()
            .AddJaegerExporter(opt =>
            {
                opt.AgentHost = "localhost"; // Jaeger agent host
                opt.AgentPort = 14250; // Jaeger agent port
            });
    });
    // Other service configurations...
}

using OpenTelemetry.Trace;
using OpenTelemetry.Exporter.Jaeger;
using OpenTelemetry.Resources;

public void ConfigureServices(IServiceCollection services)
{
    // Configure OpenTelemetry
    services.AddOpenTelemetry().WithTracing(builder =>
    {
        // Configure Jaeger exporter. The 'serviceName' can be read from environment variables
        builder
            .SetResourceBuilder(
                ResourceBuilder.CreateDefault()
                    .AddService("YourServiceName"))
            .AddAspNetCoreInstrumentation()
            .AddJaegerExporter(opt =>
            {
                opt.AgentHost = "localhost"; // Jaeger agent host
                opt.AgentPort = 14250; // Jaeger agent port
            });
    });
    // Other service configurations...
}

Imports OpenTelemetry.Trace
Imports OpenTelemetry.Exporter.Jaeger
Imports OpenTelemetry.Resources

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure OpenTelemetry
	services.AddOpenTelemetry().WithTracing(Sub(builder)
		' Configure Jaeger exporter. The 'serviceName' can be read from environment variables
		builder.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("YourServiceName")).AddAspNetCoreInstrumentation().AddJaegerExporter(Sub(opt)
				opt.AgentHost = "localhost" ' Jaeger agent host
				opt.AgentPort = 14250 ' Jaeger agent port
		End Sub)
	End Sub)
	' Other service configurations...
End Sub

Imports OpenTelemetry.Trace
Imports OpenTelemetry.Exporter.Jaeger
Imports OpenTelemetry.Resources

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure OpenTelemetry
	services.AddOpenTelemetry().WithTracing(Sub(builder)
		' Configure Jaeger exporter. The 'serviceName' can be read from environment variables
		builder.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("YourServiceName")).AddAspNetCoreInstrumentation().AddJaegerExporter(Sub(opt)
				opt.AgentHost = "localhost" ' Jaeger agent host
				opt.AgentPort = 14250 ' Jaeger agent port
		End Sub)
	End Sub)
	' Other service configurations...
End Sub

Ersetzen Sie "YourServiceName" durch den tatsächlichen Namen Ihres Dienstes. Passen Sie den Jaeger-Agenten-Host und -Port entsprechend Ihrer Jaeger-Konfigurationsoptionen an.

OpenTelemetry Middleware hinzufügen

Sie müssen die OpenTelemetry-Middleware in ASP.NET Core-Anwendungen einbinden, um eine automatische Instrumentierung von eingehenden HTTP-Anfragen zu erhalten. Fügen Sie in der Configure-Methode Ihrer Startup.cs-Datei die Middleware hinzu:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Add Prometheus metrics middleware if using Prometheus
    app.UseHttpMetrics();
    // Other middleware configurations...
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Add Prometheus metrics middleware if using Prometheus
    app.UseHttpMetrics();
    // Other middleware configurations...
}

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	' Add Prometheus metrics middleware if using Prometheus
	app.UseHttpMetrics()
	' Other middleware configurations...
End Sub

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	' Add Prometheus metrics middleware if using Prometheus
	app.UseHttpMetrics()
	' Other middleware configurations...
End Sub

Starten Sie die Spurensuche.

Nach der Einrichtung beginnt OpenTelemetry automatisch, eingehende HTTP-Anfragen zu verfolgen und Telemetriedaten an das konfigurierte Jaeger-Backend zu senden.

Überprüfen und Überwachen

Sie können in Ihrem Jaeger-Backend nach Traces suchen, um zu bestätigen, dass OpenTelemetry ordnungsgemäß funktioniert. Öffnen Sie die Jaeger-Benutzeroberfläche (normalerweise verfügbar unter http://localhost:16686 für die Jaeger-UI) und suchen Sie nach Traces, die mit Ihrem Dienst verbunden sind.

Wählen Sie ein Backend-System (optional)

OpenTelemetry ist für grundlegende Instrumentierung nicht zwingend erforderlich, integriert sich jedoch in andere Backend-Betriebssysteme, um Telemetriedaten zu speichern und zu verarbeiten. Beliebte Optionen bestehen aus den offiziell unterstützten Betriebssystemen:

Jaeger (Tracing)
Prometheus (Metriken)
Zipkin (Tracing)

Einstieg

Was ist IronPDF?

Das beliebte .NET-Paket IronPDF ermöglicht es, PDF-Dokumente innerhalb von .NET-Programmen zu erstellen, zu bearbeiten und anzuzeigen. Die Funktionen zum Arbeiten mit PDFs sind zahlreich und umfassen das Konvertieren von HTML-Seiten in PDFs, das Extrahieren von Text und Bildern aus PDFs, das Hinzufügen von Text, Bildern und Formen zu vorhandenen PDF-Dokumenten und das Erzeugen von PDFs aus HTML-Inhalten, Fotos oder Rohdaten.

Zwei der Hauptvorteile von IronPDF sind seine Benutzerfreundlichkeit und Einfachheit. Entwickler können dank der intuitiven API und der umfassenden Dokumentation problemlos mit der Erstellung von PDFs innerhalb ihrer .NET-Projekte beginnen. Die Effizienz und Geschwindigkeit von IronPDF sind weitere Eigenschaften, die Entwicklern helfen, schnell und effizient hochwertige PDF-Dokumente zu erstellen.

Einige der Vorteile von IronPDF:

Erzeugung von PDFs aus HTML, Bildern und Rohdaten
Extrahieren von Text und Bildern aus PDF-Dateien
Einfügen von Wasserzeichen, Kopf- und Fußzeilen in PDF-Dateien PDF-Dateien sind durch Verschlüsselung und ein Passwort geschützt.
Die Möglichkeit, Formulare elektronisch zu signieren und auszufüllen

Installieren Sie das NuGet-Paket

Mehrere NuGet-Pakete sind für verschiedene Komponenten von OpenTelemetry verfügbar. Je nach Bedarf können Sie die erforderlichen Pakete installieren. Um Telemetriedaten an ein Beobachtungs-Backend (wie Jaeger, Zipkin oder Prometheus) zu senden, benötigen Sie zumindest das OpenTelemetry-Paket, Instrumentierungspakete für Ihr Anwendungs-Framework (wie ASP.NET Core) und ein Exporterpaket. Stellen Sie außerdem sicher, dass das IronPDF-Paket in Ihrem Projekt installiert ist. Um es zu installieren, verwenden Sie die NuGet-Package-Manager-Konsole:

Install-Package OpenTelemetry
Install-Package OpenTelemetry.Instrumentation.AspNetCore
Install-Package OpenTelemetry.Exporter.Jaeger
Install-Package IronPdf

Install-Package OpenTelemetry
Install-Package OpenTelemetry.Instrumentation.AspNetCore
Install-Package OpenTelemetry.Exporter.Jaeger
Install-Package IronPdf

PowerShell

Verwendung von OpenTelemetry mit IronPDF

Öffnen Sie die Startup.cs-Datei Ihrer ASP.NET Core-Anwendung, um auf die ConfigureServices-Methode zuzugreifen. Um IronPDF einzurichten, fügen Sie den folgenden Code hinzu.

using IronPdf;

public void ConfigureServices(IServiceCollection services)
{
    // Configure IronPDF
    services.AddSingleton<HtmlToPdf>();
    // Other service configurations...
}

using IronPdf;

public void ConfigureServices(IServiceCollection services)
{
    // Configure IronPDF
    services.AddSingleton<HtmlToPdf>();
    // Other service configurations...
}

Imports IronPdf

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure IronPDF
	services.AddSingleton(Of HtmlToPdf)()
	' Other service configurations...
End Sub

Imports IronPdf

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	' Configure IronPDF
	services.AddSingleton(Of HtmlToPdf)()
	' Other service configurations...
End Sub

Dieser Code stellt sicher, dass eine Instanz von HtmlToPdf erstellt und von der Anwendung verwendet wird, indem der HtmlToPdf-Dienst von IronPDF als Singleton konfiguriert wird.

Sie können die PDF-Erzeugungsprozesse in Ihren .NET-Anwendungen verfolgen und beobachten, indem Sie OpenTelemetry.NET mit IronPDF integrieren. Lassen Sie uns das Codebeispiel im Detail untersuchen, indem wir jeden Schritt einzeln durchgehen:

using Microsoft.AspNetCore.Mvc;
using OpenTelemetry.Trace;
using System.Diagnostics;
using Microsoft.Extensions.Logging;
using IronPdf;

namespace DemoWebApplication.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class DemoController : ControllerBase
    {
        private readonly HtmlToPdf _htmlToPdf;
        private readonly ILogger<DemoController> _logger;
        private readonly Tracer _tracer;

        public DemoController(ILogger<DemoController> logger, HtmlToPdf htmlToPdf, TracerProvider tracerProvider)
        {
            _tracer = tracerProvider.GetTracer("Demo");
            _htmlToPdf = htmlToPdf;
            _logger = logger;
        }

        [HttpGet]
        public FileContentResult Generate()
        {
            // Define the PDF file name
            string fileName = "Sample.pdf";

            // Generate PDF from HTML content
            _logger.LogInformation("Generating PDF...");
            var pdfBytes = GeneratePdf("Hello, IronPDF!");

            // Return the PDF as a file result
            return new FileContentResult(pdfBytes, "application/pdf")
            {
                FileDownloadName = fileName
            };
        }

        private byte[] GeneratePdf(string htmlContent)
        {
            // Start a tracing activity for PDF generation
            using (var activity = _tracer.StartActiveSpan("PDF Generation"))
            {
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);

                // Log PDF generation
                _logger.LogInformation("PDF generated successfully.");

                return pdfDocument.BinaryData;
            }
        }
    }
}

using Microsoft.AspNetCore.Mvc;
using OpenTelemetry.Trace;
using System.Diagnostics;
using Microsoft.Extensions.Logging;
using IronPdf;

namespace DemoWebApplication.Controllers
{
    [ApiController]
    [Route("[controller]")]
    public class DemoController : ControllerBase
    {
        private readonly HtmlToPdf _htmlToPdf;
        private readonly ILogger<DemoController> _logger;
        private readonly Tracer _tracer;

        public DemoController(ILogger<DemoController> logger, HtmlToPdf htmlToPdf, TracerProvider tracerProvider)
        {
            _tracer = tracerProvider.GetTracer("Demo");
            _htmlToPdf = htmlToPdf;
            _logger = logger;
        }

        [HttpGet]
        public FileContentResult Generate()
        {
            // Define the PDF file name
            string fileName = "Sample.pdf";

            // Generate PDF from HTML content
            _logger.LogInformation("Generating PDF...");
            var pdfBytes = GeneratePdf("Hello, IronPDF!");

            // Return the PDF as a file result
            return new FileContentResult(pdfBytes, "application/pdf")
            {
                FileDownloadName = fileName
            };
        }

        private byte[] GeneratePdf(string htmlContent)
        {
            // Start a tracing activity for PDF generation
            using (var activity = _tracer.StartActiveSpan("PDF Generation"))
            {
                var pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent);

                // Log PDF generation
                _logger.LogInformation("PDF generated successfully.");

                return pdfDocument.BinaryData;
            }
        }
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports OpenTelemetry.Trace
Imports System.Diagnostics
Imports Microsoft.Extensions.Logging
Imports IronPdf

Namespace DemoWebApplication.Controllers
	<ApiController>
	<Route("[controller]")>
	Public Class DemoController
		Inherits ControllerBase

		Private ReadOnly _htmlToPdf As HtmlToPdf
		Private ReadOnly _logger As ILogger(Of DemoController)
		Private ReadOnly _tracer As Tracer

		Public Sub New(ByVal logger As ILogger(Of DemoController), ByVal htmlToPdf As HtmlToPdf, ByVal tracerProvider As TracerProvider)
			_tracer = tracerProvider.GetTracer("Demo")
			_htmlToPdf = htmlToPdf
			_logger = logger
		End Sub

		<HttpGet>
		Public Function Generate() As FileContentResult
			' Define the PDF file name
			Dim fileName As String = "Sample.pdf"

			' Generate PDF from HTML content
			_logger.LogInformation("Generating PDF...")
			Dim pdfBytes = GeneratePdf("Hello, IronPDF!")

			' Return the PDF as a file result
			Return New FileContentResult(pdfBytes, "application/pdf") With {.FileDownloadName = fileName}
		End Function

		Private Function GeneratePdf(ByVal htmlContent As String) As Byte()
			' Start a tracing activity for PDF generation
			Using activity = _tracer.StartActiveSpan("PDF Generation")
				Dim pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent)

				' Log PDF generation
				_logger.LogInformation("PDF generated successfully.")

				Return pdfDocument.BinaryData
			End Using
		End Function
	End Class
End Namespace

Imports Microsoft.AspNetCore.Mvc
Imports OpenTelemetry.Trace
Imports System.Diagnostics
Imports Microsoft.Extensions.Logging
Imports IronPdf

Namespace DemoWebApplication.Controllers
	<ApiController>
	<Route("[controller]")>
	Public Class DemoController
		Inherits ControllerBase

		Private ReadOnly _htmlToPdf As HtmlToPdf
		Private ReadOnly _logger As ILogger(Of DemoController)
		Private ReadOnly _tracer As Tracer

		Public Sub New(ByVal logger As ILogger(Of DemoController), ByVal htmlToPdf As HtmlToPdf, ByVal tracerProvider As TracerProvider)
			_tracer = tracerProvider.GetTracer("Demo")
			_htmlToPdf = htmlToPdf
			_logger = logger
		End Sub

		<HttpGet>
		Public Function Generate() As FileContentResult
			' Define the PDF file name
			Dim fileName As String = "Sample.pdf"

			' Generate PDF from HTML content
			_logger.LogInformation("Generating PDF...")
			Dim pdfBytes = GeneratePdf("Hello, IronPDF!")

			' Return the PDF as a file result
			Return New FileContentResult(pdfBytes, "application/pdf") With {.FileDownloadName = fileName}
		End Function

		Private Function GeneratePdf(ByVal htmlContent As String) As Byte()
			' Start a tracing activity for PDF generation
			Using activity = _tracer.StartActiveSpan("PDF Generation")
				Dim pdfDocument = _htmlToPdf.RenderHtmlAsPdf(htmlContent)

				' Log PDF generation
				_logger.LogInformation("PDF generated successfully.")

				Return pdfDocument.BinaryData
			End Using
		End Function
	End Class
End Namespace

In diesem Beispiel:

Wir injizieren die HtmlToPdf, ILogger und TracerProvider in die DemoController.
Die Generate-Methode startet einen Dateidownload und gibt ein dynamisch erstelltes PDF mit dem Inhalt "Hello, IronPDF!" zurück.
Die GeneratePdf-Methode verwendet die HtmlToPdf.RenderHtmlAsPdf, um das PDF zu rendern und gibt die Binärdaten des PDFs aus.
Der Code verwendet OpenTelemetry, um den PDF-Erstellungsprozess zu verfolgen und die Tracedaten zu protokollieren.

Erzeugte PDF-Ausgabe aus dem obigen Quellcode:

OpenTelemetry .NET (Wie es für Entwickler funktioniert): Abbildung 1 - Generierte Ausgabe aus dem obigen Code, der IronPDF und OpenTelemetry nutzt

Unten ist der Bildschirm des erzeugten Traces aus der Jaeger UI:

OpenTelemetry .NET (Wie es für Entwickler funktioniert): Abbildung 2 - Generierte Ausgabe aus der Jaeger UI

Abschluss

OpenTelemetry ist ein Game-Changer für die Optimierung der Leistung und das Gesundheitsmonitoring von .NET-Anwendungen. Es bietet Entwicklern ein umfassendes Verständnis der inneren Abläufe ihrer Anwendungen, indem es einen anbieterneutralen und standardisierten Ansatz zur Erfassung, Analyse und Export von Telemetriedaten (Metriken, Traces und Protokolle) anbietet.

Durch die Integration von OpenTelemetry.NET mit IronPDF können Entwickler Workflows zur Erstellung von PDFs verbessern und Einblicke in die Leistung ihrer Anwendungen gewinnen. Indem sie die Implementierung von OpenTelemetry.NET nutzen, um die PDF-Erzeugungsprozesse manuell zu instrumentieren, können Entwickler Ausführungspfade verfolgen, Leistungskennzahlen überwachen und Bereiche lokalisieren, die Optimierungen erfordern. Darüber hinaus ermöglicht die zentrale Erfassung und Analyse von Überwachungsmesswerten, Telemetriedaten an Beobachtungsplattformen zu exportieren, wodurch Entwickler die Gesundheit ihrer Anwendungen bewahren und eine einwandfreie Benutzererfahrung bieten können.

Die Integration von OpenTelemetry.NET-Implementierung und IronPDF kann die Workflows von Entwicklern zur Erstellung von PDFs verbessern und Skalierbarkeit, Leistung und Zuverlässigkeit in .NET-Anwendungen gewährleisten. Die Integration dieser Technologien unterstützt Entwickler dabei, die Anforderungen der modernen Softwareentwicklung zu erfüllen und herausragende Ergebnisse zu erzielen, sei es bei der Erstellung von Rechnungen, Berichten oder Dokumentationen.

Beim Kauf eines Pakets ist IronPDF zu einem fairen Preis erhältlich und enthält eine lebenslange Lizenz. Das Paket bietet großartigen Wert zu einem einmaligen Preis von nur $999 für viele Systeme. Es bietet Lizenzinhabern rund um die Uhr Online-Ingenieurssupport. Bitte besuchen Sie die Iron Software-Website für weitere Informationen über die Gebühren. Entdecken Sie Iron Software's Produkte, um mehr über die von ihnen angebotenen Lösungen zu erfahren.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...