Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Usando o IronPDF
  4. Abrir PDF no visualizador padrão em C#
USANDO O IRONPDF

Abrir PDF no visualizador padrão em C# com IronPDF (.NET 10)

Curtis Chau
Curtis Chau
Atualizado:

Abrir um PDF no visualizador padrão é uma tarefa comum no desenvolvimento de aplicações .NET . Após gerar arquivos PDF programaticamente com o IronPDF , muitas vezes é necessário exibi-los aos usuários imediatamente no aplicativo padrão escolhido por eles, como o Adobe Acrobat ou o Microsoft Edge. Este guia mostra passo a passo como gerar arquivos PDF usando o IronPDF e abri-los automaticamente no Windows usando System.Diagnostics.Process.Start.

A combinação dos poderosos recursos de conversão de HTML para PDF do IronPDF com o método de inicialização simples Process cria um fluxo de trabalho prático para criar e exibir arquivos PDF profissionais no aplicativo padrão configurado no computador do usuário.

Como instalar o IronPDF em um projeto .NET ?

Antes de gerar ou abrir qualquer PDF, você precisa ter o IronPDF instalado em seu projeto. Utilize o Console do Gerenciador de Pacotes NuGet ou a CLI do .NET :

Install-Package IronPdf
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

Após a instalação, adicione sua chave de licença ou inicie com um teste gratuito para habilitar todas as funcionalidades. A documentação do IronPDF aborda todas as opções de configuração em detalhes, incluindo a instalação via NuGet .

Após a instalação, você terá acesso ao conjunto completo de recursos do IronPDF , incluindo conversão de HTML para PDF, renderização de URLs, mesclagem de PDFs, marca d'água, assinatura digital e muito mais.

Como gerar e abrir um arquivo PDF?

A abordagem mais simples envolve três etapas:

  1. Crie um documento PDF com o IronPDF.
  2. Salve o arquivo em um diretório.
  3. Abra o PDF no aplicativo padrão usando Process.Start.

Aqui está um exemplo completo e funcional que você pode experimentar no Visual Studio com um novo projeto de Aplicativo de Console:

using IronPdf;
using System.Diagnostics;

// Create a new PDF renderer
var renderer = new ChromePdfRenderer();

// Generate PDF from HTML content
var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
        <body>
            <h1>Invoice #12345</h1>
            <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
            <table>
                <tr><td>Product</td><td>Price</td></tr>
                <tr><td>IronPDF License</td><td>$299</td></tr>
            </table>
        </body>
    </html>");

// Save the PDF to a file
string outputPath = "invoice.pdf";
pdf.SaveAs(outputPath);

// Open the PDF in the default viewer
Process.Start(new ProcessStartInfo
{
    FileName = outputPath,
    UseShellExecute = true
});
using IronPdf;
using System.Diagnostics;

// Create a new PDF renderer
var renderer = new ChromePdfRenderer();

// Generate PDF from HTML content
var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
        <body>
            <h1>Invoice #12345</h1>
            <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
            <table>
                <tr><td>Product</td><td>Price</td></tr>
                <tr><td>IronPDF License</td><td>$299</td></tr>
            </table>
        </body>
    </html>");

// Save the PDF to a file
string outputPath = "invoice.pdf";
pdf.SaveAs(outputPath);

// Open the PDF in the default viewer
Process.Start(new ProcessStartInfo
{
    FileName = outputPath,
    UseShellExecute = true
});
Imports IronPdf
Imports System.Diagnostics

' Create a new PDF renderer
Dim renderer As New ChromePdfRenderer()

