Converter HTML para PDF com autenticação de login em C#
Para converter HTML para PDF por trás da autenticação de login em C#, use o ChromeHttpLoginCredentials do IronPDF para autenticação de rede ou baixe HTML usando HttpClient antes da conversão. Essa abordagem lida de forma eficaz tanto com a autenticação de rede quanto com os logins via formulário HTML.
Converta páginas HTML em PDFs por trás de formulários de login usando a API do IronPDF. Este guia demonstra ChromeHttpLoginCredentials para autenticação e recuperação de conteúdo protegido. Lide com autenticação de rede e logins via formulário HTML com exemplos de código simples.
-
1Install IronPDF with NuGet Package Manager
-
2Copie e execute este trecho de código.
new ChromePdfRenderer { LoginCredentials = new ChromeHttpLoginCredentials("username","password") } .RenderUrlAsPdf("https://example.com/protected") .SaveAs("secure.pdf");C# -
3Implante para testar em seu ambiente de produção.
Comece a usar IronPDF em seu projeto hoje com uma avaliação gratuita
Fluxo de trabalho mínimo (5 etapas)
- Baixe a biblioteca IronPDF em C#
- Baixe o HTML para evitar logins
- Faça login usando a Autenticação de Rede com a propriedade LoginCredentials
- Utilize um formulário HTML para autenticação.
- Solução alternativa para autenticação de login MVC
Quais são as melhores práticas para lidar com a autenticação de login?
O IronPDF oferece suporte à autenticação de rede TLS (nome de usuário e senha) por meio da API ChromeHttpLoginCredentials . Para obter orientações completas sobre vários cenários de login, consulte o tutorial Logins de sites e sistemas TLS .
A abordagem recomendada é usar System.Net.WebClient ou HttpClient para baixar HTML e ativos. Este método suporta cabeçalhos, logins e outros requisitos. Após o download para a memória ou disco, o IronPDF converte o HTML em PDF. Extraia ativos como folhas de estilo e imagens usando HtmlAgilityPack, depois baixe com System.Net.WebClient.
// Your authentication token
string accessToken = "your-access-token";
// Download HTML content from a URL with authentication
using (WebClient client = new WebClient())
{
// Add authentication headers if needed
client.Headers.Add("Authorization", "Bearer " + accessToken);
// Download the HTML string
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");
}System.Uri. Para refazer todos os caminhos relativos em um documento HTML, adicione uma tag <base> ao cabeçalho usando HtmlAgilityPack. Exemplo . Para obter mais informações sobre como lidar com URLs e recursos, consulte o guia URLs Base e Codificação de Recursos .Por que devo baixar o conteúdo HTML primeiro?
Fazer o download do conteúdo HTML antes da conversão oferece diversas vantagens:
- Controle Completo: Modifique o HTML, corrija links quebrados ou injete tokens de autenticação antes da conversão
- Gerenciamento de Ativos: Baixe e faça cache de recursos externos como imagens, CSS e arquivos JavaScript
- Flexibilidade de Autenticação: Use qualquer mecanismo de autenticação .NET, incluindo OAuth, tokens JWT ou cabeçalhos personalizados
- Desempenho: Armazene em cache conteúdo frequentemente acessado para reduzir a carga do servidor
- Depuração: Inspecione o HTML exato sendo convertido para solucionar problemas
Para cenários de autenticação complexos que envolvem cookies e sessões, consulte o guia de Cookies , que explica o gerenciamento do estado de autenticação durante a conversão de PDF.
Como faço para gerenciar recursos como imagens e folhas de estilo?
Ao converter páginas autenticadas, os recursos externos geralmente exigem a mesma autenticação. Aqui está uma abordagem abrangente 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 FunctionQue ferramentas ajudam na análise de HTML?
O HtmlAgilityPack é a biblioteca de análise HTML mais popular para .NET, mas existem alternativas:
- HtmlAgilityPack: Melhor para parsing e manipulação de HTML em geral
- AngleSharp: Parser HTML moderno, compatível com padrões, com suporte a seletores CSS
- CsQuery: Sintaxe semelhante ao jQuery para desenvolvedores C# familiarizados com jQuery
- Expressões regulares : Para tarefas de extração simples (não recomendado para HTML complexo)
ChromeHttpLoginCredentials
Como faço para entrar usando a autenticação de rede?
A maioria das aplicações ASP.NET suporta autenticação de rede, que é mais confiável do que o envio de formulários HTML. O IronPDF fornece suporte integrado para autenticação básica, digest e NTLM por meio da classe ChromeHttpLoginCredentials. Para obter mais informações sobre personalização de cabeçalhos, consulte o guia de cabeçalhos de requisição HTTP .
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 que a autenticação de rede é mais confiável do que o envio de formulários?
A autenticação em rede oferece diversas vantagens em relação ao envio de formulários HTML:
- Protocolo Padronizado: Usa cabeçalhos de autenticação HTTP seguindo os padrões RFC
- Integração com Navegador: O mecanismo de renderização do Chrome gerencia a autenticação sem problemas
- Gerenciamento de Sessão: Manipulação automática de desafios de autenticação e persistência de sessão
- Segurança: Credenciais transmitidas com segurança através de cabeçalhos em vez de dados de formulário
- Compatibilidade: Funciona com a maioria dos sistemas de autenticação empresarial (
Active Directory,LDAP)
Quais credenciais eu preciso para autenticação de rede?
Diferentes tipos de autenticação exigem credenciais diferentes:
// Basic Authentication (most common)
var basicAuth = new ChromeHttpLoginCredentials
{
NetworkUsername = "user@domain.com",
NetworkPassword = "password123"
};
// NTLM/Windows Authentication
var ntlmAuth = new ChromeHttpLoginCredentials
{
NetworkUsername = "DOMAIN\\username", // Include domain
NetworkPassword = "password123"
};
// Custom authentication headers
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HttpRequestHeaders = new Dictionary<string, string>
{
{ "X-API-Key", "your-api-key" },
{ "Authorization", "Bearer " + jwtToken }
};Como solucionar problemas de falha de autenticação?
Problemas comuns de autenticação e suas soluções:
- 401 Não Autorizado: Verifique as credenciais e o tipo de autenticação
- 403 Proibido: Usuário autenticado, mas sem permissões
- Erros de Timeout: Aumente
Timeoutpara sistemas de autenticação lentos - Erros de Certificado: Configure as configurações de TLS/SSL adequadamente
Ative a depuração 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
Minha biblioteca favorita desse tipo é o IronPDF. Ele permite a manipulação rápida e eficiente de arquivos PDF. Além disso, possui muitos recursos valiosos, como a exportação para o formato PDF/A e a assinatura digital de documentos PDF.
Com o IronOCR, podemos economizar US$ 40.000 por ano em processamento manual, ao mesmo tempo que aumentamos a produtividade e liberamos recursos para tarefas de alto impacto. Eu o recomendo fortemente.
O IronSuite desempenha um papel crucial nas nossas operações. Estas são ferramentas que aumentam a eficiência no negócio, incluindo a criação de plantas baixas e melhoria na gestão de inventário.
Como faço para entrar usando um formulário HTML?
Para fazer login enviando dados para um formulário HTML, use a classe ChromeHttpLoginCredentials . Consulte a API ChromeHttpLoginCredentials da IronPDF.
Considere estes pontos:
- Enviar os dados de login para a URL especificada no atributo ACTION do formulário HTML. Defina isso como o atributo
LoginFormUrldeHttpLoginCredentials. Isso pode ser diferente da URL que você deseja renderizar como um PDF. - Enviar dados que representam cada campo de entrada e área de texto no formulário HTML. Os atributos de nome definem o nome de cada variável (não o ID). Alguns sites oferecem proteção ativa contra logins automatizados.
// 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")Que dados de formulário preciso coletar?
Para autenticar com sucesso através de formulários HTML, capture todos os campos do formulário:
// 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 FunctionComo encontro a URL correta da ação do formulário?
O URL da ação do formulário é fundamental para uma autenticação bem-sucedida:
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 FunctionQuais são os problemas comuns com a autenticação baseada em formulários?
- Tokens CSRF: Muitos formulários incluem tokens anti-falsificação que expiram
- Validação JavaScript: Alguns formulários requerem execução de JavaScript
- Autenticação Multi-Etapas: Formulários que requerem múltiplas páginas
- Proteção CAPTCHA: Desafios de verificação humana
- Tempo limite de sessão : Sessões de login que expiram rapidamente
ViewBag
TempData
Html
Para obter orientações completas sobre conversão de HTML para PDF, incluindo cenários complexos de autenticação, visite o tutorial de HTML para PDF .
Como faço para lidar com a autenticação MVC?
A seguinte solução alternativa renderiza uma view .NET MVC em uma string programaticamente, evitando logins do MVC e, ao mesmo tempo, renderizando as views fielmente. Essa abordagem funciona bem ao converter CSHTML para PDF no MVC Core ou no 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 FunctionPor que renderizar as visualizações em strings em vez de convertê-las diretamente?
Renderizar views MVC em strings oferece diversas vantagens importantes:
- Contexto de Autenticação: As visualizações são renderizadas dentro do contexto do usuário autenticado
- Toda a Pilha MVC: Todos os recursos MVC funcionam incluindo
HtmlHelper,UrlHelper, e auxíliosViewBag - Suporte a Layout: Páginas principais e layouts são renderizados corretamente
- Vinculação de Modelo: Modelos de visualização complexos funcionam sem problemas
- Filtros de ação : Os filtros de segurança e de registro são executados normalmente.
Quais são os benefícios dessa solução alternativa para o MVC?
A abordagem de renderização de strings do MVC oferece:
- Segurança: Não é necessário expor URLs internos ou contornar autenticação
- Desempenho: Evite solicitações HTTP adicionais
- Consistência: Saída idêntica ao que os usuários veem nos navegadores
- Flexibilidade: Modifique o HTML antes da conversão para PDF
- Testes : Geração fácil de HTML para testes unitários
Como faço para passar modelos para a visualização renderizada?
Aqui está um exemplo completo com um modelo complexo:
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");
}
}Antes de implementar qualquer solução de autenticação, certifique-se de ter instalado o IronPDF corretamente e configurado suas chaves de licença.
Pronto para ver o que mais você pode fazer? Visite nossa página de tutoriais: Converter PDFs .
RenderDelay
Perguntas frequentes
Como posso converter HTML para PDF quando o conteúdo está protegido por um formulário de login?
O IronPDF oferece várias abordagens para converter HTML em PDF com autenticação de login. Você pode usar a API ChromeHttpLoginCredentials para autenticação de rede TLS ou baixar o conteúdo HTML usando System.Net.WebClient ou HttpClient com os cabeçalhos de autenticação apropriados antes de convertê-lo para PDF com o IronPDF.
O que é ChromeHttpLoginCredentials e como posso usá-lo?
ChromeHttpLoginCredentials é a API do IronPDF para lidar com autenticação de rede. Você pode usá-la definindo a propriedade LoginCredentials em ChromePdfRenderer com seu nome de usuário e senha, permitindo que o IronPDF autentique automaticamente ao renderizar URLs protegidas por senha em PDF.
Posso lidar com logins baseados em formulários HTML para conversão em PDF?
Sim, o IronPDF suporta logins baseados em formulários HTML. A abordagem recomendada é usar System.Net.WebClient ou HttpClient para lidar com o processo de login, baixar o conteúdo HTML autenticado e, em seguida, usar o método RenderHtmlAsPdf do IronPDF para converter o HTML baixado em PDF.
Como faço para baixar recursos HTML, como imagens e folhas de estilo, de páginas autenticadas?
Você pode usar o HtmlAgilityPack para analisar o HTML baixado e extrair URLs de recursos como imagens e folhas de estilo. Em seguida, use o System.Net.WebClient para baixar cada recurso com os mesmos cabeçalhos de autenticação antes de converter o pacote HTML completo em PDF com o IronPDF.
Qual a melhor prática para lidar com tokens ou cabeçalhos de autenticação?
Ao usar o IronPDF com tokens de autenticação, baixe o HTML usando o HttpClient ou o WebClient com seus cabeçalhos de autenticação (como tokens Bearer). Depois de ter o conteúdo HTML autenticado na memória ou salvo em disco, use o ChromePdfRenderer do IronPDF para convertê-lo em PDF.
Existe alguma solução alternativa para a autenticação de login do MVC?
Sim, o IronPDF oferece soluções alternativas para cenários de autenticação de login MVC. A abordagem recomendada é primeiro autenticar e baixar o conteúdo HTML usando clientes HTTP .NET padrão e, em seguida, passar o HTML autenticado diretamente para o mecanismo de renderização do IronPDF, em vez de deixar o IronPDF lidar com a autenticação.
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 é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
