Zwei wichtige .NET-Bibliotheken, die die Webentwicklung und Dokumentenmanagement-Fähigkeiten erheblich verbessern, sind FiddlerCore und IronPDF. Mit FiddlerCore können Entwickler HTTP/HTTPS-Datenverkehrserfassung und Inspektionsfunktionen in ihre Anwendungen integrieren. Dieses Open-Source-Tool stammt aus dem bekannten Fiddler Web-Debugging-System-Proxy. Es bietet umfassende Kontrolle über den Netzwerkverkehr, um bei der Fehlersuche, beim Testen und der Optimierung von Online-Interaktionen zu helfen.

Im Gegensatz dazu ist IronPDF eine flexible PDF-Manipulationssoftwarebibliothek zum Erstellen, Ändern und Organisieren von PDF-Dateien. Es erleichtert das Erstellen hochwertiger PDFs aus HTML-, ASPX- und Bilddateien. IronPDF vereinfacht die komplexe PDF-Manipulation mit Funktionen wie dem Trennen, Zusammenführen und Hinzufügen von Anmerkungen.

Durch die Integration von FiddlerCore mit IronPDF können Entwickler Apps entwerfen, die umfangreiche PDF-Berichte erstellen, zusätzlich zur Überwachung und Analyse des Webverkehrs. Zusammen bieten sie ein starkes Dokumentenmanagementsystem und eine leistungsfähige Online-Debugging-Lösung, die den Entwicklungsworkflow insgesamt verbessert.

Was ist FiddlerCore?

FiddlerCore ist ein leistungsstarkes .NET-Paket basierend auf dem beliebten Web-Debugging-Proxy Fiddler. Es ermöglicht Entwicklern, die robusten HTTP/HTTPS-Verkehrserfassungs- und Inspektionsfunktionen von Fiddler in ihre Apps zu integrieren. Wie bei der Fiddler-Benutzeroberfläche können wir auch HTTP-Anfragen modifizieren. Diese Bibliothek ist eine wichtige Ressource für die Fehlersuche, das Testen und die Verbesserung von Webinteraktionen, da sie eine umfassende Überwachung, Protokollierung und Änderung des Webverkehrs ermöglicht.

FiddlerCore gibt Entwicklern die volle Kontrolle über den Netzwerkverkehr und ermöglicht es ihnen, Anfragen und Antworten abzufangen, zu dekodieren und zu ändern. Dadurch können Probleme mit Online-Apps, wie Leistungseinbrüche und Sicherheitslücken, einfacher gefunden und behoben werden. Die API von FiddlerCore ermöglicht tiefe Integrationsmöglichkeiten und ermöglicht personalisierte Prozesse und automatisierte Operationen.

Im Allgemeinen verbessert FiddlerCore den Entwicklungsprozess, indem es eine interaktive und umfassende Ansicht des Webverkehrs bietet – ein notwendiges Werkzeug für den Aufbau zuverlässiger und effektiver Webanwendungen.

Funktionen von FiddlerCore

FiddlerCore bietet einen umfangreichen Funktionssatz zur Verbesserung der Optimierung, Fehlersuche und Überwachung des Online-Verkehrs. Zu den herausragenden Merkmalen gehören:

Umfassende HTTP/HTTPS-Traffic-Erfassung

Mit FiddlerCore kann der Webverkehr gründlich eingesehen werden, da sowohl HTTP- als auch HTTPS-Datenverkehr abgefangen, protokolliert und entschlüsselt werden können.

Detaillierte Verkehrsprüfung

Zur Unterstützung der Problemidentifikation und -lösung können Entwickler die Anfragen- und Antwortdaten, einschließlich Headers, Cookies und Payloads, untersuchen und analysieren.

Dynamische Manipulation des Datenverkehrs

Mit FiddlerCore können Sie Anfragen und Antworten schnell ändern, um verschiedene Netzwerkszenarien und Antworten zu simulieren und effizient Anwendungen zu testen und zu debuggen.

Fortgeschrittene Skripterstellung und Automatisierung

Die robusten Skriptfunktionen von FiddlerCore ermöglichen es Benutzern, Prozesse zu automatisieren und komplexe Workflows und Regeln zur Verkehrsmanipulation zu erstellen, um Output und Effizienz zu steigern.

Leistungsprüfung

Durch die Bewertung des Webverkehrs, das Berechnen von Durchsatz- und Antwortladezeiten und das Identifizieren von Leistungsengpässen hilft die Bibliothek bei der Optimierung der Anwendungsleistung.

Robuste Sicherheitstests

