HttpListener C# (Wie es für Entwickler funktioniert)

Merkmale von HttpListener C#;

Eine Reihe von Funktionen machen den HttpListener von C# zu einem effektiven Werkzeug für den Aufbau von HTTP-Servern. Zu den wichtigsten Elementen gehören:

• Benutzerfreundlichkeit: HttpListener ist eine einfach zu bedienende Bibliothek, die es Programmierern ermöglicht, weniger Code zu schreiben, um einen einfachen HTTP-Server einzurichten.
• URI-Präfixe: Mehrere URI-Präfixe können für das Zuhören angegeben werden, was Flexibilität bei der Verwaltung verschiedener Endpunkte bietet und sicherstellt, dass der Server nur auf relevante Anfragen reagiert.
• Asynchrone Operationen: HttpListener unterstützt asynchrone Methoden, was die Skalierbarkeit und Reaktionsfähigkeit des Servers verbessert, indem es möglich macht, zahlreiche Anfragen auf einmal effizient zu bearbeiten, ohne den Haupt-Thread zu unterbrechen.
• Authentifizierung: Sie können Ihre Endpunkte nach Bedarf sichern, da HttpListener Unterstützung für viele Authentifizierungstechniken wie Basic, Digest, NTLM und die integrierte Windows-Authentifizierung bietet.
• HTTPS-Unterstützung: HttpListener kann so konfiguriert werden, dass er auf HTTPS-Anfragen reagiert, beispielsweise für die sichere Client-Server-Datenkommunikation.
• Anfragen- und Antwortbearbeitung: HttpListener gibt Ihnen vollständige Kontrolle über den Anfrage- und Antwortprozess, indem es Ihnen ermöglicht, Antworten durch Hinzufügen neuer Header, Statuscodes und Inhaltsarten zu ändern und Anfragedaten, Header und Parameter zu lesen.
• Listener-Konfiguration: HttpListener bietet hörerspezifische Konfigurationsoptionen, um das Verhalten des Servers anzupassen, z.B. Zertifikatsverwaltung (für HTTPS), Timeouts und andere Parameter.
• Protokollierung und Diagnose: Ermöglicht die Protokollierung und Diagnose, indem umfassende Anfragen- und Antwortinformationen bereitgestellt werden, die die Überwachung und Fehlerbehebung erleichtern.
• Kompatibilität: Erlaubt eine nahtlose Integration in bestehende .NET-Dienste und Anwendungen, da es gut mit anderen .NET-Komponenten und -Bibliotheken zusammenarbeitet.
• Plattformübergreifend: HttpListener ist kompatibel mit Windows, Linux und macOS und ist mit .NET Core und .NET 5+ verfügbar, was eine plattformübergreifende Entwicklungsflexibilität bietet.

Ein neues .NET-Projekt erstellen

Öffnen Sie Ihr Eingabeaufforderungsfenster, Ihre Konsole oder Ihr Terminal.

Starten Sie die neu erstellte .NET-Konsolenanwendung, indem Sie eingeben:

dotnet new console -n HttpListenerExample
cd HttpListenerExample

dotnet new console -n HttpListenerExample
cd HttpListenerExample

Erstellen einer HttpListener-Instanz

Erstellen Sie zuerst eine Instanz der HttpListener-Klasse.

Konfigurieren Sie URI-Präfixe

Fügen Sie URI-Präfixe hinzu, um anzugeben, welche Adressen der Listener verarbeiten soll.

Start des Listeners

Starten Sie den HttpListener, um mit dem Hören auf eingehende HTTP-Anfragen zu beginnen.

Eingehende Anfragen bearbeiten

Erstellen Sie eine Schleife, um eingehende Anfragen zu verarbeiten, sie zu bearbeiten und Antworten zu senden.

Stoppt den Zuhörer

Beenden Sie den HttpListener ordnungsgemäß, wenn er nicht mehr benötigt wird.

Hier ist eine Illustration dieser Stufen in Aktion:

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

Der enthaltene C#-Code behandelt den Prozess der Erstellung und Konfiguration eines HttpListener, der als einfacher HTTP-Server fungiert. Zuerst wird ein HttpListener-Objekt instanziiert und ein URI-Präfix (http://localhost:8080/) angefügt, um die Adresse festzulegen, für die er Anfragen bearbeiten wird. Als nächstes wird die Methode Start verwendet, um den Listener zu starten. Eine unbefristete While-Schleife wird verwendet, um weiterhin neue HTTP-Anfragen zu hören. GetContext wartet während der Schleife auf eine Anfrage und gibt dann ein HttpListenerContext-Objekt zurück, das die Anforderungs- und Antwortobjekte enthält.

Nach dem Protokollieren der Anforderungs-URL wird ein einfaches HTML-Antwortobjekt erstellt, in ein Byte-Array umgewandelt und an den Antwortausgabestream gesendet. Bevor die Antwort an den Client zurückgegeben wird, werden der Antwortinhaltstyp und die Länge ordnungsgemäß angegeben. Die endlose Schleife bedeutet, dass der Server niemals aufhört, eine Anfrage nach der anderen zu verarbeiten. Um den Listener zu stoppen, müsste die Stop-Methode aufgerufen werden, in diesem Fall hindert jedoch die endlose Schleife daran, sie zu erreichen.

Was ist IronPDF?

Die funktionsreiche .NET-Bibliothek IronPDF für C# ermöglicht es C#-Programmen, PDF-Dokumente zu erstellen, zu lesen und zu bearbeiten. Mit diesem Werkzeug können Entwickler HTML-, CSS- und JavaScript-Inhalte schnell in qualitativ hochwertige, druckfertige PDFs umwandeln. Zu den wichtigsten Aufgaben gehören das Hinzufügen von Kopf- und Fußzeilen, das Teilen und Kombinieren von PDFs, das Hinzufügen von Wasserzeichen zu Dokumenten und die Umwandlung von HTML in PDF. IronPDF ist für eine Vielzahl von Anwendungen nützlich, da es sowohl .NET Framework als auch .NET Core unterstützt.

Da PDFs einfach zu verwenden sind und eine Menge Informationen enthalten, können Entwickler sie problemlos in ihre Produkte integrieren. Weil IronPDF komplexe Datenlayouts und Formatierungen verarbeiten kann, sehen die erzeugten PDFs als Ausgabe oft ähnlich aus wie der Client oder der ursprüngliche HTML-Text.

IronPDF überzeugt in der HTML-zu-PDF-Konvertierung, indem es den originalen Layouts und Stilen präzise erhält. Es ist ideal zur Erstellung von PDFs aus webbasierten Inhalten wie Berichten, Rechnungen und Dokumentationen. Mit Unterstützung für HTML-Dateien, URLs und rohe HTML-Strings erstellt IronPDF problemlos hochwertige PDF-Dokumente.

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

Funktionen von IronPDF

PDF-Erstellung aus HTML

JavaScript, HTML und CSS in PDF konvertieren. IronPDF unterstützt Medienabfragen und responsives Design, zwei moderne Webstandards. Seine Unterstützung für moderne Webstandards ist nützlich, um PDF-Berichte, Rechnungen und Dokumente dynamisch mit HTML und CSS zu dekorieren.

PDF-Bearbeitung

Bereits vorhandene PDFs können Text, Bilder und andere Inhalte hinzugefügt werden. Mit IronPDF können Entwickler Text und Bilder aus PDF-Dateien extrahieren, mehrere PDFs in eine Datei kombinieren, PDF-Dateien in mehrere getrennte Dokumente aufteilen und Wasserzeichen, Anmerkungen, Kopf- und Fußzeilen zu den PDF-Seiten hinzufügen.

PDF-Konvertierung

Konvertieren Sie mehrere Dateiformate, einschließlich Word-, Excel- und Bilddateien, in PDF. IronPDF unterstützt auch die Konvertierung von PDF in Bilder (PNG, JPEG usw.).

Leistung und Zuverlässigkeit

Hohe Leistung und Zuverlässigkeit sind erwünschte Designqualitäten in industriellen Umgebungen. Entwickler können große Dokumentensätzen mühelos verwalten.

IronPDF installieren

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

Install-Package IronPdf