Jednym z najbardziej przydatnych narzędzi w C# do budowania podstawowych, samodzielnych serwerów internetowych jest klasa HttpListener. Jest zawarta w przestrzeni nazw System.Net i oferuje metodę zarówno do odbierania, jak i odpowiadania na HTTP żądania od klientów. Może to być szczególnie pomocne w zarządzaniu komunikacją opartą na sieci w programach desktopowych lub budowaniu lekkich usług online.
Biblioteka .NET o nazwie IronPDF for PDF jest używana do tworzenia, modyfikowania i ekstrakcji treści z plików PDF. Oferuje szeroką gamę funkcjonalności do tworzenia plików PDF z HTML, przekształcania istniejących plików PDF w różne formaty, a także modyfikowania PDF-ów przy użyciu programowania.
Deweloperzy mogą projektować usługi internetowe, które mogą dynamicznie tworzyć i obsługiwać dokumenty PDF w odpowiedzi na żądania HTTP, łącząc HttpListener z IronPDF. Aplikacje, które muszą generować pliki PDF w czasie rzeczywistym w zależności od danych wejściowych użytkowników lub innych dynamicznych danych, mogą znaleźć to niezwykle przydatne.
Dokumentacja HttpListener to prosta, ale elastyczna klasa w przestrzeni nazw System.Net w .NET Framework, która umożliwia programistom projektowanie nieskomplikowanych serwerów HTTP w C#. Jej celem jest odbieranie przychodzących żądań HTTP od klientów, ich przetwarzanie, a następnie odpowiedź z właściwymi informacjami. Ta klasa jest świetnym wyborem dla lekkich, samodzielnych usług internetowych lub do integrowania funkcji komunikacji opartej na sieci w programach desktopowych, ponieważ nie wymaga pełnego serwera internetowego, takiego jak IIS.
Programiści mogą ustawić prefiksy URI, aby określić, na które adresy serwer powinien nasłuchiwać, używając HttpListener. Po uruchomieniu odbiornik odpowiada na wszystkie przychodzące żądania i używa HttpListenerContext, aby umożliwić dostęp do obiektów żądania i odpowiedzi. Ta konfiguracja umożliwia stworzenie logiki obsługi żądań HTTP, która jest specyficzna dla wymagań aplikacji. Łatwość użycia i elastyczność HttpListener czynią go szczególnie przydatnym w sytuacjach wymagających szybkiego, skutecznego i konfigurowalnego serwera HTTP. HttpListener zapewnia stabilne rozwiązanie bez przeciążenia do tworzenia lokalnych serwerów do testowania, prototypowania usług online lub integrowania protokołów komunikacyjnych z aplikacjami desktopowymi.
Szereg funkcji sprawia, że HttpListener w C# to skuteczne narzędzie do budowania serwerów HTTP. Wśród podstawowych elementów są:
HttpListener to łatwa w użyciu biblioteka, która pozwala programistom pisać mniej kodu, aby ustanowić podstawowy serwer HTTP.HttpListener obsługuje metody asynchroniczne, co zwiększa skalowalność i reaktywność serwera, umożliwiając efektywne obsłużenie wielu żądań jednocześnie bez przerywania głównego wątku.HttpListener dla wielu technik uwierzytelniania, takich jak Basic, Digest, NTLM i Zintegrowane Uwierzytelnianie Windows.HttpListener można skonfigurować do odpowiadania na żądania HTTPS, na przykład umożliwiając bezpieczną komunikację danych między klientem a serwerem.HttpListener daje pełną kontrolę nad procesem żądania i odpowiedzi, pozwalając na modyfikację odpowiedzi poprzez dodawanie nowych nagłówków, statusów kodów i typów treści, oraz na odczytywanie danych żądania, nagłówków i parametrów.HttpListener zapewnia opcje konfiguracji specyficzne dla odbiornika, aby dostosować jego zachowanie, takie jak zarządzanie certyfikatami (dla HTTPS), limity czasu i inne parametry.HttpListener jest kompatybilne z Windows, Linux i macOS i jest dostępne z .NET Core i .NET 5+, co oferuje elastyczność w rozwoju wieloplatformowym.HttpListener C#Istnieje wiele kroków związanych z tworzeniem i konfigurowaniem HttpListener w C#. Poniżej znajduje się obszerna instrukcja konfiguracji HttpListener do obsługi żądań HTTP.
Otwórz swój wiersz poleceń, konsolę lub terminal.
Uruchom nowo utworzoną aplikację konsolową .NET, wpisując:
dotnet new console -n HttpListenerExample
cd HttpListenerExampleHttpListenerNajpierw utwórz instancję klasy HttpListener.
Dodaj prefiksy URI, aby określić, które adresy nasłuchiwacz powinien obsługiwać.
Uruchom HttpListener, aby rozpocząć nasłuchiwanie przychodzących żądań HTTP.
Utwórz pętlę, aby obsługiwać przychodzące żądania, przetwarzać je i wysyłać odpowiedzi.
Grzecznie zatrzymaj HttpListener, gdy nie jest już potrzebny.
Oto ilustracja działania tych etapów w praktyce:
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 ClassDołączony kod C# przeprowadza przez proces tworzenia i konfigurowania HttpListener, który działa jako podstawowy serwer HTTP. Najpierw instancjonuje obiekt HttpListener i dodaje prefiks URI (http://localhost:8080/), aby zdefiniować adres, dla którego będzie przetwarzać żądania. Następnie metoda Start jest używana do uruchomienia nasłuchiwacza. Wykorzystywana jest nieustanna pętla while, aby stale nasłuchiwać nowych żądań HTTP. GetContext czeka na żądanie podczas pętli, a następnie zwraca obiekt HttpListenerContext, który zawiera obiekty żądania i odpowiedzi.
Po zalogowaniu URL żądania tworzony jest proste obiekt odpowiedzi HTML, przekształcany w tablicę bajtów i wysyłany do strumienia wyjściowego odpowiedzi. Przed wysłaniem odpowiedzi do klienta odpowiednio określany jest typ i długość treści odpowiedzi. Nieskończona pętla oznacza, że serwer nigdy nie przestaje przetwarzać żądań jedno po drugim. Aby zatrzymać nasłuchiwacza, należy wywołać metodę Stop, jednak w tym przypadku nieskończona pętla uniemożliwia jej osiągnięcie.
IronPDF pomaga tworzyć i zmieniać wysokiej jakości pliki PDF w .NET, co jest potrzebne do tworzenia dokumentów i raportów. Wbudowana funkcja serwera HTTP HttpListener pozwala zarządzać żądaniami sieciowymi w małych aplikacjach lub usługach. Oba narzędzia poprawiają przydatność i szybkość aplikacji .NET w swoich własnych dziedzinach. Aby rozpocząć korzystanie z HttpListener w C# i zintegrować go z IronPDF do tworzenia plików PDF, podejmij następujące kroki:
Bogata w funkcje biblioteka .NET IronPDF for C# pozwala programom C# tworzyć, czytać i edytować dokumenty PDF. Z pomocą tego narzędzia deweloperzy mogą szybko przekształcać materiały HTML, CSS i JavaScript w wysokiej jakości, gotowe do druku pliki PDF. Do najważniejszych zadań należą dodawanie nagłówków i stopek, dzielenie i łączenie plików PDF, dodawanie znaków wodnych do dokumentów oraz konwersja HTML do PDF. IronPDF jest przydatny w wielu zastosowaniach, ponieważ obsługuje zarówno .NET Framework, jak i .NET Core.
Ponieważ pliki PDF są łatwe w użyciu i zawierają dużo informacji, deweloperzy mogą łatwo włączać je do swoich produktów. Ponieważ IronPDF potrafi obsługiwać skomplikowane układy danych i formatowanie, wygenerowane w wyniku pliki PDF wyglądają bardzo podobnie do klienta lub oryginalnego tekstu HTML.
IronPDF wyróżnia się w konwersji HTML do PDF, zapewniając precyzyjne zachowanie oryginalnych układów i stylów. Idealnie nadaje się do tworzenia plików PDF z treści internetowych, takich jak raporty, faktury i dokumentacja. Dzięki obsłudze plików HTML, adresów URL i surowych ciągów znaków HTML, IronPDF z łatwością tworzy wysokiej jakości dokumenty 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
Konwertuj JavaScript, HTML i CSS do formatu PDF. IronPDF obsługuje zapytania o media i responsywny projekt, dwa współczesne standardy internetowe. Jego wsparcie dla nowoczesnych standardów internetowych jest przydatne do dynamicznego dekorowania raportów PDF, faktur i dokumentów za pomocą HTML i CSS.
Do istniejących plików PDF można dodawać tekst, obrazy i inne treści. Korzystając z IronPDF, deweloperzy mogą wyciągać tekst i obrazy z plików PDF, łączyć wiele PDF-ów w jeden plik, dzielić pliki PDF na kilka oddzielnych dokumentów oraz dodawać znaki wodne, adnotacje, nagłówki i stopki do stron PDF.
Konwertuj kilka formatów plików, w tym pliki Word, Excel i obrazy, na PDF. IronPDF obsługuje również konwersję PDF na obraz (PNG, JPEG itp.).
Wysoka wydajność i niezawodność to cechy projektowe pożądane w środowiskach przemysłowych. Deweloperzy mogą łatwo zarządzać dużymi zbiorami dokumentów.
Aby uzyskać narzędzia potrzebne do pracy z plikami PDF w projektach .NET, zainstaluj pakiet IronPDF:
HttpListener w C# z IronPDFTo jest kompleksowy przykład, który pokazuje, jak używać IronPDF do tworzenia i serwowania dokumentu PDF oraz ustawienia 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 ModuleZawarty kod C# pokazuje, jak połączyć HTML do konwersji na PDF w IronPDF z HttpListener, aby dynamicznie generować i dostarczać dokumenty PDF oraz jak skonfigurować go do działania jako podstawowy serwer metod HTTP. Pierwszym krokiem jest utworzenie instancji HttpListener i ustawienie jej do nasłuchiwania na http://localhost:8080/ na potrzeby obsługi żądań HTTP.
Po uruchomieniu nasłuchiwacza przejmuje niekończąca się pętla do przetwarzania przychodzących żądań. Kod rejestruje URL żądania dla każdego żądania, używa IronPDF do stworzenia dokumentu PDF z tekstu HTML, a następnie przekształca PDF w tablicę bajtów. Następnie ustawiana jest odpowiedź o właściwym typie MIME (application/pdf) i długości treści.
Pierwszy strumień odpowiedzi jest zamykany, aby odesłać go z powrotem do klienta po zapisaniu tablicy bajtów PDF w strumieniu wyjściowym odpowiedzi. Dzięki tej konfiguracji serwer może efektywnie zwracać dynamicznie utworzone dokumenty PDF w odpowiedzi na żądania HTTP.
Podsumowując, używanie IronPDF w połączeniu z HttpListener w C# oferuje niezawodny sposób na dynamiczne tworzenie i dostarczanie plików PDF przez HTTP. Dzięki HttpListener aplikacje w C# mogą tworzyć lekkie serwery HTTP zdolne do obsługi przychodzących żądań i oferujące elastyczne generowanie odpowiedzi. Dzięki wykorzystaniu dynamicznej funkcji konwersji HTML na PDF w IronPDF deweloperzy mogą efektywnie tworzyć dostosowane lub oparte na danych raporty PDF, faktury lub inne dokumenty bezpośrednio z logiki serwera.
Aplikacje wymagające generowania i dostarczania dokumentów w czasie rzeczywistym za pośrednictwem interfejsów sieciowych lub API mogą uznać tę kombinację za szczególnie przydatną. Programiści mogą sprostać specyficznym wymaganiom biznesowym, wdrażając skalowalne i reaktywne rozwiązania przy użyciu HttpListener i IronPDF. Te narzędzia poprawiają doświadczenia użytkowników, ułatwiając płynną generację i dostarczanie dokumentów przez sieć.
Możesz ulepszyć swoje narzędzia do rozwoju .NET, używając OCR, pracując z kodami kreskowymi, tworząc pliki PDF, łącząc się z Excel i wieloma innymi. Robi to, łącząc swoją podstawową podstawę z wysoko elastyczną Suite i technologiami Iron Software.
Proces wyboru najlepszego modelu będzie uproszczony dla deweloperów poprzez jasne określenie możliwości licencjonowania dostosowanych do projektu. Te zalety pozwalają deweloperom stosować rozwiązania dla różnych problemów w sposób efektywny, terminowy i skoordynowany.
Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