FiddlerCore ist notwendig für Sicherheitsbewertungen, da es die Entschlüsselung und Analyse geschützter Kommunikationsmittel ermöglicht, um Schwachstellen zu testen und die Anwendungssicherheit zu verbessern.

Sitzungsspeicherung und -wiedergabe

Durch das Speichern und Wiedergeben erfasster Verkehrssitzungen kann die Fehlersuche effektiver durchgeführt werden, indem eine vollständige Untersuchung und Replikation von Fehlern ermöglicht wird.

Effiziente Filterung und Suche

Entwickler können schnell relevante Verkehrssitzungen finden, indem sie die Filter- und Suchfunktionen von FiddlerCore nutzen, die sich auf bestimmte Muster oder Typen für eine gezielte Untersuchung konzentrieren.

Plattformübergreifende Unterstützung

FiddlerCore sorgt für eine reibungslose Integration in eine Vielzahl von Entwicklungsumgebungen, indem es mit mehreren .NET-Umgebungen wie .NET Framework, .NET Core und .NET 5+ kompatibel ist.

Erstellen und Konfigurieren von FiddlerCore

Diese Schritte müssen befolgt werden, um FiddlerCore in einer .NET-Anwendung zu erstellen und einzurichten:

Setzen Sie Ihr Projekt auf

Stellen Sie sicher, dass Ihr .NET-Projekt zunächst vorbereitet ist. Sie können mit der .NET CLI oder Visual Studio ein neues erstellen.

dotnet new console -n FiddlerCoreExample
cd FiddlerCoreExample

dotnet new console -n FiddlerCoreExample
cd FiddlerCoreExample

FiddlerCore installieren

Die Installation des FiddlerCore NuGet-Pakets ist erforderlich. Verwenden Sie die .NET CLI oder den NuGet Package Manager, um es zu Ihrem Projekt hinzuzufügen.

dotnet add package FiddlerCore

dotnet add package FiddlerCore

Grundkonfiguration

Hier ist ein Beispiel für das Einrichten und Starten von FiddlerCore in einem einfachen Konsolenprogramm.

using Fiddler;
using System;

namespace FiddlerCoreExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Attach event handler for the BeforeRequest event
            FiddlerApplication.BeforeRequest += (session) => {
                Console.WriteLine("Before Request for: " + session.fullUrl);
                session.bBufferResponse = true; // Buffer response to manipulate it if needed
            };
            
            // Attach event handler for the BeforeResponse event
            FiddlerApplication.BeforeResponse += (session) => {
                Console.WriteLine("Before Response for: " + session.fullUrl);
            };

            // Start FiddlerCore
            FiddlerApplication.Startup(new FiddlerCoreStartupSettingsBuilder()
                .RegisterAsSystemProxy()
                .ListenOnPort(8888)
                .Build());
            Console.WriteLine("FiddlerCore started. Press any key to stop...");
            Console.ReadKey();

            // Shutdown FiddlerCore
            FiddlerApplication.Shutdown();
            Console.WriteLine("FiddlerCore stopped.");
        }
    }
}

using Fiddler;
using System;

namespace FiddlerCoreExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Attach event handler for the BeforeRequest event
            FiddlerApplication.BeforeRequest += (session) => {
                Console.WriteLine("Before Request for: " + session.fullUrl);
                session.bBufferResponse = true; // Buffer response to manipulate it if needed
            };
            
            // Attach event handler for the BeforeResponse event
            FiddlerApplication.BeforeResponse += (session) => {
                Console.WriteLine("Before Response for: " + session.fullUrl);
            };

            // Start FiddlerCore
            FiddlerApplication.Startup(new FiddlerCoreStartupSettingsBuilder()
                .RegisterAsSystemProxy()
                .ListenOnPort(8888)
                .Build());
            Console.WriteLine("FiddlerCore started. Press any key to stop...");
            Console.ReadKey();

            // Shutdown FiddlerCore
            FiddlerApplication.Shutdown();
            Console.WriteLine("FiddlerCore stopped.");
        }
    }
}

Imports Fiddler
Imports System

Namespace FiddlerCoreExample
    Class Program
        Shared Sub Main(args As String())
            ' Attach event handler for the BeforeRequest event
            AddHandler FiddlerApplication.BeforeRequest, Sub(session)
                                                             Console.WriteLine("Before Request for: " & session.fullUrl)
                                                             session.bBufferResponse = True ' Buffer response to manipulate it if needed
                                                         End Sub

            ' Attach event handler for the BeforeResponse event
            AddHandler FiddlerApplication.BeforeResponse, Sub(session)
                                                              Console.WriteLine("Before Response for: " & session.fullUrl)
                                                          End Sub

            ' Start FiddlerCore
            FiddlerApplication.Startup(New FiddlerCoreStartupSettingsBuilder() _
                .RegisterAsSystemProxy() _
                .ListenOnPort(8888) _
                .Build())
            Console.WriteLine("FiddlerCore started. Press any key to stop...")
            Console.ReadKey()

            ' Shutdown FiddlerCore
            FiddlerApplication.Shutdown()
            Console.WriteLine("FiddlerCore stopped.")
        End Sub
    End Class
