Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Korzystanie z IronPDF
  4. C# Otwórz plik PDF w domyślnej przeglądarce
KORZYSTANIE Z IRONPDF

C# Otwórz PDF w domyślnej przeglądarce z IronPDF (.NET 10)

Curtis Chau
Curtis Chau
Zaktualizowano:

Otwieranie pliku PDF w domyślnej przeglądarce jest częstym zadaniem podczas tworzenia aplikacji .NET. Po wygenerowaniu plików PDF programowo za pomocą IronPDF często trzeba je natychmiast wyświetlić użytkownikom w wybranej przez nich domyślnej aplikacji — takiej jak Adobe Acrobat lub Microsoft Edge. Ten przewodnik przeprowadzi Cię przez kolejne etapy tworzenia plików PDF przy użyciu IronPDF i automatycznego otwierania ich w systemie Windows za pomocą System.Diagnostics.Process.Start.

Połączenie potężnych możliwości konwersji HTML do PDF oferowanych przez IronPDF z prostą metodą uruchamiania Process tworzy praktyczny proces tworzenia i wyświetlania profesjonalnych plików PDF w domyślnej aplikacji skonfigurowanej na komputerze użytkownika.

Jak zainstalować IronPDF w projekcie .NET?

Przed wygenerowaniem lub otwarciem jakiegokolwiek pliku PDF należy zainstalować IronPDF w swoim projekcie. Użyj konsoli menedżera pakietów NuGet lub interfejsu CLI .NET:

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

Po instalacji dodaj klucz licencyjny lub rozpocznij bezpłatny okres próbny, aby uzyskać dostęp do pełnej funkcjonalności. Dokumentacja IronPDF szczegółowo opisuje wszystkie opcje konfiguracyjne, w tym instalację za pośrednictwem NuGet.

Po zainstalowaniu uzyskasz dostęp do pełnego zestawu funkcji IronPDF, w tym konwersji HTML na PDF, renderowania adresów URL, scalania plików PDF, dodawania znaków wodnych, podpisywania cyfrowego i wielu innych.

Jak wygenerować i otworzyć plik PDF?

Najprostsze podejście obejmuje trzy etapy:

  1. Utwórz dokument PDF za pomocą IronPDF.
  2. Zapisz plik w katalogu.
  3. Otwórz plik PDF w domyślnej aplikacji za pomocą Process.Start.

Oto kompletny przykład, który można wypróbować w Visual Studio w nowym projekcie aplikacji konsolowej:

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

Ten kod najpierw tworzy instancję ChromePdfRenderer, która jest podstawową klasą IronPDF służącą do konwersji HTML do formatu PDF. Metoda RenderHtmlAsPdf konwertuje ciąg znaków HTML na obiekt dokumentu PDF. Więcej informacji na temat tego podejścia można znaleźć w przewodniku IronPDF dotyczącym konwersji HTML do PDF.

Po zapisaniu pliku PDF za pomocą SaveAs kod wykorzystuje Process.Start wraz z ProcessStartInfo do otwarcia pliku w domyślnej przeglądarce PDF. Kluczowym ustawieniem jest tutaj UseShellExecute = true, które nakazuje systemowi Windows otwarcie pliku PDF za pomocą domyślnej aplikacji.

Wynik

Jak pokazano na poniższym obrazku, IronPDF z powodzeniem generuje plik PDF i wyświetla go przy użyciu domyślnej przeglądarki skonfigurowanej w systemie — w tym przypadku Opera GX.

Jak otwierać pliki PDF w domyślnej przeglądarce w języku C#: Rysunek 1 – Plik PDF wyświetlony w domyślnej przeglądarce

Dlaczego stwierdzenia najwyższego poziomu?

W .NET 10 i nowoczesnych wersjach C# instrukcje najwyższego poziomu eliminują potrzebę stosowania opakowania klasy Program. Kod uruchamia się bezpośrednio od początku pliku, dzięki czemu przykłady są krótsze i łatwiejsze do zrozumienia. Wszystkie przykłady w tym przewodniku wykorzystują ten schemat.

Dlaczego funkcja UseShellExecute ma znaczenie podczas otwierania dokumentów PDF?

W .NET Core i nowoczesnych wersjach .NET (od .NET 5 do .NET 10) domyślną wartością parametru UseShellExecute jest false. Jeśli nie ustawisz tego wyraźnie na true, Twoja aplikacja wyświetli błąd podczas próby uruchomienia pliku 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

Właściwość UseShellExecute określa, czy do uruchomienia procesu należy użyć powłoki systemu operacyjnego. Po ustawieniu opcji true system Windows korzysta z rejestru skojarzeń plików, aby określić, która domyślna przeglądarka PDF powinna otworzyć plik. Bez tego ustawienia w nowoczesnych wersjach .NET pojawi się błąd uruchomieniowy informujący, że plik nie może zostać otwarty.

Użycie katalogu tymczasowego z unikalną nazwą pliku (poprzez Guid.NewGuid()) zapobiega konfliktom plików podczas generowania wielu plików PDF w krótkich odstępach czasu. Domyślny folder tymczasowy jest automatycznie czyszczony przez system operacyjny zgodnie z ustalonym harmonogramem.

Wynik

Jak otwierać pliki PDF w domyślnej przeglądarce w języku C#: Rysunek 2 – Adres URL do pliku PDF wygenerowanego i wyświetlonego przy użyciu domyślnej przeglądarki

Jak poprawnie obsługiwać ścieżki do plików?

Ścieżki plików zawierające spacje i znaki specjalne wymagają ostrożnego traktowania. Brakujący katalog lub nieprawidłowa ścieżka spowoduje cichą awarię lub wygeneruje wyjątek, zanim zostanie osiągnięty Process.Start. Oto podejście obejmujące tworzenie katalogów i sprawdzanie istnienia plików:

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

Ten kod ilustruje kilka najlepszych praktyk: użycie Path.Combine do poprawnego tworzenia ścieżek plików niezależnie od systemu operacyjnego, tworzenie katalogów w razie potrzeby za pomocą Directory.CreateDirectory oraz sprawdzanie istnienia pliku przed próbą otwarcia pliku PDF w domyślnej przeglądarce.

Sygnatura czasowa w nazwie pliku zapewnia unikalność i stanowi jasny zapis daty utworzenia każdego pliku PDF. Aby uzyskać informacje na temat zaawansowanych opcji edycji plików PDF, takich jak łączenie lub dzielenie plików, dodawanie znaków wodnych, podpisów cyfrowych oraz nagłówków i stopek, zapoznaj się z poradnikami IronPDF.

A co z ścieżkami zawierającymi spacje?

Path.Combine poprawnie obsługuje spacje, ponieważ tworzy ścieżki jako ciągi znaków, zamiast polegać na rozszerzaniu przez powłokę. Klasa ProcessStartInfo obsługuje również poprawnie ścieżki w cudzysłowie, gdy UseShellExecute = true. Jeśli kiedykolwiek przekazujesz ścieżkę do polecenia powłoki bezpośrednio, zawsze otaczaj ją podwójnymi cudzysłowami. W przypadku Process.Start właściwość FileName nie wymaga ręcznego umieszczania w cudzysłowie.

Jak stosować najlepsze praktyki gotowe do wdrożenia w środowisku produkcyjnym?

W przypadku aplikacji produkcyjnych warto rozważyć bardziej kompletny proces, który obsługuje cykl życia plików PDF wraz z obsługą błędów, konfigurowalnymi opcjami renderowania i przewidywalnymi katalogami wyjściowymi:

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

Ten przykład zawiera ustrukturyzowaną obsługę błędów i zapisuje pliki PDF w folderze Dokumenty użytkownika, który jest dostępny niezależnie od sposobu uruchomienia aplikacji. Konfiguruje również IronPDF z opcjami renderowania odpowiednimi dla dokumentów biznesowych: format papieru A4, włączone drukowanie tła HTML oraz automatyczne tworzenie pól formularza z elementów formularza HTML.

Więcej informacji na temat interaktywnych formularzy PDF i niestandardowych znaków wodnych można znaleźć w bibliotece porad IronPDF.

Metoda ta nie czeka na zamknięcie przeglądarki PDF, co pozwala aplikacji na dalsze działanie podczas przeglądania dokumentu przez użytkownika. Zgodnie z dokumentacją Microsoftu dotyczącą Process.Start takie podejście zapewnia właściwe zarządzanie zasobami i zapobiega blokowaniu aplikacji przez długotrwały proces przeglądarki. Dokumentacja klasy ProcessStartInfo w serwisie Microsoft Learn zawiera pełną listę właściwości, które można skonfigurować, w tym styl okna, czasownik (otwórz, PRINT) oraz katalog roboczy.

Jak otwierać pliki PDF w domyślnej przeglądarce w języku C#: Rysunek 3 – Proces generowania i przeglądania plików PDF

Konfigurowanie opcji renderowania

Klasa ChromePdfRenderOptions zapewnia precyzyjną kontrolę nad wyjściowym plikiem PDF. Typowe ustawienia obejmują:

  • PaperSize -- Ustaw na PdfPaperSize.A4, Letter lub dowolny standardowy rozmiar.
  • PrintHtmlBackgrounds — renderuje kolory tła i obrazy z kodu HTML.
  • CreatePdfFormsFromHtml — Konwertuje elementy HTML <input> i <select> na interaktywne pola formularzy PDF.
  • MarginTop / MarginBottom / MarginLeft / MarginRight -- Kontroluje marginesy strony w milimetrach.

Ustawienia te mają zastosowanie niezależnie od tego, czy renderujesz ciągi HTML, lokalne pliki HTML czy zdalne adresy URL.

Jak wyodrębnić dane z wygenerowanych plików PDF?

Po wygenerowaniu i otwarciu pliku PDF może być również konieczne ponowne odczytanie jego zawartości. IronPDF obsługuje wyodrębnianie tekstu z plików PDF, co jest przydatne do rejestrowania, weryfikacji lub dalszego przetwarzania.

W przypadku dokumentów zawierających dużo obrazów można również skorzystać z konwersji PDF na obraz, aby renderować poszczególne strony jako pliki PNG lub JPEG. Jest to powszechne w generowaniu podglądów i procesach tworzenia miniatur.

Obie funkcje są dostępne za pośrednictwem tej samej biblioteki IronPDF i nie wymagają dodatkowych zależności. Pełna dokumentacja API IronPDF zawiera opisy metod dla wszystkich operacji wyodrębniania i konwersji.

Co się stanie, jeśli nie ma zainstalowanej przeglądarki PDF?

Jeśli na komputerze docelowym nie jest zainstalowana przeglądarka plików PDF, system Windows wyświetli okno dialogowe z prośbą o wybranie aplikacji lub odwiedzenie sklepu Microsoft Store w celu jej znalezienia. Jest to standardowe zachowanie systemu Windows i pozostaje poza kontrolą Process.Start.

Aby elegancko obsłużyć to w kodzie produkcyjnym, można przechwycić Win32Exception, które Process.Start wyrzuca, gdy nie znaleziono zarejestrowanego obsługi dla rozszerzenia pliku .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

Kod błędu 1155 odpowiada ERROR_NO_ASSOCIATION, który system Windows zwraca, gdy dla danego typu pliku nie jest zarejestrowana żadna aplikacja. Wykrycie tego konkretnego błędu pozwala wyświetlić pomocny komunikat zamiast powodować awarię. Pełna lista kodów błędów systemu Windows jest udokumentówana w przewodniku po kodach błędów Win32 na platformie Microsoft Learn.

Jak wybrać odpowiednie podejście do swojej aplikacji?

Metoda otwierania pliku PDF zależy od typu tworzonej aplikacji:

Porównanie strategii otwierania plików PDF dla różnych typów aplikacji
Typ aplikacji Zalecane podejście Kluczowe kwestie
Aplikacja konsolowa lub desktopowa Process.Start z UseShellExecute = true Proste, bez dodatkowych zależności
Usługa Windows Zapisz na dysku; powiadom użytkownika za pośrednictwem IPC lub kolejki komunikatów Usługi działają bez sesji pulpitu
Aplikacja internetowa (ASP.NET) Przesyłaj strumieniowo pliki PDF jako pliki do pobrania lub bezpośrednio w przeglądarce Process.Start nie jest prawidłowy w kontekście serwerów internetowych
MAUI lub WinForms Process.Start lub wbudowany kontrolka PDF Wbudowana funkcja podglądu zapewnia lepsze wrażenia podczas korzystania z aplikacji

W przypadku aplikacji internetowych zbudowanych przy użyciu ASP.NET Core nie należy używać Process.Start. Proces serwera działa w środowisku bezinterfejsowym i nie może otwierać aplikacji desktopowych. Zamiast tego zwróć plik PDF jako wynik pliku przy użyciu File() z typem MIME application/pdf i pozwól przeglądarce zająć się wyświetlaniem.

W przypadku aplikacji konsolowych i desktopowych Process.Start z UseShellExecute = true pozostaje najprostszą i najbardziej niezawodną opcją.

Zwróć uwagęUwaga: Jeśli nie masz zainstalowanej przeglądarki plików PDF, system Windows może wyświetlić okno dialogowe z prośbą o wybranie lub pobranie takiej przeglądarki.

Chcesz rozpocząć generowanie i przeglądanie plików PDF w swojej aplikacji .NET? Zacznij od bezpłatnej wersji próbnej, aby uzyskać dostęp do pełnego zestawu funkcji, lub zapoznaj się ze stroną licencyjną IronPDF, aby znaleźć plan odpowiedni dla swojego projektu.

Często Zadawane Pytania

Jak otworzyć plik PDF w domyślnej przeglądarce za pomocą języka C#?

W języku C# można otworzyć plik PDF w domyślnej przeglądarce, używając biblioteki IronPDF do wygenerowania pliku PDF oraz klasy System.Diagnostics.Process.Start do otwarcia go w domyślnej aplikacji do obsługi plików PDF użytkownika.

Czym jest IronPDF?

IronPDF to biblioteka .NET, która pozwala programistom tworzyć, edytować i przetwarzać pliki PDF programowo w ramach ich aplikacji.

Jakie są wymagania systemowe dotyczące korzystania z IronPDF?

IronPDF jest kompatybilny z każdą aplikacją .NET i działa na platformach Windows, macOS oraz Linux. Wymaga zainstalowania .NET Framework lub .NET Core/5+.

Czy IronPDF domyślnie otwiera pliki PDF w programie Adobe Acrobat?

Tak, IronPDF może generować pliki PDF, które otwierają się w domyślnej przeglądarce PDF ustawionej przez użytkownika, którą może być Adobe Acrobat, Microsoft Edge lub dowolna inna aplikacja do przeglądania plików PDF.

Jak działa System.Diagnostics.Process.Start z IronPDF?

Metoda System.Diagnostics.Process.Start służy do otwierania wygenerowanego pliku PDF w domyślnej przeglądarce. Po utworzeniu pliku przez IronPDF metoda ta uruchamia domyślną aplikację powiązaną z plikami PDF w celu wyświetlenia go.

Czy można edytować pliki PDF za pomocą IronPDF?

Tak, IronPDF umożliwia edycję istniejących plików PDF poprzez dodawanie tekstu, obrazów, adnotacji i innych elementów przed ich zapisaniem lub wyświetleniem.

Jakie języki programowania są obsługiwane przez IronPDF?

IronPDF jest używany głównie z językiem C#, ale można go również zintegrować z projektami wykorzystującymi VB.NET i inne języki obsługiwane przez platformę .NET.

Czy IronPDF może zautomatyzować wyświetlanie plików PDF po ich wygenerowaniu?

Tak, po wygenerowaniu pliku PDF za pomocą IronPDF można zautomatyzować jego wyświetlanie, używając System.Diagnostics.Process.Start, aby otworzyć go natychmiast w domyślnej przeglądarce użytkownika.

Czy są dostępne przykłady kodu dotyczące korzystania z IronPDF?

Dokumentacja IronPDF zawiera różne przykłady kodu służącego do generowania i manipulowania plikami PDF, w tym instrukcje dotyczące otwierania ich w domyślnej przeglądarce przy użyciu języka C#.

Jakie są typowe zastosowania IronPDF?

Typowe zastosowania IronPDF obejmują generowanie raportów, faktur i innych dokumentów, konwersję HTML do PDF oraz automatyzację procesu wyświetlania plików PDF w aplikacjach .NET.

Czy IronPDF jest kompatybilny z .NET 10 i jakie korzyści to przynosi?

Tak. IronPDF jest w pełni kompatybilny z .NET 10, w tym z jego ulepszeniami środowiska uruchomieniowego i języka. Korzystanie z IronPDF w środowisku .NET 10 pozwala aplikacjom czerpać korzyści z poprawy wydajności, takich jak zmniejszone alokacje pamięci, szybsze generowanie plików PDF oraz płynniejsza integracja z nowoczesnymi interfejsami API i platformami.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie