Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF nutzen
  4. C# Öffnen Sie PDF im Standardbetrachter
IRONPDF NUTZEN

Wie man PDF-Dateien in VB.NET zusammenführt

Curtis Chau
Curtis Chau
Aktualisiert:

Das Öffnen einer PDF-Datei im Standard-Viewer ist eine häufige Aufgabe bei der .NET -Anwendungsentwicklung. Nachdem Sie mit IronPDF programmatisch PDF-Dateien erstellt haben, müssen Sie diese häufig den Benutzern sofort in ihrer gewählten Standardanwendung anzeigen – beispielsweise Adobe Acrobat oder Microsoft Edge. Dieser Leitfaden führt Sie durch die Schritte zur Erstellung von PDF-Dateien mithilfe von IronPDF und deren automatischem Öffnen in Windows mit System.Diagnostics.Process.Start.

Die Kombination aus den leistungsstarken HTML-zu-PDF-Konvertierung von IronPDF und der einfachen Process Startmethode schafft einen praktischen Workflow zum Erstellen und Anzeigen professioneller PDF-Dateien in der auf einem Benutzergerät konfigurierten Standardanwendung.

Wie installiert man IronPDF in einem .NET -Projekt?

Bevor Sie eine PDF-Datei generieren oder öffnen können, müssen Sie IronPDF in Ihrem Projekt installieren. Verwenden Sie entweder die NuGet Paket-Manager-Konsole oder die .NET Befehlszeilenschnittstelle:

Install-Package IronPdf

Nach der Installation fügen Sie Ihren Lizenzschlüssel hinzu oder starten Sie mit einer kostenlosen Testversion , um den vollen Funktionsumfang zu aktivieren. Die IronPDF-Dokumentation behandelt alle Konfigurationsoptionen im Detail, einschließlich der Installation über NuGet.

Nach der Installation stehen Ihnen alle Funktionen von IronPDF zur Verfügung, darunter HTML-zu-PDF-Konvertierung, URL-Rendering, PDF-Zusammenführung, Wasserzeichen, digitale Signatur und vieles mehr.

Wie erstellt und öffnet man eine PDF-Datei?

Der einfachste Ansatz umfasst drei Schritte:

  1. Erstellen Sie ein PDF-Dokument mit IronPDF.
  2. Speichern Sie die Datei in einem Verzeichnis.
  3. Öffnen Sie das PDF in der Standardanwendung mit Process.Start.

Hier ist ein vollständiges, lauffähiges Beispiel, das Sie in Visual Studio mit einem neuen Konsolenanwendungsprojekt ausprobieren können:

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

Dieser Code erstellt zunächst eine ChromePdfRenderer Instanz, die die primäre Klasse von IronPDF für die Konvertierung von HTML zu PDF ist. Die RenderHtmlAsPdf Methode wandelt den HTML-String in ein PDF-Dokumentobjekt um. Mehr zu diesem Ansatz finden Sie im HTML-zu-PDF-Leitfaden von IronPDF .

Nach dem Speichern des PDFs mit SaveAs verwendet der Code Process.Start mit ProcessStartInfo, um die Datei im Standard-PDF-Viewer zu öffnen. Die wichtigste Einstellung hier ist UseShellExecute = true, die Windows anweist, die PDF-Datei mit seiner Standardanwendung zu öffnen.

Ausgabe

Wie im Bild unten zu sehen ist, generiert IronPDF erfolgreich die PDF-Datei und zeigt sie mit dem auf dem System konfigurierten Standard-Viewer an – in diesem Fall Opera GX.

Wie man PDFs im Standard-Viewer in C# öffnet: Abbildung 1 - PDF wird im Standard-Viewer angezeigt

Warum Top-Level-Statements?

Mit .NET 10 und modernen C#-Versionen eliminieren Top-Level-Angaben die Notwendigkeit für eine Program Klasseneinbindung. Der Code wird direkt vom Anfang der Datei ausgeführt, wodurch die Beispiele kürzer und leichter verständlich werden. Alle Beispiele in diesem Leitfaden verwenden dieses Muster.

Warum ist UseShellExecute beim Öffnen von PDF-Dokumenten wichtig?

In .NET Core und modernen .NET-Versionen (.NET 5 bis .NET 10) ist der UseShellExecute Parameter standardmäßig auf false gesetzt. Ohne ihn explizit auf true zu setzen, wirft Ihre Anwendung einen Fehler, wenn versucht wird, eine PDF-Datei zu starten.

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

