L'une des outils les plus utiles en C# pour construire des serveurs web autonomes de base est la classe HttpListener. Elle est incluse dans l'espace de noms System.Net et offre une méthode pour recevoir et répondre aux requêtes HTTP des clients. Cela peut être particulièrement utile pour gérer la communication web dans des programmes de bureau ou pour créer des services en ligne légers.
Une bibliothèque .NET appelée IronPDF pour PDF est utilisée pour produire, modifier et extraire du contenu des fichiers PDF. Elle offre une gamme complète de fonctionnalités pour créer des PDF à partir de HTML, transformer des PDF existants en différents formats, et modifier des PDF par programmation.
Les développeurs peuvent concevoir des services web capables de produire et de servir dynamiquement des documents PDF en réponse à des requêtes HTTP en combinant HttpListener avec IronPDF. Les applications qui ont besoin de générer des PDFs en temps réel en fonction des entrées utilisateur ou d'autres données dynamiques peuvent trouver cela extrêmement utile.
Documentation HttpListener est une classe simple mais flexible dans l'espace de noms System.Net du .NET Framework qui permet aux développeurs de concevoir des serveurs HTTP simples en C#. Son objectif est de recevoir des requêtes HTTP entrantes de clients, de les traiter et de répondre avec les informations appropriées. Cette classe est une excellente option pour des services web légers et autonomes ou pour l'intégration de fonctionnalités de communication web dans des programmes de bureau car elle ne nécessite pas un serveur web complet comme IIS.
Les développeurs peuvent définir des préfixes URI pour déterminer quelles adresses le serveur doit écouter en utilisant HttpListener. Une fois le listener démarré, il répond à toutes les requêtes entrantes et utilise le HttpListenerContext pour donner accès aux objets de requête et de réponse. Cette configuration permet de créer la logique de gestion des requêtes HTTP qui est spécifique aux besoins de l'application. La facilité d'utilisation et l'adaptabilité de HttpListener le rendent particulièrement utile dans les situations nécessitant un serveur HTTP rapide, efficace et configurable. HttpListener offre une solution stable sans surcharge pour développer des serveurs locaux pour les tests, le prototypage de services en ligne ou l'intégration de protocoles de communication dans des applications de bureau.
Un certain nombre de fonctionnalités font de HttpListener en C# un outil efficace pour construire des serveurs HTTP. Parmi les éléments essentiels figurent :
HttpListener est une bibliothèque facile à utiliser qui permet aux programmeurs d'écrire moins de code pour établir un serveur HTTP de base.HttpListener prend en charge les méthodes asynchrones, ce qui améliore l'évolutivité et la réactivité du serveur en permettant de gérer efficacement de nombreuses requêtes simultanément sans interrompre le thread principal.HttpListener pour de nombreuses techniques d'authentification, telles que Basic, Digest, NTLM et l'authentification Windows intégrée.HttpListener peut être configuré pour répondre aux requêtes HTTPS, par exemple en permettant une communication de données client-serveur sécurisée.HttpListener vous donne un contrôle complet sur le processus de requête et de réponse en vous permettant d'altérer les réponses en ajoutant de nouveaux en-têtes, codes d'état et types de contenu, et en lisant les données, en-têtes et paramètres des requêtes.HttpListener offre des options de configuration spécifiques au listener pour ajuster le comportement du serveur, telles que la gestion des certificats (pour HTTPS), les délais d'attente, et d'autres paramètres.HttpListener est compatible avec Windows, Linux et macOS et est disponible avec .NET Core et .NET 5+, ce qui offre une flexibilité de développement multiplateforme.HttpListener C#Il y a plusieurs étapes impliquées dans la création et la configuration d'un HttpListener en C#. Un tutoriel complet sur la configuration d'un HttpListener pour traiter les requêtes HTTP est disponible ci-dessous.
Ouvrez votre invite de commandes, console ou terminal.
Lancez la nouvelle application console .NET en tapant :
dotnet new console -n HttpListenerExample
cd HttpListenerExampleHttpListenerTout d'abord, créez une instance de la classe HttpListener.
Ajoutez des préfixes URI pour spécifier quelles adresses l'écouteur doit gérer.
Démarrez le HttpListener pour commencer à écouter les requêtes HTTP entrantes.
Créez une boucle pour gérer les requêtes entrantes, les traiter, et envoyer des réponses.
Arrêtez gracieusement le HttpListener lorsqu'il n'est plus nécessaire.
Voici une illustration de ces étapes en action :
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
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
While True
' 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()
End While
' Step 5: Stop the listener (this code is unreachable in the current loop structure)
' listener.Stop()
End Sub
End ClassLe code C# inclus explique le processus de création et de configuration d'un HttpListener, qui fonctionne comme un serveur HTTP de base. Il instancie d'abord un objet HttpListener et ajoute un préfixe URI (http://localhost:8080/) pour définir l'adresse pour laquelle il traitera les requêtes. Ensuite, la méthode Start est utilisée pour démarrer l'écouteur. Une boucle while indéfinie est utilisée pour continuer à écouter les nouvelles requêtes HTTP. GetContext attend une requête pendant la boucle et retourne ensuite un objet HttpListenerContext qui comprend les objets de requête et de réponse.
Après avoir enregistré l'URL de la requête, un simple objet réponse HTML est créé, transformé en un tableau d'octets, et envoyé au flux de sortie de la réponse. Avant de renvoyer la réponse au client, le type de contenu et la longueur de la réponse sont correctement spécifiés. La boucle infinie signifie que le serveur ne cesse jamais de traiter les requêtes l'une après l'autre. La méthode Stop devrait être appelée pour arrêter l'écouteur, mais dans ce cas, la boucle infinie l'empêche d'être atteinte.
IronPDF vous aide à créer et modifier des PDF de haute qualité en .NET, dont vous avez besoin pour créer des documents et des rapports. La fonctionnalité de serveur HTTP intégrée de HttpListener vous permet de gérer les requêtes web dans de petites applications ou services. Les deux outils améliorent l'utilité et la rapidité des applications .NET dans leurs domaines respectifs. Pour commencer à utiliser HttpListener de C# et l'intégrer avec IronPDF pour créer des PDFs, prenez les mesures suivantes :
La bibliothèque .NET riche en fonctionnalités IronPDF pour C# permet aux programmes C# de produire, lire et éditer des documents PDF. Avec l'aide de cet utilitaire, les développeurs peuvent rapidement transformer du contenu HTML, CSS et JavaScript en PDFs de haute qualité prêts à l'impression. Parmi les tâches les plus cruciales, la création d'en-têtes et de pieds de page, la division et la combinaison de PDFs, l'ajout de filigranes aux documents, et la conversion de HTML en PDF. IronPDF est utile pour une variété d'applications car il prend en charge à la fois le .NET Framework et .NET Core.
Parce que les PDFs sont faciles à utiliser et contiennent beaucoup d'informations, les développeurs peuvent facilement les inclure dans leurs produits. Parce qu'IronPDF peut gérer des dispositions de données complexes et un formatage, les PDFs qu'il génère en sortie ressemblent beaucoup au client ou au texte HTML original.
IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.
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
Convertissez JavaScript, HTML et CSS en PDF. IronPDF supporte les requêtes média et le design réactif, deux standards web contemporains. Son support des normes web modernes est utile pour décorer dynamiquement des rapports PDF, des factures et des documents avec du HTML et du CSS.
Les PDFs existants peuvent se voir ajouter du texte, des images et d'autres contenus. Avec IronPDF, les développeurs peuvent extraire du texte et des images des fichiers PDF, combiner plusieurs PDFs en un seul fichier, diviser des fichiers PDF en plusieurs documents distincts, et inclure des filigranes, des annotations, des en-têtes et des pieds de page aux pages PDF.
Convertir plusieurs formats de fichier, y compris les fichiers Word, Excel et image, en PDF. IronPDF prend également en charge la conversion PDF en image (PNG, JPEG, etc.).
La haute performance et la fiabilité sont des qualités de conception souhaitées dans les environnements industriels. Les développeurs peuvent gérer facilement de grands ensembles de documents.
Pour obtenir les outils nécessaires pour travailler avec des PDFs dans des projets .NET, installez le package IronPDF :
HttpListener C# avec IronPDFVoici un exemple complet qui vous montre comment utiliser IronPDF pour créer et servir un document PDF et configurer un HttpListener :
using System;
using System.Net;
using System.Text;
using IronPdf;
class Program
{
static void Main(string[] args)
{
// Step 1: Create an HttpListener instance
HttpListener listener = new HttpListener();
// Step 2: Configure URI prefixes
listener.Prefixes.Add("http://localhost:8080/");
// Step 3: Start the listener
listener.Start();
Console.WriteLine("Listening for requests on");
// Step 4: Handle incoming requests
while (true)
{
// Wait for an incoming request
HttpListenerContext context = listener.GetContext();
HttpListenerRequest request = context.Request;
// Process the request (e.g., log the request URL)
Console.WriteLine($"Received request for {request.Url}");
// Generate PDF using IronPDF
var htmlContent = "<h1>PDF generated by IronPDF</h1><p>This is a sample PDF document.</p>";
var pdf = IronPdf.HtmlToPdf.StaticRenderHtmlAsPdf(htmlContent);
// Get the PDF as a byte array
byte[] pdfBytes = pdf.BinaryData;
// Create a response
HttpListenerResponse response = context.Response;
// Set the content length and type
response.ContentLength64 = pdfBytes.Length;
response.ContentType = "application/pdf";
// Write the PDF to the response output stream
using (System.IO.Stream output = response.OutputStream)
{
output.Write(pdfBytes, 0, pdfBytes.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
Imports IronPdf
Module Program
Sub Main(args As String())
' Step 1: Create an HttpListener instance
Dim listener As New HttpListener()
' Step 2: Configure URI prefixes
listener.Prefixes.Add("http://localhost:8080/")
' Step 3: Start the listener
listener.Start()
Console.WriteLine("Listening for requests on")
' Step 4: Handle incoming requests
While True
' Wait for an incoming request
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}")
' Generate PDF using IronPDF
Dim htmlContent As String = "<h1>PDF generated by IronPDF</h1><p>This is a sample PDF document.</p>"
Dim pdf = IronPdf.HtmlToPdf.StaticRenderHtmlAsPdf(htmlContent)
' Get the PDF as a byte array
Dim pdfBytes() As Byte = pdf.BinaryData
' Create a response
Dim response As HttpListenerResponse = context.Response
' Set the content length and type
response.ContentLength64 = pdfBytes.Length
response.ContentType = "application/pdf"
' Write the PDF to the response output stream
Using output As System.IO.Stream = response.OutputStream
output.Write(pdfBytes, 0, pdfBytes.Length)
End Using
' Close the response
response.Close()
End While
' Step 5: Stop the listener (this code is unreachable in the current loop structure)
' listener.Stop()
End Sub
End ModuleLe code C# inclus montre comment connecter la conversion HTML en PDF d'IronPDF avec HttpListener pour générer et livrer dynamiquement des documents PDF et comment le configurer pour fonctionner comme un serveur de méthode HTTP de base. La première étape consiste à créer une instance de HttpListener et à la configurer pour écouter http://localhost:8080/ pour les requêtes HTTP.
Après avoir démarré l'écouteur, une boucle infinie prend le relais pour traiter les requêtes entrantes. Le code enregistre l'URL de la requête pour chaque requête, utilise IronPDF pour créer un document PDF à partir d'un texte HTML, puis transforme le PDF en tableau d'octets. Ensuite, la réponse est configurée avec le type MIME approprié (application/pdf) et la longueur du contenu.
Le premier flux de réponse est fermé pour le renvoyer au client après l'écriture du tableau d'octets PDF dans le flux de sortie de la réponse. Avec cette configuration, le serveur peut retourner efficacement des documents PDF générés dynamiquement en réponse à des requêtes HTTP.
En résumé, utiliser IronPDF conjointement avec le HttpListener de C# offre un moyen fiable de créer et de livrer dynamiquement des fichiers PDF via HTTP. Avec l'aide de HttpListener, les applications C# peuvent créer des serveurs HTTP légers capables de gérer les requêtes entrantes et de générer des réponses flexibles. Grâce à la fonctionnalité de conversion dynamique HTML en PDF d'IronPDF, les développeurs peuvent produire efficacement des rapports PDF, des factures ou d'autres documents personnalisés ou basés sur des données directement à partir de la logique côté serveur.
Les applications nécessitant la génération et la livraison de documents en temps réel via des interfaces web ou des API peuvent trouver cette combinaison particulièrement utile. Les développeurs peuvent répondre à des besoins commerciaux spécifiques en mettant en œuvre des solutions évolutives et réactives en utilisant HttpListener et IronPDF. Ces outils améliorent les expériences utilisateurs en facilitant la génération et la livraison fluides de documents sur le web.
Vous pouvez enrichir votre boîte à outils pour le développement .NET en utilisant l'OCR, en travaillant avec des codes-barres, en créant des PDF, en se connectant à Excel, et bien plus. Cela se fait en combinant sa base fondamentale avec la suite et les technologies Iron Software hautement adaptables.
Le processus de choix du meilleur modèle sera simplifié pour les développeurs en décrivant clairement les possibilités de licence qui sont adaptées au projet. Ces avantages permettent aux développeurs d'appliquer des solutions pour une variété de problèmes de manière efficace, rapide et coordonnée.
Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
