1. IronPDF
  2. Anleitungen
  3. TLS-Website- & Systemanmeldungen
Wie man Logins und Authentifizierung mit C# verwaltet

HTML in PDF konvertieren hinter Login-Authentifizierung in C#

Curtis Chau
Curtis Chau
Aktualisiert:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Um HTML in PDF hinter der Login-Authentifizierung in C# zu konvertieren, verwenden Sie IronPDF's ChromeHttpLoginCredentials für die Netzwerkauthentifizierung oder laden Sie HTML mit System.Net.WebClient/HttpClient vor der Konvertierung herunter. Bei diesem Ansatz werden sowohl die Netzwerkauthentifizierung als auch die Anmeldung über HTML-Formulare effektiv gehandhabt.

Schnellstart: HTML mit IronPDF hinter der Anmeldung in PDF konvertieren

Konvertierung von HTML-Seiten in PDFs hinter Anmeldeformularen mit der API von IronPDF. Dieser Leitfaden demonstriert ChromeHttpLoginCredentials für die Authentifizierung und den geschützten Abruf von Inhalten. Behandeln Sie sowohl Netzwerkauthentifizierung als auch HTML-Formularanmeldungen mit einfachen Codebeispielen.

Nuget IconLegen Sie jetzt mit NuGet los, um PDFs zu erstellen:

  1. Installieren Sie IronPDF mit dem NuGet-Paketmanager.

    PM > Install-Package IronPdf

  2. Kopieren Sie diesen Codeausschnitt und führen Sie ihn aus.

    new ChromePdfRenderer { LoginCredentials = new ChromeHttpLoginCredentials("username","password") }
    .RenderUrlAsPdf("https://example.com/protected")
    .SaveAs("secure.pdf");

  3. Bereitstellen zum Testen in Ihrer Live-Umgebung

    Beginnen Sie noch heute mit der Nutzung von IronPDF in Ihrem Projekt – mit einer kostenlosen Testversion.
    arrow pointer

Minimaler Arbeitsablauf (5 Schritte)

  1. Download der C# IronPDF Bibliothek
  2. HTML herunterladen, um Logins zu vermeiden
  3. Anmeldung über Netzwerkauthentifizierung mit der Eigenschaft LoginCredentials
  4. HTML-Formular für die Authentifizierung nutzen
  5. Workaround für MVC-Login-Authentifizierung


Was sind die besten Praktiken für die Handhabung der Login-Authentifizierung?

IronPDF unterstützt die TLS-Netzwerkauthentifizierung (Benutzername und Passwort) über die ChromeHttpLoginCredentials API. Eine umfassende Anleitung zu verschiedenen Anmeldeszenarien finden Sie im TLS Website & System Logins Tutorial.

Der empfohlene Ansatz ist die Verwendung von System.Net.WebClient oder HttpClient zum Herunterladen von HTML und Assets. Diese Methode unterstützt Header, Logins und andere Anforderungen. Nach dem Herunterladen in den Arbeitsspeicher oder auf die Festplatte wandelt IronPDF das HTML in PDF um. Extrahieren Sie Assets wie Stylesheets und Bilder mit HtmlAgilityPack und laden Sie sie dann mit System.Net.WebClient herunter.

// Download HTML content from a URL with authentication
string html;
using (WebClient client = new WebClient()) 
{
    // Add authentication headers if needed
    client.Headers.Add("Authorization", "Bearer " + accessToken);

    // Download the HTML string
    html = client.DownloadString("http://www.example.com/protected-content");
}

// Load the HTML into an HtmlDocument for parsing
HtmlDocument doc = new HtmlDocument();        
doc.LoadHtml(html);

// Extract all image sources for downloading
foreach(HtmlNode img in doc.DocumentNode.SelectNodes("//img")) 
{
    string imgSrc = img.GetAttributeValue("src", null);
    Console.WriteLine($"Found image: {imgSrc}");

    // Download each image asset
    if (!string.IsNullOrEmpty(imgSrc))
    {
        string fileName = Path.GetFileName(imgSrc);
        client.DownloadFile(imgSrc, fileName);
    }
}

// Convert the downloaded HTML to PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("authenticated-content.pdf");
// Download HTML content from a URL with authentication
string html;
using (WebClient client = new WebClient()) 
{
    // Add authentication headers if needed
    client.Headers.Add("Authorization", "Bearer " + accessToken);

    // Download the HTML string
    html = client.DownloadString("http://www.example.com/protected-content");
}

// Load the HTML into an HtmlDocument for parsing
HtmlDocument doc = new HtmlDocument();        
doc.LoadHtml(html);

