Convertir HTML a PDF con autenticación de inicio de sesión en C#
Para convertir HTML a PDF detrás de la autenticación de inicio de sesión en C#, utilice IronPDF ChromeHttpLoginCredentials para la autenticación de red o descargue HTML usando HttpClient antes de la conversión. Este enfoque es eficaz tanto para la autenticación en red como para el inicio de sesión mediante formularios HTML.
Convierte páginas HTML a PDFs detrás de formularios de inicio de sesión usando la API de IronPDF. Esta guía demuestra ChromeHttpLoginCredentials para la autenticación y recuperación de contenido protegido. Maneja tanto la autenticación de red como los inicios de sesión mediante formularios HTML con ejemplos de código sencillos.
-
1Install IronPDF with NuGet Package Manager
-
2Copie y ejecute este fragmento de código.
new ChromePdfRenderer { LoginCredentials = new ChromeHttpLoginCredentials("username","password") } .RenderUrlAsPdf("https://example.com/protected") .SaveAs("secure.pdf");C# -
3Despliegue para probar en su entorno real
Comienza a usar IronPDF en tu proyecto hoy mismo con una prueba gratuita
Flujo de trabajo mínimo (5 pasos)
- Descargar la librería C# IronPDF
- Descargar el HTML para evitar inicios de sesión
- Inicio de sesión mediante autenticación de red con la propiedad LoginCredentials
- Utilice el formulario HTML para autenticación
- Solución para autenticación de inicio de sesión MVC
¿Cuáles son las mejores prácticas para manejar la autenticación de inicio de sesión?
IronPDF admite la autenticación de red TLS (nombre de usuario y contraseña) a través de la API ChromeHttpLoginCredentials. Para obtener una guía completa sobre varios escenarios de inicio de sesión, consulte el tutorial TLS Website & System Logins.
El enfoque recomendado es usar System.Net.WebClient o HttpClient para descargar HTML y recursos. Este método admite cabeceras, inicios de sesión y otros requisitos. Tras la descarga en memoria o disco, IronPDF convierte el HTML a PDF. Extraiga recursos como hojas de estilo e imágenes utilizando HtmlAgilityPack, luego descargue con System.Net.WebClient.
// 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");Imports System.Net
Imports HtmlAgilityPack
Imports IronPdf
' Download HTML content from a URL with authentication
Dim html As String
Using client As 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")
End Using
' Load the HTML into an HtmlDocument for parsing
Dim doc As New HtmlDocument()
doc.LoadHtml(html)
' Extract all image sources for downloading
For Each img As HtmlNode In doc.DocumentNode.SelectNodes("//img")
Dim imgSrc As String = img.GetAttributeValue("src", Nothing)
Console.WriteLine($"Found image: {imgSrc}")
' Download each image asset
If Not String.IsNullOrEmpty(imgSrc) Then
Dim fileName As String = Path.GetFileName(imgSrc)
Using client As New WebClient()
client.DownloadFile(imgSrc, fileName)
End Using
End If
Next
' Convert the downloaded HTML to PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("authenticated-content.pdf")System.Uri. Para reasignar todas las rutas relativas en un documento HTML, agregue una etiqueta <base> al encabezado utilizando HtmlAgilityPack. Ejemplo. Para obtener más información sobre el manejo de URL y activos, consulte la guía URL base y codificación de activos .¿Por qué debo descargar primero el contenido HTML?
Descargar el contenido HTML antes de convertirlo ofrece varias ventajas:
- Control Completo: Modifica HTML, corrige enlaces rotos, o inyecta tokens de autenticación antes de la conversión
- Gestión de Recursos: Descarga y almacena en caché recursos externos como imágenes, CSS y archivos JavaScript
- Flexibilidad de Autenticación: Usa cualquier mecanismo de autenticación .NET incluyendo OAuth, tokens JWT, o encabezados personalizados
- Rendimiento: Cache frecuentemente contenido accedido para reducir la carga del servidor
- Depuración: Inspecciona el HTML exacto que se está convirtiendo para solucionar problemas
Para situaciones complejas de autenticación que impliquen cookies y sesiones, consulte la Guía de cookies, que explica la gestión del estado de autenticación durante la conversión de PDF.
¿Cómo manejo activos como imágenes y hojas de estilo?
Al convertir páginas autenticadas, los activos externos suelen requerir la misma autenticación. Aquí hay un enfoque integral usando 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 Function DownloadAuthenticatedHtmlWithAssets(url As String, authToken As String) As Task(Of String)
Using client As New HttpClient()
' Set authentication header
client.DefaultRequestHeaders.Authorization = New System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", authToken)
' Download the main HTML
Dim html As String = Await client.GetStringAsync(url)
' Parse HTML to find assets
Dim doc As New HtmlDocument()
doc.LoadHtml(html)
' Create a base URI for resolving relative paths
Dim baseUri As New Uri(url)
' Download CSS files
Dim cssLinks = doc.DocumentNode.SelectNodes("//link[@rel='stylesheet']")
If cssLinks IsNot Nothing Then
For Each link In cssLinks
Dim href As String = link.GetAttributeValue("href", "")
If Not String.IsNullOrEmpty(href) Then
Dim cssUri As New Uri(baseUri, href)
Dim cssContent As String = Await client.GetStringAsync(cssUri)
' Embed CSS directly in the HTML
Dim styleNode = doc.CreateElement("style")
styleNode.InnerHtml = cssContent
doc.DocumentNode.SelectSingleNode("//head").AppendChild(styleNode)
' Remove the external link
link.Remove()
End If
Next
End If
' Return the modified HTML with embedded assets
Return doc.DocumentNode.OuterHtml
End Using
End Function¿Qué herramientas ayudan a analizar HTML?
El HtmlAgilityPack es la biblioteca de análisis HTML más popular para .NET, pero existen alternativas:
- HtmlAgilityPack: Mejor para análisis general de HTML y manipulación
- AngleSharp: Analizador de HTML moderno y compatible con estándares con soporte de selectores CSS
- CsQuery: Sintaxis similar a jQuery para desarrolladores de C# familiarizados con jQuery
- Expresiones regulares: Para tareas de extracción sencillas (no recomendadas para HTML complejo)
ChromeHttpLoginCredentials
¿Cómo iniciar sesión con autenticación de red?
La mayoría de las aplicaciones ASP.NET admiten autenticación de red, que es más confiable que el envío de formularios HTML. IronPDF proporciona soporte integrado para autenticación básica, digest y NTLM a través de la clase ChromeHttpLoginCredentials. Para obtener más información sobre la personalización de cabeceras, consulte la guía HTTP Request Header guide.
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");Imports IronPdf
Imports System
Private renderer As New ChromePdfRenderer With {
.LoginCredentials = New ChromeHttpLoginCredentials() With {
.NetworkUsername = "testUser",
.NetworkPassword = "testPassword"
}
}
Private uri = New Uri("http://localhost:51169/Invoice")
' Render web URL to PDF
Private pdf As PdfDocument = renderer.RenderUrlAsPdf(uri)
' Export PDF
pdf.SaveAs("UrlToPdfExample.Pdf")¿Por qué la autenticación de red es más fiable que la publicación de formularios?
La autenticación en red ofrece varias ventajas sobre la publicación de formularios HTML:
- Protocolo Estandarizado: Utiliza encabezados de autenticación HTTP siguiendo los estándares RFC
- Integración de Navegador: El motor de renderizado Chrome maneja la autenticación sin problemas
- Gestión de Sesiones: Manejo automático de desafíos de autenticación y persistencia de sesión
- Seguridad: Credenciales transmitidas de manera segura a través de encabezados en lugar de datos de formularios
- Compatibilidad: Funciona con la mayoría de los sistemas de autenticación empresarial (
Active Directory,LDAP)
¿Qué credenciales necesito para la autenticación de red?
Los distintos tipos de autenticación requieren credenciales diferentes:
// 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);Imports System.Collections.Generic
' Basic Authentication (most common)
Dim basicAuth As New ChromeHttpLoginCredentials With {
.NetworkUsername = "user@domain.com",
.NetworkPassword = "password123",
.AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
}
' NTLM/Windows Authentication
Dim ntlmAuth As New ChromeHttpLoginCredentials With {
.NetworkUsername = "DOMAIN\username", ' Include domain
.NetworkPassword = "password123",
.AuthenticationType = ChromeHttpLoginCredentials.AuthType.Ntlm
}
' Custom authentication headers
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CustomHttpHeaders.Add("X-API-Key", "your-api-key")
renderer.RenderingOptions.CustomHttpHeaders.Add("Authorization", "Bearer " & jwtToken)¿Cómo solucionar problemas de autenticación?
Problemas comunes de autenticación y soluciones:
- 401 No Autorizado: Verifica las credenciales y el tipo de autenticación
- 403 Prohibido: Usuario autenticado pero sin permisos
- Errores de tiempo de espera: Aumente
Timeoutpara sistemas de autenticación lentos - Errores de Certificados: Configura adecuadamente las configuraciones de TLS/SSL
Permitir la depuración para diagnosticar problemas:
// 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
}Imports IronPdf
Imports System
' Enable detailed logging
Logging.Logger.EnableDebugging = True
Logging.Logger.LogFilePath = "IronPdf.log"
Logging.Logger.LoggingMode = Logging.Logger.LoggingModes.All
' Test authentication
Try
Dim pdf = renderer.RenderUrlAsPdf("https://secure.example.com")
pdf.SaveAs("authenticated.pdf")
Catch ex As Exception
Console.WriteLine($"Authentication failed: {ex.Message}")
' Check IronPdf.log for detailed error information
End Try
Mi biblioteca favorita de este tipo es IronPDF. Permite una manipulación rápida y eficiente de archivos PDF. También tiene muchas funciones valiosas, como exportar al formato PDF/A y firmar documentos PDF digitalmente.
IronOCR significa que podemos ahorrar $40,000 anualmente en el procesamiento manual, mientras mejoramos la productividad y liberamos recursos para tareas de alto impacto. Lo recomendaría encarecidamente.
El Iron Suite juega un papel crucial en nuestras operaciones. Estas son herramientas que aumentan la eficiencia en toda la empresa, incluyendo la creación de planos y la mejora en la gestión de inventario.
¿Cómo iniciar sesión con un formulario HTML?
Para iniciar sesión enviando datos a un formulario HTML, utilice la clase ChromeHttpLoginCredentials. Ver la API ChromeHttpLoginCredentials de IronPDF.
Considere estos puntos:
- Publique los datos de acceso en la URL especificada en el atributo ACTION del formulario HTML. Establezca esto como el atributo
LoginFormUrldeHttpLoginCredentials. Esto puede diferir de la URL que desea representar como PDF. - Envíe datos que representen cada entrada y área de texto del formulario HTML. Los atributos name definen el nombre de cada variable (no el id).
- Algunos sitios web protegen activamente contra el inicio de sesión automático.
// 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");Imports System.Collections.Generic
' Configure form-based login
Dim formLogin As New ChromeHttpLoginCredentials With {
.LoginFormUrl = "https://example.com/login",
.LoginFormData = New Dictionary(Of String, String) From {
{"username", "user@example.com"},
{"password", "securePassword123"},
{"rememberMe", "true"},
{"csrf_token", "abc123"} ' Include any hidden fields
}
}
Dim renderer As New ChromePdfRenderer With {
.LoginCredentials = formLogin,
.RenderingOptions = New ChromePdfRenderOptions With {
.RenderDelay = 3000, ' Allow time for login redirect
.EnableJavaScript = True
}
}
' The actual page you want to convert (after login)
Dim pdf = renderer.RenderUrlAsPdf("https://example.com/dashboard")
pdf.SaveAs("dashboard.pdf")¿Qué datos del formulario necesito capturar?
Para autenticar correctamente mediante formularios HTML, capture todas las entradas del formulario:
// 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 Function ExtractFormFields(loginPageHtml As String) As Dictionary(Of String, String)
Dim formData As New Dictionary(Of String, String)()
Dim doc As New HtmlDocument()
doc.LoadHtml(loginPageHtml)
' Find all input fields
Dim inputs = doc.DocumentNode.SelectNodes("//input")
If inputs IsNot Nothing Then
For Each input In inputs
Dim name As String = input.GetAttributeValue("name", "")
Dim value As String = input.GetAttributeValue("value", "")
Dim type As String = input.GetAttributeValue("type", "text")
If Not String.IsNullOrEmpty(name) Then
' Handle different input types
Select Case type.ToLower()
Case "checkbox"
If input.Attributes("checked") IsNot Nothing Then
formData(name) = "on"
End If
Case "radio"
If input.Attributes("checked") IsNot Nothing Then
formData(name) = value
End If
Case Else
formData(name) = value
End Select
End If
Next
End If
' Don't forget select elements
Dim selects = doc.DocumentNode.SelectNodes("//select")
If selects IsNot Nothing Then
For Each selectNode In selects
Dim name As String = selectNode.GetAttributeValue("name", "")
Dim selected = selectNode.SelectSingleNode(".//option[@selected]")
If selected IsNot Nothing AndAlso Not String.IsNullOrEmpty(name) Then
formData(name) = selected.GetAttributeValue("value", "")
End If
Next
End If
Return formData
End Function¿Cómo encontrar la URL de acción de formulario correcta?
La URL de acción del formulario es fundamental para que la autenticación se realice correctamente:
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 Function ExtractFormAction(loginPageUrl As String, loginPageHtml As String) As String
Dim doc As New HtmlDocument()
doc.LoadHtml(loginPageHtml)
' Find the login form
Dim form As HtmlNode = doc.DocumentNode.SelectSingleNode("//form[contains(@action, 'login') or contains(@id, 'login') or contains(@class, 'login')]")
If form Is Nothing Then
' Try finding any form with password field
form = doc.DocumentNode.SelectSingleNode("//form[.//input[@type='password']]")
End If
If form IsNot Nothing Then
Dim action As String = form.GetAttributeValue("action", "")
' Resolve relative URLs
If Not String.IsNullOrEmpty(action) Then
Dim baseUri As New Uri(loginPageUrl)
Dim actionUri As New Uri(baseUri, action)
Return actionUri.ToString()
End If
End If
' Default to the login page URL if no action found
Return loginPageUrl
End Function¿Cuáles son los problemas comunes de la autenticación basada en formularios?
- Tokens CSRF: Muchos formularios incluyen tokens antifalsificación que expiran
- Validación de JavaScript: Algunos formularios requieren ejecución de JavaScript
- Autenticación de Múltiples Pasos: Formularios que requieren múltiples páginas
- Protección CAPTCHA: Desafíos de verificación humana
- Tiempos de espera de sesión: Sesiones de inicio de sesión que caducan rápidamente
ViewBag
TempData
Html
Para obtener información completa sobre la conversión de HTML a PDF, incluidas situaciones complejas de autenticación, visite el Tutorial de HTML a PDF.
¿Cómo manejo la autenticación MVC?
La siguiente solución convierte una vista MVC de .NET en una cadena mediante programación, lo que evita el inicio de sesión en MVC y reproduce las vistas fielmente. Este enfoque funciona bien al convertir CSHTML a PDF en MVC Core o 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
<Extension()>
Public Shared Function RenderPartialViewToString(ByVal controller As Controller, ByVal viewPath As String, Optional ByVal model As Object = Nothing) As String
Try
' Set the model
Dim context = controller.ControllerContext
controller.ViewData.Model = model
Using sw As New StringWriter()
' Find the partial view
Dim viewResult = ViewEngines.Engines.FindPartialView(context, viewPath)
If viewResult.View Is Nothing Then
Throw New Exception($"Partial view {viewPath} could not be found.")
End If
' Create a view context
Dim viewContext As 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()
End Using
Catch ex As Exception
' Return error message if there is an exception
Return ex.Message
End Try
End Function
' Usage in an MVC Controller
Public Function GeneratePdf() As ActionResult
' Render authenticated view to string
Dim model As New InvoiceViewModel() ' populate model
Dim html As String = Me.RenderPartialViewToString("~/Views/Invoice/Details.cshtml", model)
' Convert to PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Return PDF file
Return File(pdf.BinaryData, "application/pdf", "invoice.pdf")
End Function¿Por qué renderizar vistas a cadenas en lugar de conversión directa?
La conversión de vistas MVC a cadenas de texto ofrece varias ventajas clave:
- Contexto de Autenticación: Las vistas se renderizan dentro del contexto del usuario autenticado
- Tubería MVC completa: Todas las funciones de MVC funcionan incluyendo
HtmlHelper,UrlHelper, yViewBagasistentes - Soporte de Diseño: Las páginas maestras y los diseños se renderizan correctamente
- Vinculación de Modelos: Los modelos de vista complejos funcionan sin problemas
- Filtros de acción: los filtros de seguridad y registro se ejecutan con normalidad
¿Cuáles son las ventajas de esta solución MVC?
El enfoque de representación de cadenas MVC ofrece:
- Seguridad: No es necesario exponer URLs internas o eludir la autenticación
- Rendimiento: Evita solicitudes HTTP adicionales
- Consistencia: Salida idéntica a lo que ven los usuarios en los navegadores
- Flexibilidad: Modifica el HTML antes de la conversión a PDF
- Pruebas: Generación de HTML para pruebas unitarias de forma sencilla
¿Cómo paso modelos a la vista renderizada?
He aquí un ejemplo completo con un modelo complejo:
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
Inherits Controller
Private ReadOnly _invoiceService As IInvoiceService
Public Async Function DownloadInvoicePdf(invoiceId As Integer) As Task(Of ActionResult)
' Load data within authenticated context
Dim invoice = Await _invoiceService.GetInvoiceAsync(invoiceId)
If invoice Is Nothing OrElse invoice.UserId <> User.Identity.GetUserId() Then
Return HttpNotFound()
End If
' Create view model
Dim viewModel = New InvoiceDetailsViewModel With {
.Invoice = invoice,
.Company = Await _invoiceService.GetCompanyDetailsAsync(),
.LineItems = Await _invoiceService.GetLineItemsAsync(invoiceId),
.TaxDetails = Await _invoiceService.GetTaxDetailsAsync(invoiceId)
}
' Render to HTML string
Dim html As String = Me.RenderPartialViewToString("~/Views/Invoice/DetailsPdf.vbhtml", 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
Dim renderer = New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.MarginTop = 20,
.MarginBottom = 20,
.MarginLeft = 10,
.MarginRight = 10,
.PrintHtmlBackgrounds = True
}
}
Dim 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")
End Function
End ClassAntes de implementar cualquier solución de autenticación, asegúrese de haber instalado IronPDF correctamente y de haber configurado sus claves de licencia.
¿Listo para ver qué más puedes hacer? Visite nuestra página de tutoriales: Convertir PDF.
RenderDelay
Preguntas Frecuentes
¿Cómo puedo convertir HTML a PDF cuando el contenido está detrás de un formulario de acceso?
IronPDF proporciona múltiples enfoques para convertir HTML a PDF tras la autenticación de inicio de sesión. Puede utilizar la API ChromeHttpLoginCredentials para la autenticación de red TLS, o descargar el contenido HTML utilizando System.Net.WebClient o HttpClient con las cabeceras de autenticación adecuadas antes de convertirlo a PDF con IronPDF.
¿Qué es ChromeHttpLoginCredentials y cómo se utiliza?
ChromeHttpLoginCredentials es la API de IronPDF para manejar la autenticación de red. Puede utilizarla estableciendo la propiedad LoginCredentials en ChromePdfRenderer con su nombre de usuario y contraseña, permitiendo a IronPDF autenticarse automáticamente al renderizar URL protegidas por contraseña a PDF.
¿Puedo gestionar inicios de sesión basados en formularios HTML para la conversión de PDF?
Sí, IronPDF admite inicios de sesión basados en formularios HTML. Se recomienda utilizar System.Net.WebClient o HttpClient para gestionar el proceso de inicio de sesión, descargar el contenido HTML autenticado y, a continuación, utilizar el método RenderHtmlAsPdf de IronPDF para convertir el HTML descargado en PDF.
¿Cómo descargo activos HTML como imágenes y hojas de estilo de páginas autenticadas?
Puede utilizar HtmlAgilityPack para analizar el HTML descargado y extraer las URL de activos como imágenes y hojas de estilo. A continuación, utilice System.Net.WebClient para descargar cada activo con las mismas cabeceras de autenticación antes de convertir el paquete HTML completo a PDF con IronPDF.
¿Cuál es la mejor práctica para manejar tokens o cabeceras de autenticación?
Cuando utilice IronPDF con tokens de autenticación, descargue el HTML utilizando HttpClient o WebClient con sus cabeceras de autenticación (como los tokens Bearer). Una vez que tenga el contenido HTML autenticado en la memoria o guardado en el disco, utilice ChromePdfRenderer de IronPDF para convertirlo a PDF.
¿Existe alguna solución para la autenticación de inicio de sesión MVC?
Sí, IronPDF proporciona soluciones para los escenarios de autenticación de inicio de sesión MVC. El enfoque recomendado es autenticar y descargar primero el contenido HTML utilizando clientes HTTP .NET estándar y, a continuación, pasar el HTML autenticado directamente al motor de renderizado de IronPDF en lugar de que IronPDF se encargue de la autenticación.
How do I log in using HTML form authentication with IronPDF?
Using IronPDF, you can configure form-based login by providing URL and form data to 'ChromeHttpLoginCredentials'. Ensure all input data from the HTML form, including hidden fields like CSRF tokens, are captured accurately.
What common issues might arise with form-based authentication?
Common issues include handling CSRF tokens, JavaScript validations, multi-step processes, CAPTCHA requirements, and session timeouts. Properly addressing these can ensure smoother login processes for automated tasks.
How can I troubleshoot authentication failures with IronPDF?
Authentication issues can be addressed by verifying credentials, checking for 401 or 403 errors, adjusting timeout settings, ensuring proper TLS/SSL configuration, and enabling detailed logging to diagnose problems.
What are the advantages of rendering MVC views to strings before converting to PDF?
Rendering views to strings maintains the authentication context, supports MVC features, and allows modification of HTML before conversion. This approach ensures security, performance, and consistency, reflecting what users see in browsers.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
