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

C# PDF im Standard-Viewer mit IronPDF öffnen (.NET 10)

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 Erzeugung von PDF-Dateien mit IronPDF und zum automatischen Öffnen dieser Dateien in Windows mit System.Diagnostics.Process.Start.

Die Kombination der leistungsstarken HTML-zu-PDF-Konvertierung von IronPDF mit der einfachen Process Startmethode schafft einen praktischen Arbeitsablauf für die Erstellung und Anzeige professioneller PDF-Dateien in der auf dem Rechner des Benutzers 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
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

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 die PDF-Datei 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 IronPDFs primäre Klasse für die Umwandlung von HTML in PDF ist. Die Methode RenderHtmlAsPdf 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 der PDF-Datei mit SaveAs, verwendet der Code Process.Start mit ProcessStartInfo, um die Datei im Standard-PDF-Viewer zu öffnen. Die Schlüsseleinstellung ist hier 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 Standardanzeigeprogramm in C# öffnet: Abbildung 1 - PDF wurde mit Standardanzeigeprogramm angezeigt

Warum Top-Level-Statements?

Mit .NET 10 und modernen C#-Versionen machen Top-Level-Anweisungen einen Program-Klassenwrapper überflüssig. 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 Parameter UseShellExecute standardmäßig auf false eingestellt. Ohne explizite Einstellung auf true wird Ihre Anwendung beim Versuch, eine PDF-Datei zu starten, einen Fehler ausgeben.

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 Eigenschaft UseShellExecute bestimmt, ob die Shell des Betriebssystems zum Starten des Prozesses verwendet werden soll. Bei der Einstellung true verwendet Windows die Dateizuordnungsregistrierung, um zu bestimmen, welcher Standard-PDF-Reader die Datei öffnen soll. Ohne diese Einstellung wird in modernen .NET-Versionen ein Laufzeitfehler auftreten, 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 bei der Erstellung mehrerer PDFs in schneller Folge. Der standardmäßige temporäre Ordner wird vom Betriebssystem regelmäßig automatisch geleert.

Ausgabe

Wie man PDFs im Standardanzeigeprogramm in C# öffnet: Abbildung 2 - URL als PDF erzeugt und mit Standardanzeigeprogramm angezeigt

Wie geht man korrekt mit Dateipfaden um?

Dateipfade, die Leerzeichen und Sonderzeichen enthalten, erfordern besondere Sorgfalt. Ein fehlendes Verzeichnis oder ein fehlerhafter Pfad führt zu einem Fehlschlag oder einer Ausnahme, bevor Process.Start überhaupt 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 demonstriert mehrere Best Practices: die Verwendung von Path.Combine, um Dateipfade unabhängig vom Betriebssystem korrekt zu erstellen, die Erstellung von Verzeichnissen nach Bedarf mit Directory.CreateDirectory und die Überprüfung des Vorhandenseins von Dateien, bevor versucht wird, die PDF-Datei 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 behandelt Leerzeichen korrekt, da es Pfade als Zeichenketten aufbaut, anstatt sich auf die Shell-Expansion zu verlassen. Die Klasse ProcessStartInfo behandelt auch Pfade in Anführungszeichen korrekt, 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 muss die Eigenschaft FileName nicht manuell zitiert werden.

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.

Mehr über interaktive PDF-Formulare und benutzerdefinierte Wasserzeichen erfahren Sie in der IronPDF -Anleitungsbibliothek.

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 Standardanzeigeprogramm in C# öffnet: Abbildung 3 - Workflow vom Erstellen bis zum Anzeigen

Rendereinstellungen konfigurieren

Die Klasse ChromePdfRenderOptions gibt Ihnen die Möglichkeit, die PDF-Ausgabe genauestens zu steuern. Übliche Einstellungen sind:

  • PaperSize -- Setzen Sie auf PdfPaperSize.A4, Letter oder eine beliebige Standardgröße.
  • PrintHtmlBackgrounds -- Rendert Hintergrundfarben und -bilder aus dem HTML-Code.
  • CreatePdfFormsFromHtml -- Konvertiert HTML <input> und <select> Elemente in interaktive PDF Formularfelder.
  • 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 ein Standardverhalten von Windows und liegt außerhalb der Kontrolle von Process.Start.

Um dies im Produktionscode elegant zu handhaben, können Sie den Win32Exception abfangen, den Process.Start auslöst, 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 dem 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, darf Process.Start nicht verwendet werden. Der Serverprozess läuft in einer Headless-Umgebung und kann keine Desktop-Anwendungen öffnen. Geben Sie stattdessen das PDF als Dateiergebnis mit File() und dem MIME-Typ application/pdf zurück und überlassen Sie die Anzeige dem Browser.

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