' Generate PDF from HTML content
Dim pdf = renderer.RenderHtmlAsPdf("
    <html>
        <body>
            <h1>Invoice #12345</h1>
            <p>Generated on: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
            <table>
                <tr><td>Product</td><td>Price</td></tr>
                <tr><td>IronPDF License</td><td>$299</td></tr>
            </table>
        </body>
    </html>")

' Save the PDF to a file
Dim outputPath As String = "invoice.pdf"
pdf.SaveAs(outputPath)

' Open the PDF in the default viewer
Process.Start(New ProcessStartInfo With {
    .FileName = outputPath,
    .UseShellExecute = True
})
$vbLabelText   $csharpLabel

Este código primeiro cria uma instância de ChromePdfRenderer, que é a classe principal do IronPDF para converter HTML em PDF. O método RenderHtmlAsPdf converte a string HTML em um objeto de documento PDF. Para mais informações sobre essa abordagem, consulte o guia de conversão de HTML para PDF do IronPDF .

Após salvar o PDF usando SaveAs, o código usa Process.Start com ProcessStartInfo para abrir o arquivo no visualizador de PDF padrão. A configuração principal aqui é UseShellExecute = true, que instrui o Windows a abrir o arquivo PDF com seu aplicativo padrão.

Saída

Conforme mostrado na imagem abaixo, o IronPDF gera com sucesso o arquivo PDF e o exibe usando o visualizador padrão configurado no sistema — neste caso, o Opera GX.

Como abrir PDFs no visualizador padrão em C#: Figura 1 - PDF exibido usando o visualizador padrão

Por que declarações de alto nível?

Com o .NET 10 e as versões modernas do C#, as instruções de nível superior eliminam a necessidade de um wrapper de classe Program. O código é executado diretamente do início do arquivo, tornando os exemplos mais curtos e fáceis de acompanhar. Todos os exemplos neste guia utilizam esse padrão.

Por que o UseShellExecute é importante ao abrir documentos PDF?

No .NET Core e nas versões modernas do .NET (.NET 5 até .NET 10), o parâmetro UseShellExecute tem como valor padrão false. Sem definir explicitamente para true, seu aplicativo apresentará um erro ao tentar abrir um arquivo PDF.

using IronPdf;
using System.Diagnostics;
using System.IO;

// Generate a report with IronPDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;

var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/Main_Page");

// Save to temp directory for immediate viewing
string tempPath = Path.Combine(Path.GetTempPath(), $"URL_{Guid.NewGuid()}.pdf");
pdf.SaveAs(tempPath);

// IMPORTANT: Set UseShellExecute = true for .NET Core/5+
var startInfo = new ProcessStartInfo
{
    FileName = tempPath,
    UseShellExecute = true  // Required in .NET Core/5+ to open PDF in default viewer
};
Process.Start(startInfo);
using IronPdf;
using System.Diagnostics;
using System.IO;

// Generate a report with IronPDF
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;

var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/Main_Page");

// Save to temp directory for immediate viewing
string tempPath = Path.Combine(Path.GetTempPath(), $"URL_{Guid.NewGuid()}.pdf");
pdf.SaveAs(tempPath);

// IMPORTANT: Set UseShellExecute = true for .NET Core/5+
var startInfo = new ProcessStartInfo
{
    FileName = tempPath,
    UseShellExecute = true  // Required in .NET Core/5+ to open PDF in default viewer
};
Process.Start(startInfo);
Imports IronPdf
Imports System.Diagnostics
Imports System.IO

' Generate a report with IronPDF
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 50
renderer.RenderingOptions.MarginBottom = 50

Dim pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/Main_Page")

' Save to temp directory for immediate viewing
Dim tempPath As String = Path.Combine(Path.GetTempPath(), $"URL_{Guid.NewGuid()}.pdf")
pdf.SaveAs(tempPath)

' IMPORTANT: Set UseShellExecute = true for .NET Core/5+
Dim startInfo As New ProcessStartInfo With {
    .FileName = tempPath,
    .UseShellExecute = True  ' Required in .NET Core/5+ to open PDF in default viewer
}
Process.Start(startInfo)
$vbLabelText   $csharpLabel

A propriedade UseShellExecute determina se o shell do sistema operacional deve ser usado para iniciar o processo. Quando definido como true, o Windows usa o registro de associação de arquivos para determinar qual leitor de PDF padrão deve abrir o arquivo. Sem essa configuração nas versões modernas do .NET, você encontrará um erro de tempo de execução informando que o arquivo não pode ser aberto.

O uso de um diretório temporário com um nome de arquivo exclusivo (via Guid.NewGuid()) evita conflitos de arquivos ao gerar vários PDFs em rápida sucessão. A pasta temporária padrão é limpa automaticamente pelo sistema operacional em intervalos regulares.

Saída

Como abrir PDFs no visualizador padrão em C#: Figura 2 - URL para PDF gerada e exibida usando o visualizador padrão

Como lidar corretamente com caminhos de arquivos?

Caminhos de arquivos que contêm espaços e caracteres especiais exigem tratamento cuidadoso. Um diretório ausente ou um caminho malformado causará falha silenciosa ou lançará uma exceção antes mesmo de Process.Start ser alcançado. Eis uma abordagem que inclui a criação de diretórios e a verificação da existência de arquivos:

using IronPdf;
using System.Diagnostics;
using System.IO;

// Generate PDF from HTML file
var renderer = new ChromePdfRenderer();
var htmlContent = File.ReadAllText("template.html");
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Create output directory if it doesn't exist
string outputDir = @"C:\PDF Reports\Monthly";
Directory.CreateDirectory(outputDir);

// Build file path with timestamp
string fileName = $"Report_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";
string fullPath = Path.Combine(outputDir, fileName);

// Save the PDF
pdf.SaveAs(fullPath);

// Verify file exists before opening in default PDF viewer
if (File.Exists(fullPath))
{
    Process.Start(new ProcessStartInfo
    {
        FileName = fullPath,
        UseShellExecute = true
    });
}
else
{
    Console.WriteLine($"Error: PDF file not found at {fullPath}");
}
using IronPdf;
using System.Diagnostics;
using System.IO;

// Generate PDF from HTML file
var renderer = new ChromePdfRenderer();
var htmlContent = File.ReadAllText("template.html");
var pdf = renderer.RenderHtmlAsPdf(htmlContent);

// Create output directory if it doesn't exist
string outputDir = @"C:\PDF Reports\Monthly";
Directory.CreateDirectory(outputDir);

// Build file path with timestamp
string fileName = $"Report_{DateTime.Now:yyyyMMdd_HHmmss}.pdf";
string fullPath = Path.Combine(outputDir, fileName);

// Save the PDF
pdf.SaveAs(fullPath);

// Verify file exists before opening in default PDF viewer
if (File.Exists(fullPath))
{
    Process.Start(new ProcessStartInfo
    {
        FileName = fullPath,
        UseShellExecute = true
    });
}
else
{
    Console.WriteLine($"Error: PDF file not found at {fullPath}");
}
Imports IronPdf
Imports System.Diagnostics
Imports System.IO

' Generate PDF from HTML file
Dim renderer As New ChromePdfRenderer()
Dim htmlContent As String = File.ReadAllText("template.html")
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

' Create output directory if it doesn't exist
Dim outputDir As String = "C:\PDF Reports\Monthly"
Directory.CreateDirectory(outputDir)

' Build file path with timestamp
Dim fileName As String = $"Report_{DateTime.Now:yyyyMMdd_HHmmss}.pdf"
Dim fullPath As String = Path.Combine(outputDir, fileName)

' Save the PDF
pdf.SaveAs(fullPath)

' Verify file exists before opening in default PDF viewer
If File.Exists(fullPath) Then
    Process.Start(New ProcessStartInfo With {
        .FileName = fullPath,
        .UseShellExecute = True
    })
Else
    Console.WriteLine($"Error: PDF file not found at {fullPath}")
End If
$vbLabelText   $csharpLabel

Este código demonstra várias boas práticas: usar Path.Combine para construir caminhos de arquivo corretamente, independentemente do sistema operacional, criar diretórios conforme necessário com Directory.CreateDirectory e verificar a existência do arquivo antes de tentar abrir o PDF no visualizador padrão.

O carimbo de data/hora no nome do arquivo garante a exclusividade e fornece um registro claro de quando cada PDF foi gerado. Para opções avançadas de manipulação de PDFs, como mesclar ou dividir PDFs , adicionar marcas d'água , assinatura digital e cabeçalhos e rodapés , explore os guias práticos do IronPDF.

E quanto aos caminhos com espaços?

Path.Combine lida corretamente com espaços porque constrói caminhos como strings em vez de depender da expansão do shell. A classe ProcessStartInfo também lida corretamente com caminhos entre aspas quando UseShellExecute = true. Se você alguma vez passar um caminho diretamente para um comando do shell, sempre o coloque entre aspas duplas. Com Process.Start, a propriedade FileName não requer cotação manual.

Como aplicar as melhores práticas para garantir a prontidão na produção?

Para aplicações de produção, considere um fluxo de trabalho mais completo que lide com o ciclo de vida do PDF, incluindo tratamento de erros, opções de renderização configuráveis ​​e diretórios de saída previsíveis:

using IronPdf;
using IronPdf.Rendering;
using System.Diagnostics;
using System.IO;

static void GenerateAndDisplayPdf(string htmlContent, string documentName)
{
    try
    {
        // Configure IronPDF renderer with production settings
        var renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                PaperSize = PdfPaperSize.A4,
                PrintHtmlBackgrounds = true,
                CreatePdfFormsFromHtml = true
            }
        };

        // Generate the PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Use the user's Documents folder for better accessibility
        string documentsPath = Environment.GetFolderPath(
            Environment.SpecialFolder.MyDocuments);
        string pdfFolder = Path.Combine(documentsPath, "Generated PDFs");
        Directory.CreateDirectory(pdfFolder);
        string outputPath = Path.Combine(pdfFolder, $"{documentName}.pdf");

        pdf.SaveAs(outputPath);

        // Open PDF in default viewer without waiting for it to close
        Process.Start(new ProcessStartInfo
        {
            FileName = outputPath,
            UseShellExecute = true  // Essential for opening PDF in default application
        });

        Console.WriteLine($"PDF opened: {outputPath}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error generating or opening PDF: {ex.Message}");
    }
}
using IronPdf;
using IronPdf.Rendering;
using System.Diagnostics;
using System.IO;