End Namespace

Imports Fiddler
Imports System

Namespace FiddlerCoreExample
    Class Program
        Shared Sub Main(args As String())
            ' Attach event handler for the BeforeRequest event
            AddHandler FiddlerApplication.BeforeRequest, Sub(session)
                                                             Console.WriteLine("Before Request for: " & session.fullUrl)
                                                             session.bBufferResponse = True ' Buffer response to manipulate it if needed
                                                         End Sub

            ' Attach event handler for the BeforeResponse event
            AddHandler FiddlerApplication.BeforeResponse, Sub(session)
                                                              Console.WriteLine("Before Response for: " & session.fullUrl)
                                                          End Sub

            ' Start FiddlerCore
            FiddlerApplication.Startup(New FiddlerCoreStartupSettingsBuilder() _
                .RegisterAsSystemProxy() _
                .ListenOnPort(8888) _
                .Build())
            Console.WriteLine("FiddlerCore started. Press any key to stop...")
            Console.ReadKey()

            ' Shutdown FiddlerCore
            FiddlerApplication.Shutdown()
            Console.WriteLine("FiddlerCore stopped.")
        End Sub
    End Class
End Namespace

Erklärung

• FiddlerApplication.BeforeRequest: Wird ausgelöst, bevor eine Anfrage an den Server gesendet wird.
• FiddlerApplication.BeforeResponse: Wird ausgelöst, bevor eine Antwort an den Client gesendet wird.

Start von FiddlerCore

FiddlerApplication.Startup(settings): Verwendet die angegebenen Starteinstellungen, um FiddlerCore auf dem angegebenen Port zu starten. Der Standardport ist 8888.

Stoppen von FiddlerCore

FiddlerApplication.Shutdown(): Stoppt FiddlerCore und gibt Ressourcen frei.

Zusätzliche Konfiguration

FiddlerCore kann weiter konfiguriert werden, um Ihren Bedürfnissen zu entsprechen, indem Sie entweder die FiddlerCoreStartupFlags oder das Sitzungsverhalten in den Ereignishandlern ändern.

FiddlerApplication.Startup(new FiddlerCoreStartupSettingsBuilder()
    .RegisterAsSystemProxy()
    .ListenOnPort(3000)
    .DecryptSSL()
    .AllowRemoteClients()
    .Build());

FiddlerApplication.Startup(new FiddlerCoreStartupSettingsBuilder()
    .RegisterAsSystemProxy()
    .ListenOnPort(3000)
    .DecryptSSL()
    .AllowRemoteClients()
    .Build());

FiddlerApplication.Startup((New FiddlerCoreStartupSettingsBuilder()).RegisterAsSystemProxy().ListenOnPort(3000).DecryptSSL().AllowRemoteClients().Build())

FiddlerApplication.Startup((New FiddlerCoreStartupSettingsBuilder()).RegisterAsSystemProxy().ListenOnPort(3000).DecryptSSL().AllowRemoteClients().Build())

• DecryptSSL: Ermöglicht die Entschlüsselung von HTTPS-Verkehr.
• AllowRemoteClients: Erlaubt es entfernten Clients, eine Verbindung zu FiddlerCore herzustellen.

Einstieg mit IronPDF

Wenn Sie FiddlerCore und IronPDF in einer .NET-Anwendung integrieren, können Sie den Webverkehr überwachen und steuern und die gesammelten Daten verwenden, um umfassende PDF-Berichte zu erstellen. Hier ist ein Schritt-für-Schritt-Tutorial zur Verwendung von IronPDF und FiddlerCore:

Was ist IronPDF?

C#-Programme können die funktionsreiche .NET-Bibliothek IronPDF verwenden, um PDF-Dokumente zu erstellen, zu lesen und zu bearbeiten. Entwickler können mit diesem Dienstprogramm problemlos druckfertige, hochwertige PDFs aus HTML-, CSS- und JavaScript-Inhalten erstellen. Einige der wesentlichen Funktionen beinhalten das Hinzufügen von Kopf- und Fußzeilen, das Trennen und Zusammenführen von PDFs, das Wasserzeichen von Dokumenten und die Umwandlung von HTML zu PDF. IronPDF unterstützt sowohl .NET Framework als auch .NET Core, was es für eine breite Palette von Anwendungen nützlich macht.