// Extract all image sources for downloading
foreach(HtmlNode img in doc.DocumentNode.SelectNodes("//img")) 
{
    string imgSrc = img.GetAttributeValue("src", null);
    Console.WriteLine($"Found image: {imgSrc}");

    // Download each image asset
    if (!string.IsNullOrEmpty(imgSrc))
    {
        string fileName = Path.GetFileName(imgSrc);
        client.DownloadFile(imgSrc, fileName);
    }
}

// Convert the downloaded HTML to PDF
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("authenticated-content.pdf");
$vbLabelText   $csharpLabel

relative URLs in absolute URLs umwandeln, indem man den überladenen System.Uri-Konstruktor verwendet. Um alle relativen Pfade in einem HTML-Dokument umzubasieren, fügen Sie mit HtmlAgilityPack ein <base>-Tag in die Kopfzeile ein. Beispiel. Weitere Informationen zum Umgang mit URLs und Assets finden Sie im Leitfaden zur Codierung von Basis-URLs und Assets.)}]

Warum sollte ich zuerst HTML-Inhalte herunterladen?

Das Herunterladen von HTML-Inhalten vor der Konvertierung bietet mehrere Vorteile:

  1. Komplette Kontrolle: Ändern Sie HTML, korrigieren Sie fehlerhafte Links oder fügen Sie Authentifizierungstoken vor der Konvertierung ein
  2. Asset Management: Herunterladen und Zwischenspeichern externer Ressourcen wie Bilder, CSS- und JavaScript-Dateien
  3. Authentifizierungsflexibilität: Verwenden Sie jeden .NET-Authentifizierungsmechanismus, einschließlich OAuth, JWT-Tokens oder benutzerdefinierte Header
  4. Leistung: Häufig aufgerufene Inhalte im Cache speichern, um die Serverlast zu verringern
  5. Debugging: Untersuchen Sie das genaue HTML, das konvertiert wird, um Probleme zu beheben

Für komplexe Authentifizierungsszenarien, die Cookies und Sitzungen beinhalten, siehe den Cookies-Leitfaden, der die Verwaltung des Authentifizierungsstatus während der PDF-Konvertierung erklärt.

Wie gehe ich mit Assets wie Bildern und Stylesheets um?

Bei der Konvertierung authentifizierter Seiten erfordern externe Assets oft die gleiche Authentifizierung. Hier ist ein umfassender Ansatz mit HttpClient:

public async Task<string> DownloadAuthenticatedHtmlWithAssets(string url, string authToken)
{
    using (var client = new HttpClient())
    {
        // Set authentication header
        client.DefaultRequestHeaders.Authorization = 
            new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authToken);

        // Download the main HTML
        string html = await client.GetStringAsync(url);

        // Parse HTML to find assets
        var doc = new HtmlDocument();
        doc.LoadHtml(html);

        // Create a base URI for resolving relative paths
        var baseUri = new Uri(url);

        // Download CSS files
        var cssLinks = doc.DocumentNode.SelectNodes("//link[@rel='stylesheet']");
        if (cssLinks != null)
        {
            foreach (var link in cssLinks)
            {
                string href = link.GetAttributeValue("href", "");
                if (!string.IsNullOrEmpty(href))
                {
                    var cssUri = new Uri(baseUri, href);
                    string cssContent = await client.GetStringAsync(cssUri);

                    // Embed CSS directly in the HTML
                    var styleNode = doc.CreateElement("style");
                    styleNode.InnerHtml = cssContent;
                    doc.DocumentNode.SelectSingleNode("//head").AppendChild(styleNode);

                    // Remove the external link
                    link.Remove();
                }
            }
        }

        // Return the modified HTML with embedded assets
        return doc.DocumentNode.OuterHtml;
    }
}
public async Task<string> DownloadAuthenticatedHtmlWithAssets(string url, string authToken)
{
    using (var client = new HttpClient())
    {
        // Set authentication header
        client.DefaultRequestHeaders.Authorization = 
            new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authToken);

        // Download the main HTML
        string html = await client.GetStringAsync(url);

        // Parse HTML to find assets
        var doc = new HtmlDocument();
        doc.LoadHtml(html);

        // Create a base URI for resolving relative paths
        var baseUri = new Uri(url);

        // Download CSS files
        var cssLinks = doc.DocumentNode.SelectNodes("//link[@rel='stylesheet']");
        if (cssLinks != null)
        {
            foreach (var link in cssLinks)
            {
                string href = link.GetAttributeValue("href", "");
                if (!string.IsNullOrEmpty(href))
                {
                    var cssUri = new Uri(baseUri, href);
                    string cssContent = await client.GetStringAsync(cssUri);

                    // Embed CSS directly in the HTML
                    var styleNode = doc.CreateElement("style");
                    styleNode.InnerHtml = cssContent;
                    doc.DocumentNode.SelectSingleNode("//head").AppendChild(styleNode);

                    // Remove the external link
                    link.Remove();
                }
            }
        }

        // Return the modified HTML with embedded assets
        return doc.DocumentNode.OuterHtml;
    }
}
$vbLabelText   $csharpLabel

Welche Tools helfen beim HTML-Parsing?

Das HtmlAgilityPack ist die beliebteste HTML-Parsing-Bibliothek für .NET, aber es gibt auch Alternativen:

  1. HtmlAgilityPack: Am besten geeignet für allgemeines HTML-Parsing und Manipulation
  2. AngleSharp: Moderner, standardkonformer HTML-Parser mit CSS-Selektor-Unterstützung
  3. CsQuery: jQuery-ähnliche Syntax für C#-Entwickler, die mit jQuery vertraut sind
  4. Reguläre Ausdrücke: Für einfache Extraktionsaufgaben (nicht empfohlen für komplexes HTML)

Wie melde ich mich mit Netzwerkauthentifizierung an?

Die meisten ASP.NET-Anwendungen unterstützen die Netzwerkauthentifizierung, die zuverlässiger ist als das Absenden von HTML-Formularen. IronPDF bietet integrierte Unterstützung für Basic-, Digest- und NTLM-Authentifizierung durch die ChromeHttpLoginCredentials-Klasse. Weitere Informationen zur Anpassung der Header finden Sie im HTTP Request Header guide.

:path=/static-assets/pdf/content-code-examples/how-to/logins-username-password.cs
using IronPdf;
using System;

ChromePdfRenderer renderer = new ChromePdfRenderer
{
    // setting login credentials to bypass basic authentication
    LoginCredentials = new ChromeHttpLoginCredentials()
    {
        NetworkUsername = "testUser",
        NetworkPassword = "testPassword"
    }
};

var uri = new Uri("http://localhost:51169/Invoice");

// Render web URL to PDF
PdfDocument pdf = renderer.RenderUrlAsPdf(uri);

// Export PDF
pdf.SaveAs("UrlToPdfExample.Pdf");
$vbLabelText   $csharpLabel

Warum ist Netzwerkauthentifizierung zuverlässiger als Formularposting?

Die Netzwerkauthentifizierung bietet mehrere Vorteile gegenüber der Veröffentlichung von HTML-Formularen:

  1. Standardisiertes Protokoll: Verwendet HTTP-Authentifizierungs-Header nach RFC-Standards
  2. Browser-Integration: Chrome-Rendering-Engine übernimmt nahtlos die Authentifizierung
  3. Sitzungsverwaltung: Automatische Handhabung von Authentifizierungsherausforderungen und Sitzungspersistenz
  4. Sicherheit: Sichere Übertragung von Anmeldeinformationen über Header statt über Formulardaten
  5. Kompatibilität: Funktioniert mit den meisten Authentifizierungssystemen von Unternehmen (Active Directory, LDAP)

Welche Anmeldeinformationen benötige ich für die Netzwerkauthentifizierung?

Verschiedene Authentifizierungsarten erfordern unterschiedliche Anmeldedaten:

// Basic Authentication (most common)
var basicAuth = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "password123",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
};

// NTLM/Windows Authentication
var ntlmAuth = new ChromeHttpLoginCredentials
{
    NetworkUsername = "DOMAIN\\username", // Include domain
    NetworkPassword = "password123",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Ntlm
};

// Custom authentication headers
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CustomHttpHeaders.Add("X-API-Key", "your-api-key");
renderer.RenderingOptions.CustomHttpHeaders.Add("Authorization", "Bearer " + jwtToken);
// Basic Authentication (most common)
var basicAuth = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "password123",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
};

// NTLM/Windows Authentication
var ntlmAuth = new ChromeHttpLoginCredentials
{
    NetworkUsername = "DOMAIN\\username", // Include domain
    NetworkPassword = "password123",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Ntlm
};

// Custom authentication headers
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CustomHttpHeaders.Add("X-API-Key", "your-api-key");
renderer.RenderingOptions.CustomHttpHeaders.Add("Authorization", "Bearer " + jwtToken);
$vbLabelText   $csharpLabel

Wie behebe ich Fehler bei der Authentifizierung?

Allgemeine Authentifizierungsprobleme und Lösungen:

  1. 401 Nicht autorisiert: Anmeldeinformationen und Authentifizierungstyp prüfen
  2. 403 Verboten: Benutzer ist authentifiziert, hat aber keine Berechtigungen
  3. Timeout-Fehler: Erhöhen Sie RenderDelay für langsame Authentifizierungssysteme
  4. Zertifikat-Fehler: TLS/SSL-Einstellungen richtig konfigurieren

Ermöglichen Sie die Fehlersuche, um Probleme zu diagnostizieren:

// Enable detailed logging
IronPdf.Logging.Logger.EnableDebugging = true;
IronPdf.Logging.Logger.LogFilePath = "IronPdf.log";
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;

// Test authentication
try 
{
    var pdf = renderer.RenderUrlAsPdf("https://secure.example.com");
    pdf.SaveAs("authenticated.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Authentication failed: {ex.Message}");
    // Check IronPdf.log for detailed error information
}
// Enable detailed logging
IronPdf.Logging.Logger.EnableDebugging = true;
IronPdf.Logging.Logger.LogFilePath = "IronPdf.log";
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;

// Test authentication
try 
{
    var pdf = renderer.RenderUrlAsPdf("https://secure.example.com");
    pdf.SaveAs("authenticated.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Authentication failed: {ex.Message}");
    // Check IronPdf.log for detailed error information
}
$vbLabelText   $csharpLabel

Wie melde ich mich mit einem HTML-Formular an?

Um sich durch Senden von Daten an ein HTML-Formular anzumelden, verwenden Sie die Klasse ChromeHttpLoginCredentials. Siehe IronPDFs ChromeHttpLoginCredentials API.

Berücksichtigen Sie diese Punkte:

  • Die Anmeldedaten müssen an die im ACTION-Attribut des HTML-Formulars angegebene URL gesendet werden. Setzen Sie dies als LoginFormUrl-Attribut von HttpLoginCredentials. Dies kann von der URL abweichen, die Sie als PDF wiedergeben möchten.
  • Senden Sie Daten, die alle Eingaben und Textfelder im HTML-Formular darstellen. Die name-Attribute definieren jeden Variablennamen (nicht die id).
  • Einige Websites schützen sich aktiv gegen maschinelle Anmeldung.

Hier ist ein vollständiges Beispiel für formularbasierte Authentifizierung:

// Configure form-based login
var formLogin = new ChromeHttpLoginCredentials
{
    LoginFormUrl = "https://example.com/login",
    LoginFormData = new Dictionary<string, string>
    {
        {"username", "user@example.com"},
        {"password", "securePassword123"},
        {"rememberMe", "true"},
        {"csrf_token", "abc123"} // Include any hidden fields
    }
};

var renderer = new ChromePdfRenderer
{
    LoginCredentials = formLogin,
    RenderingOptions = new ChromePdfRenderOptions
    {
        RenderDelay = 3000, // Allow time for login redirect
        EnableJavaScript = true
    }
};

// The actual page you want to convert (after login)
var pdf = renderer.RenderUrlAsPdf("https://example.com/dashboard");
pdf.SaveAs("dashboard.pdf");
// Configure form-based login
var formLogin = new ChromeHttpLoginCredentials
{
    LoginFormUrl = "https://example.com/login",
    LoginFormData = new Dictionary<string, string>
    {
        {"username", "user@example.com"},
        {"password", "securePassword123"},
        {"rememberMe", "true"},
        {"csrf_token", "abc123"} // Include any hidden fields
    }
};

var renderer = new ChromePdfRenderer
{
    LoginCredentials = formLogin,
    RenderingOptions = new ChromePdfRenderOptions
    {
        RenderDelay = 3000, // Allow time for login redirect
        EnableJavaScript = true
    }
};

// The actual page you want to convert (after login)
var pdf = renderer.RenderUrlAsPdf("https://example.com/dashboard");
pdf.SaveAs("dashboard.pdf");
$vbLabelText   $csharpLabel

Welche Formulardaten muss ich erfassen?

Für eine erfolgreiche Authentifizierung über HTML-Formulare müssen alle Formulareingaben erfasst werden:

// Use this helper method to extract form fields
public Dictionary<string, string> ExtractFormFields(string loginPageHtml)
{
    var formData = new Dictionary<string, string>();
    var doc = new HtmlDocument();
    doc.LoadHtml(loginPageHtml);

    // Find all input fields
    var inputs = doc.DocumentNode.SelectNodes("//input");
    if (inputs != null)
    {
        foreach (var input in inputs)
        {
            string name = input.GetAttributeValue("name", "");
            string value = input.GetAttributeValue("value", "");
            string type = input.GetAttributeValue("type", "text");

            if (!string.IsNullOrEmpty(name))
            {
                // Handle different input types
                switch (type.ToLower())
                {
                    case "checkbox":
                        if (input.Attributes["checked"] != null)
                            formData[name] = "on";
                        break;
                    case "radio":
                        if (input.Attributes["checked"] != null)
                            formData[name] = value;
                        break;
                    default:
                        formData[name] = value;
                        break;
                }
            }
        }
    }

    // Don't forget select elements
    var selects = doc.DocumentNode.SelectNodes("//select");
    if (selects != null)
    {
        foreach (var select in selects)
        {
            string name = select.GetAttributeValue("name", "");
            var selected = select.SelectSingleNode(".//option[@selected]");
            if (selected != null && !string.IsNullOrEmpty(name))
            {
                formData[name] = selected.GetAttributeValue("value", "");
            }
        }
    }

    return formData;
}
// Use this helper method to extract form fields
public Dictionary<string, string> ExtractFormFields(string loginPageHtml)
{
    var formData = new Dictionary<string, string>();
    var doc = new HtmlDocument();
    doc.LoadHtml(loginPageHtml);

    // Find all input fields
    var inputs = doc.DocumentNode.SelectNodes("//input");
    if (inputs != null)
    {
        foreach (var input in inputs)
        {
            string name = input.GetAttributeValue("name", "");
            string value = input.GetAttributeValue("value", "");
            string type = input.GetAttributeValue("type", "text");

            if (!string.IsNullOrEmpty(name))
            {
                // Handle different input types
                switch (type.ToLower())
                {
                    case "checkbox":
                        if (input.Attributes["checked"] != null)
                            formData[name] = "on";
                        break;
                    case "radio":
                        if (input.Attributes["checked"] != null)
                            formData[name] = value;
                        break;
                    default:
                        formData[name] = value;
                        break;
                }
            }
        }
    }

    // Don't forget select elements
    var selects = doc.DocumentNode.SelectNodes("//select");
    if (selects != null)
    {
        foreach (var select in selects)
        {
            string name = select.GetAttributeValue("name", "");
            var selected = select.SelectSingleNode(".//option[@selected]");
            if (selected != null && !string.IsNullOrEmpty(name))
            {
                formData[name] = selected.GetAttributeValue("value", "");
            }
        }
    }

    return formData;
}
$vbLabelText   $csharpLabel

Wie finde ich die korrekte URL für Formularaktionen?

Die URL der Formularaktion ist für die erfolgreiche Authentifizierung entscheidend:

public string ExtractFormAction(string loginPageUrl, string loginPageHtml)
{
    var doc = new HtmlDocument();
    doc.LoadHtml(loginPageHtml);

    // Find the login form
    var form = doc.DocumentNode.SelectSingleNode("//form[contains(@action, 'login') or contains(@id, 'login') or contains(@class, 'login')]");

    if (form == null)
    {
        // Try finding any form with password field
        form = doc.DocumentNode.SelectSingleNode("//form[.//input[@type='password']]");
    }

    if (form != null)
    {
        string action = form.GetAttributeValue("action", "");

        // Resolve relative URLs
        if (!string.IsNullOrEmpty(action))
        {
            var baseUri = new Uri(loginPageUrl);
            var actionUri = new Uri(baseUri, action);
            return actionUri.ToString();
        }
    }

    // Default to the login page URL if no action found
    return loginPageUrl;
}
public string ExtractFormAction(string loginPageUrl, string loginPageHtml)
{
    var doc = new HtmlDocument();
    doc.LoadHtml(loginPageHtml);

    // Find the login form
    var form = doc.DocumentNode.SelectSingleNode("//form[contains(@action, 'login') or contains(@id, 'login') or contains(@class, 'login')]");

    if (form == null)
    {
        // Try finding any form with password field
        form = doc.DocumentNode.SelectSingleNode("//form[.//input[@type='password']]");
    }

    if (form != null)
    {
        string action = form.GetAttributeValue("action", "");

        // Resolve relative URLs
        if (!string.IsNullOrEmpty(action))
        {
            var baseUri = new Uri(loginPageUrl);
            var actionUri = new Uri(baseUri, action);
            return actionUri.ToString();
        }
    }

    // Default to the login page URL if no action found
    return loginPageUrl;
}
$vbLabelText   $csharpLabel

Was sind häufige Probleme bei der formularbasierten Authentifizierung?

  1. CSRF-Tokens: Viele Formulare enthalten fälschungssichere Token, die ablaufen
  2. JavaScript-Validierung: Einige Formulare erfordern die Ausführung von JavaScript
  3. Mehrstufige Authentifizierung: Formulare, die mehrere Seiten erfordern
  4. CAPTCHA-Schutz: Herausforderungen bei der menschlichen Überprüfung
  5. Sitzungszeitüberschreitungen: Anmeldesitzungen, die schnell ablaufen

Wie gehe ich mit Anti-Bot-Schutz um?

Moderne Websites bieten Schutz vor automatischen Anmeldungen:

// Strategies for handling anti-bot measures
var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        // Mimic real browser behavior
        ViewPortWidth = 1920,
        ViewPortHeight = 1080,
        EnableJavaScript = true,
        RenderDelay = 5000, // Wait for JavaScript

        // Set a real user agent
        CustomHttpHeaders = new Dictionary<string, string>
        {
            {"User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
        }
    }
};

 // For sites with rate limiting, add delays between requests
 System.Threading.Thread.Sleep(2000);
// Strategies for handling anti-bot measures
var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        // Mimic real browser behavior
        ViewPortWidth = 1920,
        ViewPortHeight = 1080,
        EnableJavaScript = true,
        RenderDelay = 5000, // Wait for JavaScript

        // Set a real user agent
        CustomHttpHeaders = new Dictionary<string, string>
        {
            {"User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
        }
    }
};

 // For sites with rate limiting, add delays between requests
 System.Threading.Thread.Sleep(2000);
$vbLabelText   $csharpLabel

Eine umfassende Anleitung zur Konvertierung von HTML in PDF, einschließlich komplexer Authentifizierungsszenarien, finden Sie im HTML to PDF tutorial.

Wie handhabe ich die MVC-Authentifizierung?

Der folgende Workaround rendert eine .NET MVC-Ansicht programmatisch in eine Zeichenkette und vermeidet so MVC-Anmeldungen, während die Ansichten originalgetreu wiedergegeben werden. Dieser Ansatz eignet sich gut für die Konvertierung von CSHTML in PDF in MVC Core oder MVC Framework.

// Converts an MVC partial view to a string
public static string RenderPartialViewToString(this Controller controller, string viewPath, object model = null)
{
    try
    {
        // Set the model
        var context = controller.ControllerContext;
        controller.ViewData.Model = model;

        using (var sw = new StringWriter())
        {
            // Find the partial view
            var viewResult = ViewEngines.Engines.FindPartialView(context, viewPath);

            if (viewResult.View == null)
            {
                throw new Exception($"Partial view {viewPath} could not be found.");
            }

            // Create a view context
            var viewContext = new ViewContext(context, viewResult.View, context.Controller.ViewData, context.Controller.TempData, sw);

            // Render the view
            viewResult.View.Render(viewContext, sw);
            viewResult.ViewEngine.ReleaseView(context, viewResult.View);

            return sw.GetStringBuilder().ToString();
        }
    }
    catch (Exception ex)
    {
        // Return error message if there is an exception
        return ex.Message;
    }
}

// Usage in an MVC Controller
public ActionResult GeneratePdf()
{
    // Render authenticated view to string
    var model = new InvoiceViewModel { /* populate model */ };
    string html = this.RenderPartialViewToString("~/Views/Invoice/Details.cshtml", model);

    // Convert to PDF
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);

    // Return PDF file
    return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
}
// Converts an MVC partial view to a string
public static string RenderPartialViewToString(this Controller controller, string viewPath, object model = null)
{
    try
    {
        // Set the model
        var context = controller.ControllerContext;
        controller.ViewData.Model = model;

        using (var sw = new StringWriter())
        {
            // Find the partial view
            var viewResult = ViewEngines.Engines.FindPartialView(context, viewPath);

            if (viewResult.View == null)
            {
                throw new Exception($"Partial view {viewPath} could not be found.");
            }

            // Create a view context
            var viewContext = new ViewContext(context, viewResult.View, context.Controller.ViewData, context.Controller.TempData, sw);

            // Render the view
            viewResult.View.Render(viewContext, sw);
            viewResult.ViewEngine.ReleaseView(context, viewResult.View);

            return sw.GetStringBuilder().ToString();
        }
    }
    catch (Exception ex)
    {
        // Return error message if there is an exception
        return ex.Message;
    }
}

// Usage in an MVC Controller
public ActionResult GeneratePdf()
{
    // Render authenticated view to string
    var model = new InvoiceViewModel { /* populate model */ };
    string html = this.RenderPartialViewToString("~/Views/Invoice/Details.cshtml", model);

    // Convert to PDF
    var renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf(html);

    // Return PDF file
    return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
}
$vbLabelText   $csharpLabel

Warum Ansichten in Strings rendern, anstatt sie direkt zu konvertieren?

Das Rendern von MVC-Ansichten in Strings bietet mehrere entscheidende Vorteile:

  1. Authentifizierungskontext: Ansichten werden im Kontext des authentifizierten Benutzers dargestellt
  2. Vollständige MVC-Pipeline: Alle MVC-Funktionen funktionieren, einschließlich ViewBag, TempData und Html-Hilfsmittel
  3. Layout-Unterstützung: Stammseiten und Layouts werden korrekt wiedergegeben
  4. Model Binding: Komplexe Ansichtsmodelle funktionieren nahtlos
  5. Action Filters: Sicherheits- und Protokollierungsfilter werden normal ausgeführt

Was sind die Vorteile dieser MVC-Umgehung?

Der MVC-String-Rendering-Ansatz bietet:

  • Sicherheit: Keine Notwendigkeit, interne URLs offenzulegen oder die Authentifizierung zu umgehen
  • Leistungsfähigkeit: Vermeiden Sie zusätzliche HTTP-Anfragen
  • Konsistenz: Identische Ausgabe mit dem, was Benutzer in Browsern sehen
  • Flexibilität: Ändern Sie HTML vor der PDF-Konvertierung
  • Testing: Einfache HTML-Generierung für Unit-Tests

Wie übergebe ich Modelle an die gerenderte Ansicht?

Hier ist ein umfassendes Beispiel mit einem komplexen Modell:

public class InvoiceController : Controller
{
    private readonly IInvoiceService _invoiceService;

    public async Task<ActionResult> DownloadInvoicePdf(int invoiceId)
    {
        // Load data within authenticated context
        var invoice = await _invoiceService.GetInvoiceAsync(invoiceId);

        if (invoice == null || invoice.UserId != User.Identity.GetUserId())
        {
            return HttpNotFound();
        }

        // Create view model
        var viewModel = new InvoiceDetailsViewModel
        {
            Invoice = invoice,
            Company = await _invoiceService.GetCompanyDetailsAsync(),
            LineItems = await _invoiceService.GetLineItemsAsync(invoiceId),
            TaxDetails = await _invoiceService.GetTaxDetailsAsync(invoiceId)
        };

        // Render to HTML string
        string html = this.RenderPartialViewToString("~/Views/Invoice/DetailsPdf.cshtml", viewModel);

        // Add custom styling for PDF
        html = $@"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; }}
                    .invoice-header {{ background-color: #f0f0f0; padding: 20px; }}
                    .line-items {{ width: 100%; border-collapse: collapse; }}
                    .line-items th, .line-items td {{ border: 1px solid #ddd; padding: 8px; }}
                </style>
            </head>
            <body>
                {html}
            </body>
            </html>";

        // Convert to PDF with options
        var renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                MarginTop = 20,
                MarginBottom = 20,
                MarginLeft = 10,
                MarginRight = 10,
                PrintHtmlBackgrounds = true
            }
        };

        var pdf = renderer.RenderHtmlAsPdf(html);

        // Add metadata
        pdf.MetaData.Author = "Invoice System";
        pdf.MetaData.Title = $"Invoice #{invoice.Number}";
        pdf.MetaData.CreationDate = DateTime.Now;

        return File(pdf.BinaryData, "application/pdf", $"Invoice-{invoice.Number}.pdf");
    }
}
public class InvoiceController : Controller
{
    private readonly IInvoiceService _invoiceService;

    public async Task<ActionResult> DownloadInvoicePdf(int invoiceId)
    {
        // Load data within authenticated context
        var invoice = await _invoiceService.GetInvoiceAsync(invoiceId);

        if (invoice == null || invoice.UserId != User.Identity.GetUserId())
        {
            return HttpNotFound();
        }

        // Create view model
        var viewModel = new InvoiceDetailsViewModel
        {
            Invoice = invoice,
            Company = await _invoiceService.GetCompanyDetailsAsync(),
            LineItems = await _invoiceService.GetLineItemsAsync(invoiceId),
            TaxDetails = await _invoiceService.GetTaxDetailsAsync(invoiceId)
        };

        // Render to HTML string
        string html = this.RenderPartialViewToString("~/Views/Invoice/DetailsPdf.cshtml", viewModel);

        // Add custom styling for PDF
        html = $@"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; }}
                    .invoice-header {{ background-color: #f0f0f0; padding: 20px; }}
                    .line-items {{ width: 100%; border-collapse: collapse; }}
                    .line-items th, .line-items td {{ border: 1px solid #ddd; padding: 8px; }}
                </style>
            </head>
            <body>
                {html}
            </body>
            </html>";

        // Convert to PDF with options
        var renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                MarginTop = 20,
                MarginBottom = 20,
                MarginLeft = 10,
                MarginRight = 10,
                PrintHtmlBackgrounds = true
            }
        };

        var pdf = renderer.RenderHtmlAsPdf(html);

        // Add metadata
        pdf.MetaData.Author = "Invoice System";
        pdf.MetaData.Title = $"Invoice #{invoice.Number}";
        pdf.MetaData.CreationDate = DateTime.Now;

        return File(pdf.BinaryData, "application/pdf", $"Invoice-{invoice.Number}.pdf");
    }
}
$vbLabelText   $csharpLabel

Bevor Sie eine Authentifizierungslösung implementieren, stellen Sie sicher, dass Sie IronPDF ordnungsgemäß installiert und Ihre Lizenzschlüssel konfiguriert haben.

Bereit zu sehen, was Sie sonst noch tun können? Besuchen Sie unsere Tutorial-Seite: Konvertieren von PDFs.

Häufig gestellte Fragen

Wie kann ich HTML in PDF konvertieren, wenn sich der Inhalt hinter einem Anmeldeformular befindet?

IronPDF bietet mehrere Ansätze für die Konvertierung von HTML in PDF hinter der Anmeldeauthentifizierung. Sie können die ChromeHttpLoginCredentials-API für die TLS-Netzwerkauthentifizierung verwenden oder den HTML-Inhalt mithilfe von System.Net.WebClient oder HttpClient mit entsprechenden Authentifizierungs-Headern herunterladen, bevor Sie ihn mit IronPDF in PDF konvertieren.

Was ist ChromeHttpLoginCredentials und wie kann ich es verwenden?

ChromeHttpLoginCredentials ist die API von IronPDF für die Handhabung der Netzwerkauthentifizierung. Sie können sie verwenden, indem Sie die Eigenschaft LoginCredentials von ChromePdfRenderer mit Ihrem Benutzernamen und Kennwort festlegen, so dass IronPDF sich automatisch authentifizieren kann, wenn passwortgeschützte URLs in PDF gerendert werden.

Kann ich HTML-Formular-basierte Anmeldungen für die PDF-Konvertierung verarbeiten?

Ja, IronPDF unterstützt HTML-Formular-basierte Anmeldungen. Der empfohlene Ansatz ist die Verwendung von System.Net.WebClient oder HttpClient, um den Anmeldevorgang abzuwickeln, den authentifizierten HTML-Inhalt herunterzuladen und dann die RenderHtmlAsPdf-Methode von IronPDF zu verwenden, um das heruntergeladene HTML in PDF zu konvertieren.

Wie lade ich HTML-Inhalte wie Bilder und Stylesheets von authentifizierten Seiten herunter?

Sie können HtmlAgilityPack verwenden, um das heruntergeladene HTML zu parsen und Asset-URLs wie Bilder und Stylesheets zu extrahieren. Verwenden Sie dann System.Net.WebClient, um jedes Asset mit denselben Authentifizierungs-Headern herunterzuladen, bevor Sie das gesamte HTML-Paket mit IronPDF in PDF konvertieren.

Was ist die beste Praxis für den Umgang mit Authentifizierungs-Tokens oder Headern?

Wenn Sie IronPDF mit Authentifizierungstoken verwenden, laden Sie den HTML-Inhalt mithilfe von HttpClient oder WebClient mit Ihren Authentifizierungs-Headern (z. B. Bearer-Tokens) herunter. Sobald Sie den authentifizierten HTML-Inhalt im Speicher oder auf der Festplatte gespeichert haben, verwenden Sie den ChromePdfRenderer von IronPDF, um ihn in PDF zu konvertieren.

Gibt es einen Workaround für die MVC-Anmeldeauthentifizierung?

Ja, IronPDF bietet Umgehungslösungen für MVC-Anmeldeauthentifizierungsszenarien. Der empfohlene Ansatz besteht darin, zunächst die Authentifizierung vorzunehmen und den HTML-Inhalt mit Hilfe von Standard-.NET-HTTP-Clients herunterzuladen und dann den authentifizierten HTML-Inhalt direkt an die Rendering-Engine von IronPDF zu übergeben, anstatt IronPDF die Authentifizierung durchführen zu lassen.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen
Bereit anzufangen?
Nuget Downloads 17,012,929 | Version: 2025.12 gerade veröffentlicht