static void GenerateAndDisplayPdf(string htmlContent, string documentName)
{
    try
    {
        // Configure IronPDF renderer with production settings
        var renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                PaperSize = PdfPaperSize.A4,
                PrintHtmlBackgrounds = true,
                CreatePdfFormsFromHtml = true
            }
        };

        // Generate the PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Use the user's Documents folder for better accessibility
        string documentsPath = Environment.GetFolderPath(
            Environment.SpecialFolder.MyDocuments);
        string pdfFolder = Path.Combine(documentsPath, "Generated PDFs");
        Directory.CreateDirectory(pdfFolder);
        string outputPath = Path.Combine(pdfFolder, $"{documentName}.pdf");

        pdf.SaveAs(outputPath);

        // Open PDF in default viewer without waiting for it to close
        Process.Start(new ProcessStartInfo
        {
            FileName = outputPath,
            UseShellExecute = true  // Essential for opening PDF in default application
        });

        Console.WriteLine($"PDF opened: {outputPath}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error generating or opening PDF: {ex.Message}");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System.Diagnostics
Imports System.IO

Module PdfGenerator

    Sub GenerateAndDisplayPdf(htmlContent As String, documentName As String)
        Try
            ' Configure IronPDF renderer with production settings
            Dim renderer As New ChromePdfRenderer With {
                .RenderingOptions = New ChromePdfRenderOptions With {
                    .PaperSize = PdfPaperSize.A4,
                    .PrintHtmlBackgrounds = True,
                    .CreatePdfFormsFromHtml = True
                }
            }

            ' Generate the PDF
            Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)

            ' Use the user's Documents folder for better accessibility
            Dim documentsPath As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)
            Dim pdfFolder As String = Path.Combine(documentsPath, "Generated PDFs")
            Directory.CreateDirectory(pdfFolder)
            Dim outputPath As String = Path.Combine(pdfFolder, $"{documentName}.pdf")

            pdf.SaveAs(outputPath)

            ' Open PDF in default viewer without waiting for it to close
            Process.Start(New ProcessStartInfo With {
                .FileName = outputPath,
                .UseShellExecute = True  ' Essential for opening PDF in default application
            })

            Console.WriteLine($"PDF opened: {outputPath}")
        Catch ex As Exception
            Console.WriteLine($"Error generating or opening PDF: {ex.Message}")
        End Try
    End Sub