Da PDFs eine Fülle von Inhalten bieten und benutzerfreundlich sind, können Entwickler sie problemlos in ihre Programme integrieren. Die von IronPDF erzeugten Ausgabe-PDFs ähneln dem Quell-HTML-Inhalt, da es komplexe Layouts und Formatierungen problemlos handhaben kann.

Funktionen von IronPDF

PDF-Erstellung aus HTML

Konvertieren Sie HTML, CSS und JavaScript in PDF. IronPDF unterstützt zwei moderne Webstandards: Media Queries und Responsive Design. Dadurch ist es praktisch, um PDF-Dokumente, Berichte und Rechnungen dynamisch mit HTML und CSS zu gestalten.

PDF-Bearbeitung

Es ist möglich, Text, Bilder und anderes Material zu bereits bestehenden PDFs hinzuzufügen. Text und Bilder aus PDFs extrahieren. Mehrere PDFs zu einer einzigen Datei zusammenführen. PDF-Dateien in mehrere einzelne Dokumente aufteilen. Kopfzeilen, Fußzeilen, Anmerkungen und Wasserzeichen hinzufügen.

PDF-Konvertierung

IronPDF kann eine Vielzahl von Dateitypen, wie Word-, Excel- und Bilddateien, in PDF umwandeln. Macht die Umwandlung von PDF in Bild (PNG, JPEG etc.) einfach.

Leistung und Zuverlässigkeit

In industriellen Kontexten sind hohe Leistung und Zuverlässigkeit wünschenswerte Designmerkmale. IronPDF bewältigt problemlos große Dokumentensätze.

IronPDF installieren

Installieren Sie das IronPDF-Paket, um die Tools zu erhalten, die Sie benötigen, um mit PDFs in .NET-Projekten zu arbeiten.

dotnet add package IronPdf

FiddlerCore mit IronPDF

Der untenstehende Code ist ein Beispiel für das Einrichten und Ausführen von FiddlerCore, welches den Webverkehr erfasst, und dann IronPDF verwendet, um einen PDF-Bericht zu erstellen.

using Fiddler;
using IronPdf;
using System;
using System.Text;

namespace FiddlerCore IronPDFExample
{
    class Program
    {
        // StringBuilder to store traffic details
        static StringBuilder sb = new StringBuilder();
        
        static void Main(string[] args)
        {
            // Initialize FiddlerCore event handlers
            FiddlerApplication.OnNotification += (sender, oNEA) => {
                Console.WriteLine("Notification: " + oNEA.NotifyString);
            };
            FiddlerApplication.OnLogString += (sender, oLEA) => {
                Console.WriteLine("Log: " + oLEA.LogString);
            };
            FiddlerApplication.BeforeRequest += (session) => {
                Console.WriteLine("Before Request for: " + session.fullUrl);
                sb.AppendLine($"Request: {session.fullUrl}");
                session.bBufferResponse = true; // Buffer response
            };
            FiddlerApplication.BeforeResponse += (session) => {
                Console.WriteLine("Before Response for: " + session.fullUrl);
                sb.AppendLine($"Response: {session.GetResponseBodyAsString()}");
            };

            // Start FiddlerCore
            FiddlerApplication.Startup(8888, FiddlerCoreStartupFlags.Default);
            Console.WriteLine("FiddlerCore started. Press any key to stop...");
            Console.ReadKey();

            // Shutdown FiddlerCore
            FiddlerApplication.Shutdown();
            Console.WriteLine("FiddlerCore stopped.");

            // Generate PDF report
            GeneratePdfReport(sb.ToString());
        }

        // Method to generate PDF report from captured traffic
        static void GeneratePdfReport(string content)
        {
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf($"<html><body><pre>{content}</pre></body></html>");
            pdf.SaveAs("TrafficReport.pdf");
            Console.WriteLine("PDF report generated: TrafficReport.pdf");
        }
    }
}

using Fiddler;
using IronPdf;
using System;
using System.Text;

namespace FiddlerCore IronPDFExample
{
    class Program
    {
        // StringBuilder to store traffic details
        static StringBuilder sb = new StringBuilder();
        