Die UseShellExecute Eigenschaft bestimmt, ob das Betriebssystem-Shell verwendet werden soll, um den Prozess zu starten. Wenn sie auf true gesetzt ist, verwendet Windows das Dateizuordnungsregister, um zu bestimmen, welcher Standard-PDF-Reader die Datei öffnen soll. Ohne diese Einstellung in modernen .NET-Versionen werden Sie auf einen Laufzeitfehler stoßen, der besagt, dass die Datei nicht geöffnet werden kann.

Die Verwendung eines temporären Verzeichnisses mit einem eindeutigen Dateinamen (über Guid.NewGuid()) verhindert Dateikonflikte beim Erstellen mehrerer PDFs in schneller Folge. Der standardmäßige temporäre Ordner wird vom Betriebssystem regelmäßig automatisch geleert.

Ausgabe

Wie man PDFs im Standard-Viewer in C# öffnet: Abbildung 2 - URL zu PDF generiert und verwendet den Standard-Viewer

Wie geht man korrekt mit Dateipfaden um?

Dateipfade, die Leerzeichen und Sonderzeichen enthalten, erfordern besondere Sorgfalt. Ein fehlendes Verzeichnis oder ein fehlerhafter Pfad wird unbemerkt scheitern oder eine Ausnahme werfen, bevor Process.Start jemals erreicht wird. Hier ist ein Ansatz, der die Erstellung von Verzeichnissen und die Überprüfung der Existenz von Dateien umfasst:

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

Dieser Code zeigt mehrere bewährte Verfahren: die Verwendung von Path.Combine zur korrekten Erstellung von Dateipfaden unabhängig vom Betriebssystem, das Erstellen von Verzeichnissen nach Bedarf mit Directory.CreateDirectory und die Überprüfung der Dateiexistenz, bevor versucht wird, das PDF im Standard-Viewer zu öffnen.

Der Zeitstempel im Dateinamen sorgt für Einzigartigkeit und bietet einen klaren Nachweis darüber, wann jedes PDF erzeugt wurde. Für fortgeschrittene PDF-Bearbeitungsoptionen wie das Zusammenführen oder Aufteilen von PDFs , das Hinzufügen von Wasserzeichen , digitale Signaturen sowie Kopf- und Fußzeilen , konsultieren Sie die Anleitungen von IronPDF.

Wie sieht es mit Wegen mit Zwischenräumen aus?

Path.Combine bewältigt Leerzeichen korrekt, da es Pfade als Strings erstellt, anstatt sich auf die Shell-Expansion zu verlassen. Die ProcessStartInfo Klasse geht auch korrekt mit zitierten Pfaden um, wenn UseShellExecute = true. Wenn Sie jemals einen Pfad direkt an einen Shell-Befehl übergeben, setzen Sie ihn immer in doppelte Anführungszeichen. Mit Process.Start erfordert die FileName Eigenschaft kein manuelles Zitieren.

Wie wendet man bewährte Verfahren für die Produktionsreife an?

Für Produktionsanwendungen empfiehlt sich ein umfassenderer Workflow, der den PDF-Lebenszyklus mit Fehlerbehandlung, konfigurierbaren Rendering-Optionen und vorhersehbaren Ausgabeverzeichnissen abdeckt:

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

Dieses Beispiel beinhaltet eine strukturierte Fehlerbehandlung und speichert PDFs im Dokumentenordner des Benutzers, auf den unabhängig von der Art des Anwendungsstarts zugegriffen werden kann. Außerdem konfiguriert es IronPDF mit Rendering-Optionen, die für Geschäftsdokumente geeignet sind: A4-Papierformat, aktivierter HTML-Hintergrunddruck und automatische Formularfelderstellung aus HTML-Formularelementen.

Weitere Informationen zu interaktiven PDF-Formularen und benutzerdefinierten Wasserzeichen finden Sie in der IronPDF How-to-Bibliothek.

Die Methode wartet nicht auf das Schließen des PDF-Viewers, sodass Ihre Anwendung weiterlaufen kann, während der Benutzer das Dokument betrachtet. Laut Microsofts Dokumentation zu Process.Start gewährleistet dieser Ansatz eine ordnungsgemäße Ressourcenverwaltung und verhindert, dass Ihre Anwendung durch einen langlaufenden Viewer-Prozess blockiert wird. Die Klassenreferenz ProcessStartInfo auf Microsoft Learn bietet eine vollständige Liste der konfigurierbaren Eigenschaften, einschließlich Fensterstil, Verb (Öffnen, Drucken) und Arbeitsverzeichnis.

Wie man PDFs im Standard-Viewer in C# öffnet: Abbildung 3 - PDF-Erstellung zum anzeigen Prozess-Workflow

Rendereinstellungen konfigurieren

Die ChromePdfRenderOptions Klasse gibt Ihnen eine feinkörnige Kontrolle über das Ausgabe-PDF. Übliche Einstellungen sind:

  • PaperSize -- Setzen Sie auf PdfPaperSize.A4, Letter oder jede Standardgröße.
  • PrintHtmlBackgrounds -- Rendert Hintergrundfarben und -bilder aus dem HTML-Code.
  • CreatePdfFormsFromHtml -- Wandelt HTML <input> und <select> Elemente in interaktive PDF-Formularfelder um.
  • MarginTop / MarginBottom / MarginLeft / MarginRight -- Seitenränder in Millimetern steuern.

Diese Einstellungen gelten gleichermaßen für das Rendern von HTML-Zeichenketten, lokalen HTML-Dateien oder Remote-URLs.

Wie extrahiert man Daten aus generierten PDFs?

Sobald Sie eine PDF-Datei erstellt und geöffnet haben, müssen Sie möglicherweise auch deren Inhalt lesen. IronPDF unterstützt die Textextraktion aus PDF-Dateien , was für Protokollierung, Überprüfung oder Weiterverarbeitung nützlich ist.

Bei Dokumenten mit vielen Bildern können Sie auch die PDF-zu-Bild-Konvertierung nutzen, um einzelne Seiten als PNG- oder JPEG-Dateien zu speichern. Dies ist ein häufiges Problem bei der Erstellung von Vorschaubildern und Miniaturansichten.

Beide Funktionen sind über dieselbe IronPDF Bibliothek verfügbar und erfordern keine zusätzlichen Abhängigkeiten. Die vollständige IronPDF API-Dokumentation enthält Methodenreferenzen für alle Extraktions- und Konvertierungsoperationen.

Was passiert, wenn kein PDF-Viewer installiert ist?

Wenn auf dem Zielrechner kein PDF-Viewer installiert ist, zeigt Windows ein Dialogfeld an, in dem der Benutzer aufgefordert wird, eine Anwendung auszuwählen oder den Microsoft Store aufzusuchen, um eine solche zu finden. Dies ist Standardverhalten unter Windows und liegt außerhalb der Kontrolle von Process.Start.

Um dies in Produktionscode elegant zu handhaben, können Sie den Win32Exception abfangen, den Process.Start wirft, wenn kein registrierter Handler für die .pdf Dateierweiterung gefunden wird:

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

Der Fehlercode 1155 entspricht ERROR_NO_ASSOCIATION, den Windows zurückgibt, wenn keine Anwendung für den Dateityp registriert ist. Durch das Abfangen dieses spezifischen Fehlers können Sie eine hilfreiche Meldung anzeigen, anstatt einen Absturz zu verursachen. Die vollständige Liste der Windows-Systemfehlercodes ist in der Win32-Fehlercodereferenz auf Microsoft Learn dokumentiert.

Wie wählen Sie den richtigen Ansatz für Ihre Anwendung?

Die Methode, die Sie zum Öffnen einer PDF-Datei wählen, hängt von der Art der Anwendung ab, die Sie entwickeln:

Vergleich der PDF-Öffnungsstrategien für verschiedene Anwendungstypen
Anwendungsart Empfohlene Vorgehensweise Wichtiger Aspekt
Konsolen- oder Desktop-App Process.Start mit UseShellExecute = true Einfach, keine zusätzlichen Abhängigkeiten
Windows-Dienst Auf Festplatte speichern; Benutzer über IPC oder Nachrichtenwarteschlange benachrichtigen. Die Dienste laufen ohne Desktop-Sitzung
Webanwendung (ASP.NET) PDF als Datei herunterladen oder direkt im Browser streamen Process.Start ist in Webserverkontexten ungültig.
MAUI oder WinForms Prozess.Start oder eingebettetes PDF-Steuerelement Die eingebettete Ansicht bietet ein besseres In-App-Erlebnis

Für Webanwendungen, die mit ASP.NET Core erstellt wurden, verwenden Sie nicht Process.Start. Der Serverprozess läuft in einer Headless-Umgebung und kann keine Desktop-Anwendungen öffnen. Geben Sie stattdessen das PDF als Dateiresultat mit File() und dem application/pdf MIME-Typ zurück, und lassen Sie den Browser die Anzeige handhaben.

Für Konsolen- und Desktop-Anwendungen bleibt Process.Start mit UseShellExecute = true die einfachste und zuverlässigste Option.

Hinweis:Hinweis: Falls kein PDF-Viewer installiert ist, zeigt Windows möglicherweise ein Dialogfeld an, in dem Sie aufgefordert werden, einen auszuwählen oder herunterzuladen.

Sind Sie bereit, mit der PDF-Generierung und -Anzeige in Ihrer .NET Anwendung zu beginnen? Starten Sie mit einer kostenlosen Testversion , um auf den vollen Funktionsumfang zuzugreifen, oder besuchen Sie die IronPDF -Lizenzseite, um den passenden Tarif für Ihr Projekt zu finden.

Häufig gestellte Fragen

Wie kann ich ein PDF im Standardbetrachter mit C# öffnen?

Sie können ein PDF im Standardbetrachter in C# öffnen, indem Sie mit IronPDF das PDF erstellen und mit System.Diagnostics.Process.Start in der Standard-PDF-Anwendung des Benutzers öffnen.

Was ist IronPDF?

IronPDF ist eine .NET-Bibliothek, die es Entwicklern ermöglicht, PDF-Dateien programmatisch innerhalb ihrer Anwendungen zu erstellen, zu bearbeiten und zu manipulieren.

Was sind die Systemanforderungen für die Verwendung von IronPDF?

IronPDF ist mit jeder .NET-Anwendung kompatibel und funktioniert auf Windows-, macOS- und Linux-Plattformen. Es erfordert die Installation von .NET Framework oder .NET Core/5+.

Kann IronPDF PDFs standardmäßig in Adobe Acrobat öffnen?

Ja, IronPDF kann PDFs erstellen, die im vom Benutzer festgelegten Standard-PDF-Betrachter geöffnet werden, sei es Adobe Acrobat, Microsoft Edge oder eine andere PDF-Anzeigeanwendung.

Wie funktioniert System.Diagnostics.Process.Start mit IronPDF?

System.Diagnostics.Process.Start wird verwendet, um die erstellte PDF-Datei im Standardbetrachter zu öffnen. Sobald IronPDF die Datei erstellt hat, startet diese Methode die Standardanwendung, die mit PDF-Dateien verknüpft ist, um sie anzuzeigen.

Ist es möglich, PDF-Dateien mit IronPDF zu bearbeiten?

Ja, IronPDF ermöglicht Ihnen das Bearbeiten bestehender PDF-Dateien durch Hinzufügen von Text, Bildern, Anmerkungen und mehr vor dem Speichern oder Anzeigen.

Welche Programmiersprachen werden von IronPDF unterstützt?

IronPDF wird hauptsächlich mit C# verwendet, kann aber auch in Projekte mit VB.NET und anderen .NET-unterstützten Sprachen integriert werden.

Kann IronPDF die Anzeige von PDFs nach der Erstellung automatisieren?

Ja, nach der Erstellung eines PDFs mit IronPDF können Sie seine Anzeige automatisieren, indem Sie System.Diagnostics.Process.Start verwenden, um es sofort im Standardbetrachter des Benutzers zu öffnen.

Gibt es Codebeispiele für die Verwendung von IronPDF?

Die IronPDF-Dokumentation bietet verschiedene Codebeispiele zum Erstellen und Bearbeiten von PDFs, einschließlich wie man sie mit C# im Standardbetrachter öffnet.

Was sind einige häufige Anwendungsfälle für IronPDF?

Häufige Anwendungsfälle für IronPDF sind das Generieren von Berichten, Rechnungen und anderen Dokumenten, das Konvertieren von HTML in PDF und die Automatisierung des PDF-Anzeigeprozesses in .NET-Anwendungen.

Ist IronPDF mit .NET 10 kompatibel und welche Vorteile ergeben sich daraus?

Ja. IronPDF ist vollständig kompatibel mit .NET 10, einschließlich dessen Laufzeit- und Spracherweiterungen. Durch die Verwendung von IronPDF mit .NET 10 profitieren Ihre Anwendungen von Leistungsverbesserungen wie reduziertem Heap-Speicherbedarf, schnellerer PDF-Generierung und reibungsloserer Integration mit modernen APIs und Plattformen.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

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

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron-Support-Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an