FiddlerCore .NET (Como funciona para desenvolvedores)

O que é o FiddlerCore?

FiddlerCore é um poderoso pacote .NET baseado no popular proxy de depuração web, Fiddler. Ele permite que os desenvolvedores incorporem os recursos robustos de captura e inspeção de tráfego HTTP/HTTPS do Fiddler em seus aplicativos. Assim como a interface do usuário do Fiddler, ele também permite modificar as solicitações HTTP. Esta biblioteca é um recurso vital para depurar, testar e melhorar as interações na web, pois permite o monitoramento, registro e modificação completos do tráfego da web.

O FiddlerCore oferece aos desenvolvedores controle total sobre o tráfego de rede, permitindo que eles interceptem, decodifiquem e alterem solicitações e respostas. Isso facilita a localização e a correção de problemas em aplicativos online, como problemas de desempenho e falhas de segurança. A API do FiddlerCore possibilita opções de integração profunda, permitindo processos personalizados e operações automatizadas.

De maneira geral, o FiddlerCore aprimora o processo de desenvolvimento ao oferecer uma visão interativa e completa do tráfego da web — uma ferramenta essencial para a criação de aplicativos web confiáveis ​​e eficazes.

Criar e configurar o FiddlerCore

Estas etapas devem ser seguidas para criar e configurar o FiddlerCore em uma aplicação .NET :

dotnet new console -n FiddlerCoreExample
cd FiddlerCoreExample

dotnet new console -n FiddlerCoreExample
cd FiddlerCoreExample

dotnet add package FiddlerCore

dotnet add package FiddlerCore

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
	Friend Class Program
		Shared Sub Main(ByVal 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

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())

Primeiros passos com o IronPDF

Ao integrar o FiddlerCore e o IronPDF em uma aplicação .NET , você pode monitorar e controlar o tráfego da web e usar os dados coletados para criar relatórios PDF abrangentes. Aqui está um tutorial passo a passo sobre como usar o IronPDF e o FiddlerCore:

O que é o IronPDF?

Os programas em C# podem usar a biblioteca IronPDF do .NET , rica em recursos, para produzir, ler e editar documentos PDF. Com essa ferramenta, os desenvolvedores podem criar facilmente PDFs de alta qualidade e prontos para impressão a partir de conteúdo HTML, CSS e JavaScript . Adicionar cabeçalhos e rodapés, dividir e combinar PDFs, inserir marcas d'água em documentos e converter HTML para PDF são algumas das funções essenciais. O IronPDF é compatível com o .NET Framework e o .NET Core, o que o torna útil para uma ampla gama de aplicações.

Como os PDFs oferecem uma grande quantidade de conteúdo e são fáceis de usar, os desenvolvedores podem incorporá-los facilmente em seus programas. Os PDFs gerados pelo IronPDF são muito semelhantes ao conteúdo HTML original, pois ele consegue lidar facilmente com layouts e formatações complexas.

Funcionalidades do IronPDF

dotnet add package IronPdf

FiddlerCore com IronPDF

O código abaixo é um exemplo de como configurar e executar o FiddlerCore, capturar o tráfego da web e, em seguida, usar o IronPDF para criar um relatório em 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");
        }
    }
}

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");
        }
    }
}

Imports Fiddler
Imports IronPdf
Imports System
Imports System.Text

Namespace FiddlerCoreIronPDFExample
    Class Program
        ' StringBuilder to store traffic details
        Private Shared sb As New StringBuilder()

        Shared Sub Main(args As String())
            ' Initialize FiddlerCore event handlers
            AddHandler FiddlerApplication.OnNotification, Sub(sender, oNEA)
                                                              Console.WriteLine("Notification: " & oNEA.NotifyString)
                                                          End Sub
            AddHandler FiddlerApplication.OnLogString, Sub(sender, oLEA)
                                                           Console.WriteLine("Log: " & oLEA.LogString)
                                                       End Sub
            AddHandler FiddlerApplication.BeforeRequest, Sub(session)
                                                             Console.WriteLine("Before Request for: " & session.fullUrl)
                                                             sb.AppendLine($"Request: {session.fullUrl}")
                                                             session.bBufferResponse = True ' Buffer response
                                                         End Sub
            AddHandler FiddlerApplication.BeforeResponse, Sub(session)
                                                              Console.WriteLine("Before Response for: " & session.fullUrl)
                                                              sb.AppendLine($"Response: {session.GetResponseBodyAsString()}")
                                                          End Sub

            ' 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())
        End Sub

        ' Method to generate PDF report from captured traffic
        Private Shared Sub GeneratePdfReport(content As String)
            Dim renderer = New HtmlToPdf()
            Dim pdf = renderer.RenderHtmlAsPdf($"<html><body><pre>{content}</pre></body></html>")
            pdf.SaveAs("TrafficReport.pdf")
            Console.WriteLine("PDF report generated: TrafficReport.pdf")
        End Sub
    End Class
End Namespace

Neste exemplo, para registrar o tráfego online e gerar um relatório em PDF, incorporamos o FiddlerCore e o IronPDF em um aplicativo de console .NET . O FiddlerCore é inicializado pela aplicação, que também configura os manipuladores de eventos para requisições e respostas HTTP.

Os dados de tráfego, que incluem os URLs das solicitações e o conteúdo das respostas, são coletados usando um StringBuilder. O FiddlerCore é executado na porta 8888 e continua a gravar o tráfego online até que o usuário pressione qualquer tecla para encerrar o programa. Após o encerramento do programa, o IronPDF é utilizado para compilar os dados de tráfego em um relatório em PDF.

O registro de tráfego, que é formatado em Como Criar um PDF Usando HTML com IronPDF, é convertido em um PDF usando a função GeneratePdfReport e salvo como "TrafficReport.pdf." Isso ilustra como os robustos recursos de criação de PDF do IronPDF e as capacidades de monitoramento de tráfego online do FiddlerCore funcionam juntos de forma perfeita para fornecer uma análise e relatórios detalhados de tráfego em um único aplicativo.

Conclusão

A integração do FiddlerCore e do IronPDF em uma aplicação .NET resulta em uma ferramenta eficaz para coletar, examinar e gerar relatórios de tráfego web. Os desenvolvedores podem depurar e otimizar seus aplicativos online de forma eficiente, além de gerar relatórios informativos, utilizando os recursos flexíveis de produção de PDF do IronPDF em conjunto com os poderosos recursos de monitoramento e manipulação de tráfego do FiddlerCore. Essa combinação agiliza os processos de desenvolvimento e solução de problemas, melhorando a visibilidade das interações do aplicativo web e permitindo documentação e análise abrangentes.

Para o desenvolvimento de aplicações web, a combinação do FiddlerCore e do IronPDF oferece uma solução completa que aumenta significativamente a produtividade e a capacidade de obter insights, independentemente da necessidade de testes de desempenho, verificações de segurança ou monitoramento completo do tráfego.

Você pode fazer OCR, interagir com códigos de barras, gerar PDFs, vincular ao Excel e mais com o IronPDF e explorar bibliotecas adicionais da Iron Software para capacidades aprimoradas, juntamente com um desenvolvimento mais eficiente, por um preço inicial de $999. Isso é possível graças à combinação dos sistemas e do conjunto de ferramentas altamente adaptáveis ​​da Iron Software com seu suporte principal.

Os desenvolvedores acharão mais fácil escolher o melhor modelo se as opções de licenciamento forem explícitas e adaptadas ao projeto. Com a ajuda dessas vantagens, os desenvolvedores podem incorporar soluções para uma variedade de problemas de forma fácil, bem-sucedida e coesa.