        static void Main(string[] args)
        {
            // Initialize FiddlerCore event handlers
            FiddlerApplication.OnNotification += (sender, oNEA) => {
                Console.WriteLine("Notification: " + oNEA.NotifyString);
            };
            FiddlerApplication.OnLogString += (sender, oLEA) => {
                Console.WriteLine("Log: " + oLEA.LogString);
            };
            FiddlerApplication.BeforeRequest += (session) => {
                Console.WriteLine("Before Request for: " + session.fullUrl);
                sb.AppendLine($"Request: {session.fullUrl}");
                session.bBufferResponse = true; // Buffer response
            };
            FiddlerApplication.BeforeResponse += (session) => {
                Console.WriteLine("Before Response for: " + session.fullUrl);
                sb.AppendLine($"Response: {session.GetResponseBodyAsString()}");
            };

            // Start FiddlerCore
            FiddlerApplication.Startup(8888, FiddlerCoreStartupFlags.Default);
            Console.WriteLine("FiddlerCore started. Press any key to stop...");
            Console.ReadKey();

            // Shutdown FiddlerCore
            FiddlerApplication.Shutdown();
            Console.WriteLine("FiddlerCore stopped.");

            // Generate PDF report
            GeneratePdfReport(sb.ToString());
        }

        // Method to generate PDF report from captured traffic
        static void GeneratePdfReport(string content)
        {
            var renderer = new HtmlToPdf();
            var pdf = renderer.RenderHtmlAsPdf($"<html><body><pre>{content}</pre></body></html>");
            pdf.SaveAs("TrafficReport.pdf");
            Console.WriteLine("PDF report generated: TrafficReport.pdf");
        }
    }
}

Um den Online-Verkehr aufzuzeichnen und einen PDF-Bericht zu erstellen, integrieren wir FiddlerCore und IronPDF in eine .NET-Konsolenanwendung in diesem Beispiel. FiddlerCore wird von der Anwendung initialisiert, die auch Ereignishandler für HTTP-Anfragen und -Antworten konfiguriert.

Die Verkehrsdaten, die die URLs der Anfragen und den Inhalt der Antworten umfassen, werden mit einem StringBuilder gesammelt. FiddlerCore wird auf Port 8888 gestartet und zeichnet den Onlineverkehr weiter auf, bis der Benutzer eine Taste drückt, um das Programm zu beenden. Nachdem das Programm beendet wurde, wird IronPDF verwendet, um die Verkehrsdaten in einem PDF-Bericht zusammenzufassen.

Das Verkehrsprotokoll, das in Wie man ein PDF mit HTML mit IronPDF erstellt formatiert ist, wird mit der GeneratePdfReport-Funktion in ein PDF umgewandelt und als "TrafficReport.pdf" gespeichert. Dies veranschaulicht, wie die leistungsstarken PDF-Erstellungsfunktionen von IronPDF und die Echtzeit-Verkehrsüberwachungsfunktionen von FiddlerCore nahtlos zusammenarbeiten, um eine umfassende Verkehrsanalyse und -berichterstellung in einer einzigen Anwendung bereitzustellen.

Abschluss

Ein effektives Werkzeug für das Sammeln, Analysieren und Berichten von Webverkehr wird erzeugt, wenn FiddlerCore und IronPDF in eine .NET-Anwendung integriert werden. Entwickler können ihre Online-Apps effizient debuggen und optimieren, während sie informative Berichte erstellen, indem sie die flexiblen PDF-Erstellungsfunktionen von IronPDF zusammen mit den leistungsstarken Überwachungs- und Manipulationsfähigkeiten von FiddlerCore nutzen. Diese Kombination vereinfacht die Entwicklungs- und Fehlersuchprozesse, indem sie die Sichtbarkeit der Web-App-Interaktionen verbessert und umfassende Dokumentation und Analyse ermöglicht.

Für die Webanwendungsentwicklung bietet die Kombination aus FiddlerCore und IronPDF eine vollständige Lösung, die die Produktivität und das Verständnis erheblich erhöht, unabhängig vom Bedarf an Leistungstests, Sicherheitsprüfungen oder vollständiger Verkehrsüberwachung.

Sie können OCR durchführen, mit Barcodes interagieren, PDFs erstellen, zu Excel verlinken und mehr mit IronPDF und weitere Iron Software-Bibliotheken erkunden für erweiterte Funktionen sowie effizientere Entwicklung zu einem Startpreis von $999. Dies geschieht durch die Kombination der hoch anpassungsfähigen Systeme und der Suite von Iron Software mit dessen Kernunterstützung.

Entwickler werden es einfacher finden, das beste Modell zu wählen, wenn Lizenzoptionen klar und projektgerecht sind. Mit Hilfe dieser Vorteile können Entwickler problemlos, erfolgreich und kohärent Lösungen für eine Vielzahl von Problemen integrieren.