End Module
$vbLabelText   $csharpLabel

Este exemplo inclui tratamento estruturado de erros e salva PDFs na pasta Documentos do usuário, que pode ser acessada independentemente de como o aplicativo é iniciado. Ele também configura o IronPDF com opções de renderização adequadas para documentos comerciais: tamanho de papel A4, impressão de fundo HTML ativada e criação automática de campos de formulário a partir de elementos de formulário HTML.

Você pode aprender mais sobre formulários PDF interativos e marcas d'água personalizadas na biblioteca de tutoriais do IronPDF .

O método não espera que o visualizador de PDF seja fechado, permitindo que seu aplicativo continue em execução enquanto o usuário visualiza o documento. De acordo com a documentação da Microsoft sobre Process.Start , essa abordagem garante o gerenciamento adequado de recursos e impede que seu aplicativo fique bloqueado em um processo de visualização de longa duração. A referência da classe ProcessStartInfo no Microsoft Learn fornece uma lista completa de propriedades que você pode configurar, incluindo estilo da janela, verbo (abrir, imprimir) e diretório de trabalho.

Como abrir PDFs no visualizador padrão em C#: Figura 3 - Fluxo de trabalho do processo de geração à visualização do PDF

Configurando as opções de renderização

A classe ChromePdfRenderOptions oferece controle preciso sobre o PDF de saída. As configurações comuns incluem:

  • Tamanho do papel -- Defina como PdfPaperSize.A4, Letter ou qualquer tamanho padrão.
  • PrintHtmlBackgrounds -- Renderiza cores e imagens de fundo a partir do HTML.
  • CreatePdfFormsFromHtml -- Converte elementos HTML <input> e <select> em campos de formulário PDF interativos.
  • MarginTop / MarginBottom / MarginLeft / MarginRight -- Controlam as margens da página em milímetros.

Essas configurações se aplicam igualmente, independentemente de você renderizar strings HTML, arquivos HTML locais ou URLs remotos.

Como extrair dados de PDFs gerados?

Depois de gerar e abrir um PDF, você também pode precisar ler o seu conteúdo novamente. O IronPDF suporta a extração de texto de arquivos PDF , o que é útil para registro, verificação ou processamento posterior.

Para documentos com muitas imagens, você também pode usar a conversão de PDF para imagem para renderizar páginas individuais como arquivos PNG ou JPEG. Isso é comum em fluxos de trabalho de geração de pré-visualizações e miniaturas.

Ambas as funcionalidades estão disponíveis através da mesma biblioteca IronPDF e não requerem dependências adicionais. A documentação completa da API do IronPDF fornece referências em nível de método para todas as operações de extração e conversão.

O que acontece se nenhum visualizador de PDF estiver instalado?

Se nenhum visualizador de PDF estiver instalado no computador de destino, o Windows exibirá uma caixa de diálogo solicitando ao usuário que selecione um aplicativo ou visite a Microsoft Store para encontrar um. Este é o comportamento padrão do Windows e está fora do controle de Process.Start.

Para lidar com isso de forma adequada em código de produção, você pode capturar o erro Win32Exception que Process.Start lança quando nenhum manipulador registrado é encontrado para a extensão de arquivo .pdf:

using System.ComponentModel;
using System.Diagnostics;

try
{
    Process.Start(new ProcessStartInfo
    {
        FileName = outputPath,
        UseShellExecute = true
    });
}
catch (Win32Exception ex) when (ex.NativeErrorCode == 1155)
{
    // Error 1155: No application associated with the file extension
    Console.WriteLine("No PDF viewer is installed. Please install a PDF reader such as Adobe Acrobat Reader.");
}
using System.ComponentModel;
using System.Diagnostics;

try
{
    Process.Start(new ProcessStartInfo
    {
        FileName = outputPath,
        UseShellExecute = true
    });
}
catch (Win32Exception ex) when (ex.NativeErrorCode == 1155)
{
    // Error 1155: No application associated with the file extension
    Console.WriteLine("No PDF viewer is installed. Please install a PDF reader such as Adobe Acrobat Reader.");
}
Imports System.ComponentModel
Imports System.Diagnostics

Try
    Process.Start(New ProcessStartInfo With {
        .FileName = outputPath,
        .UseShellExecute = True
    })
Catch ex As Win32Exception When ex.NativeErrorCode = 1155
    ' Error 1155: No application associated with the file extension
    Console.WriteLine("No PDF viewer is installed. Please install a PDF reader such as Adobe Acrobat Reader.")
End Try
$vbLabelText   $csharpLabel

O código de erro 1155 corresponde a ERROR_NO_ASSOCIATION, que o Windows retorna quando nenhum aplicativo está registrado para o tipo de arquivo. Ao detectar esse erro específico, você pode exibir uma mensagem útil em vez de causar uma falha no programa. A lista completa de códigos de erro do sistema Windows está documentada na referência de códigos de erro Win32 no Microsoft Learn.

Como escolher a abordagem certa para sua candidatura?

O método que você escolher para abrir um PDF depende do tipo de aplicativo que você está desenvolvendo:

Comparação de estratégias de abertura de PDF para diferentes tipos de aplicativos
Tipo de aplicação Abordagem recomendada Consideração fundamental
Aplicativo para console ou desktop Process.Start com UseShellExecute = true Simples, sem dependências adicionais.
Serviço do Windows Salvar em disco; notificar o usuário via IPC ou fila de mensagens. Os serviços são executados sem uma sessão de área de trabalho.
Aplicação Web (ASP.NET) Transmita o PDF como um arquivo para download ou diretamente no navegador. Process.Start não é válido em contextos de servidor web.
MAUI ou WinForms Process.Start ou controle de PDF incorporado A visualização integrada proporciona uma melhor experiência dentro do aplicativo.

Para aplicações web construídas com ASP.NET Core, não use Process.Start. O processo do servidor é executado em um ambiente sem interface gráfica e não pode abrir aplicativos de desktop. Em vez disso, retorne o PDF como um resultado de arquivo usando File() com o tipo MIME application/pdf e deixe o navegador lidar com a exibição.

Para aplicações de console e desktop, Process.Start com UseShellExecute = true continua sendo a opção mais simples e confiável.

ObserveNota: Se nenhum visualizador de PDF estiver instalado, o Windows poderá exibir uma caixa de diálogo solicitando que você selecione ou baixe um.

Pronto para começar a gerar e visualizar PDFs em sua aplicação .NET ? Comece com um teste gratuito para acessar todos os recursos ou consulte a página de licenciamento do IronPDF para encontrar o plano ideal para o seu projeto.

Perguntas frequentes

Como posso abrir um PDF no visualizador padrão usando C#?

Em C#, você pode abrir um PDF no visualizador padrão usando o IronPDF para gerar o PDF e o System.Diagnostics.Process.Start para abri-lo no aplicativo de PDF padrão do usuário.

O que é o IronPDF?

IronPDF é uma biblioteca .NET que permite aos desenvolvedores criar, editar e manipular arquivos PDF programaticamente dentro de seus aplicativos.

Quais são os requisitos de sistema para usar o IronPDF?

O IronPDF é compatível com qualquer aplicação .NET e funciona em plataformas Windows, macOS e Linux. Requer a instalação do .NET Framework ou .NET Core/5+.

O IronPDF consegue abrir PDFs no Adobe Acrobat por padrão?

Sim, o IronPDF pode gerar PDFs que são abertos no visualizador de PDF padrão definido pelo usuário, que pode ser o Adobe Acrobat, o Microsoft Edge ou qualquer outro aplicativo de visualização de PDF.

Como o System.Diagnostics.Process.Start funciona com o IronPDF?

O método System.Diagnostics.Process.Start é usado para abrir o arquivo PDF gerado no visualizador padrão. Depois que o IronPDF cria o arquivo, esse método inicia o aplicativo padrão associado a arquivos PDF para exibi-lo.

É possível editar arquivos PDF com o IronPDF?

Sim, o IronPDF permite editar arquivos PDF existentes, adicionando texto, imagens, anotações e muito mais antes de salvá-los ou exibi-los.

Quais linguagens de programação são suportadas pelo IronPDF?

O IronPDF é usado principalmente com C#, mas também pode ser integrado a projetos que utilizam VB.NET e outras linguagens compatíveis com .NET.

O IronPDF consegue automatizar a exibição de PDFs após a sua geração?

Sim, após gerar um PDF com o IronPDF, você pode automatizar sua exibição usando System.Diagnostics.Process.Start para abri-lo imediatamente no visualizador padrão do usuário.

Existem exemplos de código disponíveis para usar o IronPDF?

A documentação do IronPDF fornece vários exemplos de código para gerar e manipular PDFs, incluindo como abri-los no visualizador padrão usando C#.

Quais são alguns casos de uso comuns para o IronPDF?

Os casos de uso comuns do IronPDF incluem a geração de relatórios, faturas e outros documentos, a conversão de HTML para PDF e a automatização do processo de exibição de PDF em aplicações .NET.

O IronPDF é compatível com o .NET 10 e quais são os benefícios disso?

Sim. O IronPDF é totalmente compatível com o .NET 10, incluindo seus aprimoramentos de tempo de execução e linguagem. Usar o IronPDF com o .NET 10 permite que seus aplicativos se beneficiem de melhorias de desempenho, como alocação reduzida de memória heap, geração de PDF mais rápida e integração mais fluida com APIs e plataformas modernas.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

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 ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim