HttpListener em C# (Como funciona para desenvolvedores)

Features of HttpListener C

Diversas funcionalidades fazem do HttpListener do C# uma ferramenta eficaz para a construção de servidores HTTP. Entre os elementos essenciais estão:

• Facilidade de Uso: HttpListener é uma biblioteca fácil de usar que permite aos programadores escreverem menos código para estabelecer um servidor HTTP básico.
• Prefixos URI: É possível especificar vários prefixos URI para escuta, proporcionando flexibilidade no tratamento de diversos endpoints e garantindo que o servidor reaja apenas a consultas pertinentes.
• Operações Assíncronas: HttpListener suporta métodos assíncronos, o que aumenta a escalabilidade e a capacidade de resposta do servidor, tornando possível lidar com várias solicitações ao mesmo tempo, de forma eficiente, sem interromper o thread principal.
• Autenticação: Você pode proteger seus endpoints conforme necessário com o suporte do HttpListener para várias técnicas de autenticação, como Básica, Digest, NTLM e Autenticação Integrada do Windows.
• Suporte HTTPS: HttpListener pode ser configurado para responder a solicitações HTTPS, por exemplo, permitindo comunicação segura de dados entre cliente e servidor.
• Tratamento de Solicitação e Resposta: HttpListener oferece controle total sobre o processo de solicitação e resposta, permitindo que você altere respostas adicionando novos cabeçalhos, códigos de status e tipos de conteúdo, além de ler dados de solicitação, cabeçalhos e parâmetros.
• Configuração do Ouvinte: HttpListener fornece opções de configuração específicas do ouvinte para ajustar o comportamento do servidor, como gerenciamento de certificados (para HTTPS), tempos limite e outros parâmetros.
• Registro e diagnóstico: Permite o registro e o diagnóstico, fornecendo informações completas sobre solicitações e respostas que facilitam o monitoramento e a solução de problemas.
• Compatibilidade: Permite uma integração perfeita com os serviços e aplicativos .NET atuais, pois funciona bem com outros componentes e bibliotecas .NET .
• Multiplataforma: HttpListener é compatível com Windows, Linux e macOS e está disponível com .NET Core e .NET 5+, oferecendo flexibilidade de desenvolvimento multiplataforma.

Criar um novo projeto .NET

Abra o prompt de comando, o console ou o terminal.

Inicie a aplicação de console .NET recém-criada digitando:

dotnet new console -n HttpListenerExample
cd HttpListenerExample

dotnet new console -n HttpListenerExample
cd HttpListenerExample

Criar uma Instância HttpListener

Primeiro, crie uma instância da classe HttpListener.

Configurar prefixos de URI

Adicione prefixos de URI para especificar quais endereços o ouvinte deve processar.

Iniciar o ouvinte

Inicie o HttpListener para começar a escutar solicitações HTTP recebidas.

Atender às solicitações recebidas

Crie um loop para lidar com as solicitações recebidas, processá-las e enviar as respostas.

Pare o ouvinte

Pare graciosamente o HttpListener quando não for mais necessário.

Aqui está uma ilustração dessas etapas em ação:

using System;
using System.Net;
using System.Text;

class Program
{
    public static string url = "http://localhost:8080/";
    public static HttpListener listener;

    public static void Main(string[] args)
    {
        // Step 1: Create an HttpListener instance
        listener = new HttpListener();

        // Step 2: Configure URI prefixes
        listener.Prefixes.Add(url);

        // Step 3: Start the listener
        listener.Start();
        Console.WriteLine("Listening for requests on " + url);

        // Step 4: Handle incoming requests
        // This server will handle requests in an infinite loop
        while (true)
        {
            // GetContext method blocks until a request is received
            HttpListenerContext context = listener.GetContext();
            HttpListenerRequest request = context.Request;

            // Process the request (e.g., log the request URL)
            Console.WriteLine($"Received request for {request.Url}");

            // Create a response
            HttpListenerResponse response = context.Response;

            // Add response content
            string responseString = "<html><body>Hello, world!</body></html>";
            byte[] buffer = Encoding.UTF8.GetBytes(responseString);

            // Set the content length and type
            response.ContentLength64 = buffer.Length;
            response.ContentType = "text/html";

            // Write the response to the output stream
            using (System.IO.Stream output = response.OutputStream)
            {
                output.Write(buffer, 0, buffer.Length);
            }

            // Close the response
            response.Close();
        }
        // Step 5: Stop the listener (this code is unreachable in the current loop structure)
        // listener.Stop();
    }
}

using System;
using System.Net;
using System.Text;

class Program
{
    public static string url = "http://localhost:8080/";
    public static HttpListener listener;

    public static void Main(string[] args)
    {
        // Step 1: Create an HttpListener instance
        listener = new HttpListener();

        // Step 2: Configure URI prefixes
        listener.Prefixes.Add(url);

        // Step 3: Start the listener
        listener.Start();
        Console.WriteLine("Listening for requests on " + url);

        // Step 4: Handle incoming requests
        // This server will handle requests in an infinite loop
        while (true)
        {
            // GetContext method blocks until a request is received
            HttpListenerContext context = listener.GetContext();
            HttpListenerRequest request = context.Request;

            // Process the request (e.g., log the request URL)
            Console.WriteLine($"Received request for {request.Url}");

            // Create a response
            HttpListenerResponse response = context.Response;

            // Add response content
            string responseString = "<html><body>Hello, world!</body></html>";
            byte[] buffer = Encoding.UTF8.GetBytes(responseString);

            // Set the content length and type
            response.ContentLength64 = buffer.Length;
            response.ContentType = "text/html";

            // Write the response to the output stream
            using (System.IO.Stream output = response.OutputStream)
            {
                output.Write(buffer, 0, buffer.Length);
            }

            // Close the response
            response.Close();
        }
        // Step 5: Stop the listener (this code is unreachable in the current loop structure)
        // listener.Stop();
    }
}

Imports System
Imports System.Net
Imports System.Text

Friend Class Program
	Public Shared url As String = "http://localhost:8080/"
	Public Shared listener As HttpListener

	Public Shared Sub Main(ByVal args() As String)
		' Step 1: Create an HttpListener instance
		listener = New HttpListener()

		' Step 2: Configure URI prefixes
		listener.Prefixes.Add(url)

		' Step 3: Start the listener
		listener.Start()
		Console.WriteLine("Listening for requests on " & url)

		' Step 4: Handle incoming requests
		' This server will handle requests in an infinite loop
		Do
			' GetContext method blocks until a request is received
			Dim context As HttpListenerContext = listener.GetContext()
			Dim request As HttpListenerRequest = context.Request

			' Process the request (e.g., log the request URL)
			Console.WriteLine($"Received request for {request.Url}")

			' Create a response
			Dim response As HttpListenerResponse = context.Response

			' Add response content
			Dim responseString As String = "<html><body>Hello, world!</body></html>"
			Dim buffer() As Byte = Encoding.UTF8.GetBytes(responseString)

			' Set the content length and type
			response.ContentLength64 = buffer.Length
			response.ContentType = "text/html"

			' Write the response to the output stream
			Using output As System.IO.Stream = response.OutputStream
				output.Write(buffer, 0, buffer.Length)
			End Using

			' Close the response
			response.Close()
		Loop
		' Step 5: Stop the listener (this code is unreachable in the current loop structure)
		' listener.Stop();
	End Sub
End Class

O código C# incluído percorre o processo de criação e configuração de um HttpListener, que funciona como um servidor HTTP básico. Ele primeiro instancia um objeto HttpListener e anexa um prefixo URI (http://localhost:8080/) para definir o endereço para o qual processará solicitações. Em seguida, o método Start é usado para iniciar o ouvinte. Um laço while indefinido é utilizado para continuar à escuta de novas requisições HTTP. GetContext aguarda uma solicitação durante o loop e depois retorna um objeto HttpListenerContext que inclui os objetos de solicitação e resposta.

Após registrar a URL da solicitação, um objeto de resposta HTML simples é criado, transformado em uma matriz de bytes e enviado para o fluxo de saída de resposta. Antes de retornar a resposta ao cliente, o tipo de conteúdo e o comprimento da resposta são especificados corretamente. O loop infinito significa que o servidor nunca para de processar as solicitações uma após a outra. O método Stop precisaria ser chamado para interromper o ouvinte, mas, neste caso, o loop infinito impede que ele seja alcançado.

O que é o IronPDF?

A biblioteca .NET IronPDF para C#, rica em recursos, permite que programas em C# criem, leiam e editem documentos PDF. Com a ajuda desta ferramenta, os desenvolvedores podem transformar rapidamente conteúdo HTML, CSS e JavaScript em PDFs de alta qualidade e prontos para impressão. Entre as tarefas mais importantes estão adicionar cabeçalhos e rodapés, dividir e combinar PDFs, adicionar marcas d'água aos documentos e converter HTML para PDF. O IronPDF é útil para uma variedade de aplicações porque oferece suporte tanto ao .NET Framework quanto ao .NET Core.

Como os PDFs são fáceis de usar e contêm muitas informações, os desenvolvedores podem incluí-los facilmente em seus produtos. Como o IronPDF consegue lidar com layouts e formatações de dados complexos, os PDFs que ele gera como saída são muito semelhantes ao texto HTML original ou ao do cliente.

O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Funcionalidades do IronPDF

Geração de PDF a partir de HTML

Converter JavaScript, HTML e CSS para PDF. O IronPDF oferece suporte a media queries e design responsivo, dois padrões web contemporâneos. O suporte aos padrões modernos da web é útil para decorar dinamicamente relatórios em PDF, faturas e documentos com HTML e CSS.

Edição de PDF

É possível adicionar texto, imagens e outros conteúdos a arquivos PDF preexistentes. Com o IronPDF, os desenvolvedores podem extrair texto e imagens de arquivos PDF, combinar vários PDFs em um único arquivo, dividir arquivos PDF em vários documentos separados e incluir marcas d'água, anotações, cabeçalhos e rodapés nas páginas do PDF.

Conversão de PDF

Converta diversos formatos de arquivo, incluindo Word, Excel e arquivos de imagem, para PDF. O IronPDF também suporta a conversão de PDF para imagem (PNG, JPEG, etc.).

Desempenho e confiabilidade

Alto desempenho e confiabilidade são qualidades desejáveis ​​em projetos de ambientes industriais. Os desenvolvedores podem gerenciar grandes conjuntos de documentos com facilidade.

Instale o IronPDF

Para obter as ferramentas necessárias para trabalhar com PDFs em projetos .NET , instale o pacote IronPDF :

Install-Package IronPdf