Wie können Sie die PDF-Darstellung in C# verzögern?

Sie können die PDF-Darstellung in C# verzögern, indem Sie die `Thread.Sleep`-Methode für synchrones Warten oder `Task.Delay` für asynchrones Warten verwenden. Diese Methoden ermöglichen es Ihnen, die Ausführung von Code für eine bestimmte Dauer zu pausieren, um sicherzustellen, dass Aufgaben zur richtigen Zeit ausgeführt werden.

Was ist die WaitFor-Klasse in C#?

Die WaitFor-Klasse in C# wird verwendet, um verschiedene Warte-Strategien in Ihrem Code zu implementieren. Sie bietet Methoden wie `Thread.Sleep` und `Task.Delay`, um das Timing der Aufgabenausführung zu verwalten, sodass Entwickler die Codeausführung bei Bedarf pausieren können.

Wie können Sie asynchrones Warten in C# für PDF-Aufgaben implementieren?

Asynchrones Warten in C# kann mit der `Task.Delay`-Methode implementiert werden, die es ermöglicht, asynchron zu warten, ohne den Hauptthread zu blockieren. Dies ist besonders nützlich bei PDF-Aufgaben, um eine reibungslose Ausführung und ordnungsgemäße Aufgabenplanung sicherzustellen.

Welche Rolle spielen Timer bei der Verwaltung der Aufgabenausführung in C#?

Timer, wie sie von der `System.Timers.Timer`-Klasse bereitgestellt werden, ermöglichen es Ihnen, Aufgaben in bestimmten Intervallen zu planen. Sie sind nützlich für die Ausführung von Aufgaben wie der PDF-Erstellung in regelmäßigen Abständen und sorgen für ein effizientes Aufgabenmanagement, ohne den Hauptthread zu blockieren.

Können Sie benutzerdefinierte Wartefunktionen in C# erstellen?

Ja, Sie können benutzerdefinierte Wartefunktionen in C# mit asynchronen Delegates erstellen. Dies ermöglicht maßgeschneiderte Pausen in der Codeausführung, um spezifische Anforderungen zu erfüllen, insbesondere wenn Standardwarte-Methoden nicht ausreichen.

Wie können Sie PDF-Erstellung mit Warte-Strategien in C# integrieren?

Sie können PDF-Erstellung mit Warte-Strategien in C# integrieren, indem Sie asynchrone Methoden und Timer verwenden. Dies stellt sicher, dass Aufgaben zur PDF-Erstellung effizient verwaltet werden und eine geplante Ausführung erfolgt, ohne andere Prozesse zu blockieren.

Wie konvertiert man HTML zu PDF in C#?

Um HTML zu PDF in C# zu konvertieren, können Sie Bibliotheken wie IronPDF verwenden. Diese Bibliothek bietet Methoden zum effizienten Konvertieren von HTML-Strings, URLs und Dateien in PDF-Dokumente.

Welche Vorteile haben asynchrone Methoden in C#?

Asynchrone Methoden in C# bieten den Vorteil der gleichzeitigen Ausführung von Aufgaben, was die Effizienz der Anwendung verbessert, indem mehrere Aufgaben parallel laufen können, ohne den Hauptthread zu blockieren.

Wie installiert man eine PDF-Bibliothek in einem .NET-Projekt?

Um eine PDF-Bibliothek in einem .NET-Projekt zu installieren, können Sie den NuGet-Paket-Manager in Visual Studio verwenden, um die Bibliothek zu suchen und zu installieren. Alternativ können Sie die DLL-Datei der Bibliothek herunterladen und manuell zu Ihrem Projekt hinzufügen.

Ist es möglich, die PDF-Darstellung für eine bestimmte Zeit in C# zu pausieren?

Ja, Sie können das PDF-Renderring für eine bestimmte Zeit in C# pausieren, indem Sie Methoden wie `Thread.Sleep` für synchrone Pausen oder `Task.Delay` für asynchrone Pausen verwenden, die es Ihnen ermöglichen, das Timing von PDF-Generierungsaufgaben zu steuern.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

C# Warten auf Sekunden (Wie es für Entwickler funktioniert)

Jacob Mellor

Updated: 23. April 2026

Beim Programmieren möchten Sie manchmal die Ausführung Ihres Codes für eine bestimmte Zeitspanne pausieren oder verzögern. Dies dient dazu, unterschiedliche Zeitbedingungen zu simulieren, bestimmte Aufgaben zu priorisieren, andere Aufgaben auszuführen, ohne den Hauptthread zu blockieren, und mehr.

In diesem Leitfaden erklären wir, wie Sie in C# warten, einschließlich asynchroner Methoden, Sleep-Befehle, Sleep-Funktionen, Konsolenanwendungen und wie Sie eine Wartefunktion in unserem branchenführenden PDF-Generierungstool, IronPDF, integrieren.

Wie wartet man eine Aufgabe in C#

Der Befehl Sleep

'Sleep' ist ein einfacher, aber leistungsstarker Befehl, mit dem Sie die Ausführung Ihrer aktuellen Aufgabe für einen bestimmten Zeitraum pausieren können, wobei Sie Ihr Programm im Grunde anweisen, vor dem Fortfahren mit der nächsten Aufgabe zu warten. In C# machen wir dies mit der Thread.Sleep(int milliseconds) Methode, wie im folgenden Codebeispiel:

using System;
using System.Threading;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Starting the program...");
        Thread.Sleep(3000); // Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds");
    }
}

using System;
using System.Threading;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Starting the program...");
        Thread.Sleep(3000); // Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds");
    }
}

Imports System
Imports System.Threading

Class Program
    Public Shared Sub Main()
        Console.WriteLine("Starting the program...")
        Thread.Sleep(3000) ' Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds")
    End Sub
End Class

Imports System
Imports System.Threading

Class Program
    Public Shared Sub Main()
        Console.WriteLine("Starting the program...")
        Thread.Sleep(3000) ' Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds")
    End Sub
End Class

Hier startet das Programm, indem es "Programm wird gestartet..." in die Konsole druckt, bevor die Thread.Sleep Methode verwendet wird, um für 3.000 Millisekunden (oder drei Sekunden) zu pausieren. Nach der angegebenen Verzögerung wird das Programm fortgesetzt und gibt die Ausgabe "...Programm geht nach 3 Sekunden weiter" in die Konsole aus.

Async-Methode und Aufgaben

Asynchrone Methoden in C# ermöglichen es Ihnen, mehrere Aufgaben gleichzeitig auszuführen, ohne den Hauptthread zu beeinflussen. Das bedeutet, dass während eine Aufgabe wartet, andere Aufgaben weiterlaufen können. Um eine asynchrone Methode zu implementieren, müssen Sie das async Schlüsselwort und die Task Klasse verwenden.

using System;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       var task1 = DoSomethingAsync(3000);
       Console.WriteLine("Starting Task 2...");
       var task2 = DoSomethingAsync(2000);

       await Task.WhenAll(task1, task2);
       Console.WriteLine("Both tasks completed.");
   }

   private static async Task DoSomethingAsync(int milliseconds)
   {
       await Task.Delay(milliseconds); // Asynchronously wait without blocking the main thread
       Console.WriteLine($"Task completed after {milliseconds} milliseconds");
   }
}

using System;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       var task1 = DoSomethingAsync(3000);
       Console.WriteLine("Starting Task 2...");
       var task2 = DoSomethingAsync(2000);

       await Task.WhenAll(task1, task2);
       Console.WriteLine("Both tasks completed.");
   }

   private static async Task DoSomethingAsync(int milliseconds)
   {
       await Task.Delay(milliseconds); // Asynchronously wait without blocking the main thread
       Console.WriteLine($"Task completed after {milliseconds} milliseconds");
   }
}

Imports System
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Dim task1 = DoSomethingAsync(3000)
	   Console.WriteLine("Starting Task 2...")
	   Dim task2 = DoSomethingAsync(2000)

	   Await Task.WhenAll(task1, task2)
	   Console.WriteLine("Both tasks completed.")
   End Function

   Private Shared Async Function DoSomethingAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Delay(milliseconds) ' Asynchronously wait without blocking the main thread
	   Console.WriteLine($"Task completed after {milliseconds} milliseconds")
   End Function
End Class

Imports System
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Dim task1 = DoSomethingAsync(3000)
	   Console.WriteLine("Starting Task 2...")
	   Dim task2 = DoSomethingAsync(2000)

	   Await Task.WhenAll(task1, task2)
	   Console.WriteLine("Both tasks completed.")
   End Function

   Private Shared Async Function DoSomethingAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Delay(milliseconds) ' Asynchronously wait without blocking the main thread
	   Console.WriteLine($"Task completed after {milliseconds} milliseconds")
   End Function
End Class

In diesem Codebeispiel haben wir zwei Aufgaben, die gleichzeitig ausgeführt werden. Die DoSomethingAsync Methode nimmt einen int Parameter, der die Zeit in Millisekunden darstellt, um die die Aufgabe verzögert werden soll (wie Sie in den 3000 und 2000 im Code sehen können, beide ein Timeout-Wert). Die Task.Delay Methode ist der Thread.Sleep() Methode ähnlich, arbeitet jedoch mit asynchronen Aufgaben und blockiert nicht den Haupt-Thread.

Verwendung von Timern zur Planung von Aufgaben

Timer in C# ermöglichen es Ihnen, eine bestimmte Aufgabe nach einem bestimmten Intervall auszuführen. Sie können einen Timer durch die Verwendung der System.Timers.Timer Klasse erstellen. Hier ist ein Beispiel, wie Sie einen Timer in einer Konsolenanwendung verwenden:

using System;
using System.Timers;

class Program
{
   public static void Main()
   {
       var timer = new Timer(1000); // Create a timer with a 1-second interval
       timer.Elapsed += OnTimerElapsed;
       timer.AutoReset = true;
       timer.Enabled = true;

       Console.WriteLine("Press any key to exit...");
       Console.ReadKey();
   }

   private static void OnTimerElapsed(object sender, ElapsedEventArgs e)
   {
       Console.WriteLine("Timer ticked at " + e.SignalTime);
   }
}

using System;
using System.Timers;

class Program
{
   public static void Main()
   {
       var timer = new Timer(1000); // Create a timer with a 1-second interval
       timer.Elapsed += OnTimerElapsed;
       timer.AutoReset = true;
       timer.Enabled = true;

       Console.WriteLine("Press any key to exit...");
       Console.ReadKey();
   }

   private static void OnTimerElapsed(object sender, ElapsedEventArgs e)
   {
       Console.WriteLine("Timer ticked at " + e.SignalTime);
   }
}

Imports System
Imports System.Timers

Class Program
    Public Shared Sub Main()
        Dim timer As New Timer(1000) ' Create a timer with a 1-second interval
        AddHandler timer.Elapsed, AddressOf OnTimerElapsed
        timer.AutoReset = True
        timer.Enabled = True

        Console.WriteLine("Press any key to exit...")
        Console.ReadKey()
    End Sub

    Private Shared Sub OnTimerElapsed(sender As Object, e As ElapsedEventArgs)
        Console.WriteLine("Timer ticked at " & e.SignalTime)
    End Sub
End Class

Imports System
Imports System.Timers

Class Program
    Public Shared Sub Main()
        Dim timer As New Timer(1000) ' Create a timer with a 1-second interval
        AddHandler timer.Elapsed, AddressOf OnTimerElapsed
        timer.AutoReset = True
        timer.Enabled = True

        Console.WriteLine("Press any key to exit...")
        Console.ReadKey()
    End Sub

    Private Shared Sub OnTimerElapsed(sender As Object, e As ElapsedEventArgs)
        Console.WriteLine("Timer ticked at " & e.SignalTime)
    End Sub
End Class

In dem obigen Beispiel erstellen wir einen Timer mit einem 1-Sekunden-Intervall. Die OnTimerElapsed Methode wird jedes Mal ausgeführt, wenn der Timer tickt. Wir setzen die AutoReset Eigenschaft auf true, damit der Timer nach jedem Tick automatisch neu startet. Die Enabled Eigenschaft wird auf true gesetzt, um den Timer zu starten.

Wenn Sie diese Konsolenanwendung ausführen, sehen Sie, wie der Timer jede Sekunde tickt und die Tick-Zeit in die Konsole ausgibt. Das Programm läuft weiter, bis Sie eine Taste drücken, um es zu beenden.

Benutzerdefinierte Wartefunktionen erstellen

Manchmal benötigen Sie möglicherweise eine benutzerdefinierte Wartefunktion, um spezifische Anforderungen in Ihrem Code zu erfüllen. Zum Beispiel möchten Sie möglicherweise eine Wartefunktion erstellen, die nur die aktuelle Aufgabe blockiert, nicht jedoch den gesamten Thread. Dies können Sie mit asynchronen Delegaten erreichen.

Hier ist ein Beispiel für eine benutzerdefinierte Wartefunktion:

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       await CustomWaitAsync(3000);
       Console.WriteLine("Task 1 completed.");

       Console.WriteLine("Starting Task 2...");
       await CustomWaitAsync(2000);
       Console.WriteLine("Task 2 completed.");
   }

   private static async Task CustomWaitAsync(int milliseconds)
   {
       await Task.Run(() => Thread.Sleep(milliseconds)); // Run in a separate task to avoid blocking the main thread
   }
}

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       await CustomWaitAsync(3000);
       Console.WriteLine("Task 1 completed.");

       Console.WriteLine("Starting Task 2...");
       await CustomWaitAsync(2000);
       Console.WriteLine("Task 2 completed.");
   }

   private static async Task CustomWaitAsync(int milliseconds)
   {
       await Task.Run(() => Thread.Sleep(milliseconds)); // Run in a separate task to avoid blocking the main thread
   }
}

Imports System
Imports System.Threading
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Await CustomWaitAsync(3000)
	   Console.WriteLine("Task 1 completed.")

	   Console.WriteLine("Starting Task 2...")
	   Await CustomWaitAsync(2000)
	   Console.WriteLine("Task 2 completed.")
   End Function

   Private Shared Async Function CustomWaitAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Run(Sub() Thread.Sleep(milliseconds)) ' Run in a separate task to avoid blocking the main thread
   End Function
End Class

Imports System
Imports System.Threading
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Await CustomWaitAsync(3000)
	   Console.WriteLine("Task 1 completed.")

	   Console.WriteLine("Starting Task 2...")
	   Await CustomWaitAsync(2000)
	   Console.WriteLine("Task 2 completed.")
   End Function

   Private Shared Async Function CustomWaitAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Run(Sub() Thread.Sleep(milliseconds)) ' Run in a separate task to avoid blocking the main thread
   End Function
End Class

Hier akzeptiert die CustomWaitAsync Methode einen int Parameter, der die Verzögerungszeit in Millisekunden darstellt. Die Methode verwendet ein asynchrones Delegat, um die Thread.Sleep Funktion innerhalb einer neuen Aufgabe auszuführen, was sicherstellt, dass der aktuelle Aufgabenstatus blockiert ist, während gewartet wird, nicht jedoch der Haupt-Thread.

Auswahl der richtigen Wartestrategie

Da wir nun die C#-Wartedeclaration, den Sleep-Befehl, asynchrone Methoden, Timer und benutzerdefinierte Wartefunktionen behandelt haben, ist es wichtig zu wissen, wann welche Technik eingesetzt werden sollte. Hier ist eine kurze Zusammenfassung:

Verwenden Sie die Thread.Sleep Funktion, wenn Sie eine einfache Möglichkeit benötigen, die Ausführung Ihres Codes für eine bestimmte Zeitspanne zu pausieren.
Verwenden Sie asynchrone Methoden und Aufgaben, wenn Sie mehrere Aufgaben gleichzeitig ausführen möchten, ohne den Hauptthread zu blockieren.
Verwenden Sie Timer, wenn Sie eine bestimmte Aufgabe in einem bestimmten Intervall ausführen müssen.
Erstellen Sie benutzerdefinierte Wartefunktionen, wenn Sie spezifische Anforderungen haben, die von den eingebauten Methoden nicht erfüllt werden.

Erzeugen von PDFs mit IronPDF unter Verwendung der Wait-Funktion

IronPDF ist eine leichtgewichtige .NET PDF-Bibliothek, die speziell für Webentwickler entwickelt wurde. Es macht das Lesen, Schreiben und Bearbeiten von PDF-Dateien zum Kinderspiel, kann alle Arten von Dateitypen in PDF-Inhalte konvertieren, und Sie können es in Ihren .NET-Projekten sowohl für Desktop- als auch Webanwendungen verwenden. Das Beste daran - es ist kostenlos in einer Entwicklungsumgebung auszuprobieren. Lassen Sie uns eintauchen.

IronPDF arbeitet mit HTML-Dateien, URLs, rohen Zeichenfolgen und ZIP-Dateien. Hier ist eine kurze Übersicht über den Code:

using IronPdf;

class Program
{
   static void Main(string[] args)
   {
       var renderer = new ChromePdfRenderer();

       // 1. Convert HTML String to PDF
       var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
       var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
       pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

       // 2. Convert HTML File to PDF
       var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
       var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
       pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

       // 3. Convert URL to PDF
       var url = "http://ironpdf.com"; // Specify the URL
       var pdfFromUrl = renderer.RenderUrlAsPdf(url);
       pdfFromUrl.SaveAs("URLToPDF.pdf");
   }
}

using IronPdf;

class Program
{
   static void Main(string[] args)
   {
       var renderer = new ChromePdfRenderer();

       // 1. Convert HTML String to PDF
       var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
       var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
       pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

       // 2. Convert HTML File to PDF
       var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
       var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
       pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

       // 3. Convert URL to PDF
       var url = "http://ironpdf.com"; // Specify the URL
       var pdfFromUrl = renderer.RenderUrlAsPdf(url);
       pdfFromUrl.SaveAs("URLToPDF.pdf");
   }
}

Imports IronPdf

Friend Class Program
   Shared Sub Main(ByVal args() As String)
	   Dim renderer = New ChromePdfRenderer()

	   ' 1. Convert HTML String to PDF
	   Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
	   Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
	   pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

	   ' 2. Convert HTML File to PDF
	   Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
	   Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
	   pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

	   ' 3. Convert URL to PDF
	   Dim url = "http://ironpdf.com" ' Specify the URL
	   Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
	   pdfFromUrl.SaveAs("URLToPDF.pdf")
   End Sub
End Class

Imports IronPdf

Friend Class Program
   Shared Sub Main(ByVal args() As String)
	   Dim renderer = New ChromePdfRenderer()

	   ' 1. Convert HTML String to PDF
	   Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
	   Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
	   pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

	   ' 2. Convert HTML File to PDF
	   Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
	   Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
	   pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

	   ' 3. Convert URL to PDF
	   Dim url = "http://ironpdf.com" ' Specify the URL
	   Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
	   pdfFromUrl.SaveAs("URLToPDF.pdf")
   End Sub
End Class

IronPDF kann nahtlos in Ihre Wartestrategien integriert werden, um PDF-Dokumente nach der Ausführung von Aufgaben, während geplanter Intervalle oder wenn der aktuelle Thread die Ausführung wieder aufnimmt, zu erstellen.

Zum Beispiel können Sie IronPDF in Kombination mit einer asynchronen Methode verwenden, um einen PDF-Bericht zu generieren, nachdem Daten aus einer Datenbank abgerufen wurden, ohne den Hauptthread zu blockieren. Ebenso können Sie eine Timer-Klasse verwenden, um in regelmäßigen Abständen eine PDF-Schnappschuss Ihrer Anwendungsdaten zu erstellen.

Die IronPDF-Bibliothek installieren

IronPDF ist einfach zu verwenden, aber noch einfacher zu installieren. Es gibt einige Möglichkeiten, wie Sie dies tun können:

Methode 1: NuGet Paket-Manager-Konsole

Klicken Sie in Visual Studio im Projektmappen-Explorer mit der rechten Maustaste auf Verweise und dann auf NuGet-Pakete verwalten. Klicken Sie auf Durchsuchen, suchen Sie 'IronPDF' und installieren Sie die neueste Version. Wenn Sie dies sehen, funktioniert es:

Sie können auch zu Werkzeuge -> NuGet-Paketmanager -> Paketmanager-Konsole gehen und die folgende Zeile im Paketmanager-Tab eingeben:

PM > Install-Package IronPdf

Install-Package IronPdf

Schließlich können Sie IronPDF direkt von der offiziellen NuGet-Website erhalten. Wählen Sie die Paket herunterladen-Option aus dem Menü auf der rechten Seite der Seite, doppelklicken Sie auf Ihren Download, um es automatisch zu installieren, und laden Sie die Lösung neu, um es in Ihrem Projekt zu verwenden.

Funktionierte nicht? Sie finden plattformspezifische Hilfe auf unserer erweiterten NuGet-Installationsseite.

Methode 2: Verwenden einer DLL-Datei

Sie können die IronPDF-DLL-Datei auch direkt von uns erhalten und manuell zu Visual Studio hinzufügen. Für vollständige Anweisungen und Links zu den Windows-, MacOS- und Linux-DLL-Paketen besuchen Sie unsere spezielle Installationsseite.

Wie man C# Wait in IronPDF verwendet

Sie können sehen, wie eine Wartefunktion in IronPDF integriert wird, im folgenden Beispiel:

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting the PDF generation task...");
       Stopwatch stopwatch = Stopwatch.StartNew();
       await Task.Delay(3000); // Wait for 3 seconds
       GeneratePdf();
       Console.WriteLine("PDF generated successfully.");
   }

   private static void GeneratePdf()
   {
       var htmlToPdf = new ChromePdfRenderer();
       var pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
       pdf.SaveAs("HelloWorld.pdf");
   }
}

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting the PDF generation task...");
       Stopwatch stopwatch = Stopwatch.StartNew();
       await Task.Delay(3000); // Wait for 3 seconds
       GeneratePdf();
       Console.WriteLine("PDF generated successfully.");
   }

   private static void GeneratePdf()
   {
       var htmlToPdf = new ChromePdfRenderer();
       var pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
       pdf.SaveAs("HelloWorld.pdf");
   }
}

Imports System
Imports System.Threading.Tasks
Imports System.Diagnostics
Imports IronPdf

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting the PDF generation task...")
	   Dim stopwatch As Stopwatch = System.Diagnostics.Stopwatch.StartNew()
	   Await Task.Delay(3000) ' Wait for 3 seconds
	   GeneratePdf()
	   Console.WriteLine("PDF generated successfully.")
   End Function

   Private Shared Sub GeneratePdf()
	   Dim htmlToPdf = New ChromePdfRenderer()
	   Dim pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
	   pdf.SaveAs("HelloWorld.pdf")
   End Sub
End Class

Imports System
Imports System.Threading.Tasks
Imports System.Diagnostics
Imports IronPdf

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting the PDF generation task...")
	   Dim stopwatch As Stopwatch = System.Diagnostics.Stopwatch.StartNew()
	   Await Task.Delay(3000) ' Wait for 3 seconds
	   GeneratePdf()
	   Console.WriteLine("PDF generated successfully.")
   End Function

   Private Shared Sub GeneratePdf()
	   Dim htmlToPdf = New ChromePdfRenderer()
	   Dim pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
	   pdf.SaveAs("HelloWorld.pdf")
   End Sub
End Class

Hier verwenden wir die Task.Delay Methode, um drei Sekunden zu warten, bevor ein PDF erzeugt wird. Das PDF wird dann als "HelloWorld.pdf" im Arbeitsverzeichnis der Anwendung gespeichert, wenn das Warten abgeschlossen ist.

Und hier ist das Endprodukt:

Verwendung der Wait-Methode mit IronPDF

In C#-Anwendungen können Sie die Schlaf-Funktion effizient verwenden, um den aktuellen Thread und die CPU-Zeit zu verwalten, während Sie Vorgänge wie das Laden von Daten in eine DataTable oder das Generieren von PDF-Berichten mit IronPDF ausführen.

Abschluss

Es mag anfangs kontraintuitiv erscheinen, aber Warteanweisungen in Ihren Code einzubauen, ist eine notwendige Fähigkeit beim Erstellen effizienter Anwendungen. Und durch die Integration von IronPDF können Sie Ihre Anwendungen auf die nächste Stufe heben, indem Sie PDF-Dokumente spontan erstellen, ohne den Hauptthread zu blockieren.

Bereit, IronPDF selbst auszuprobieren? Sie können mit unserer 30-tägigen kostenlosen Testversion beginnen. Es ist auch völlig kostenlos für Entwicklungszwecke, sodass Sie wirklich sehen können, woraus es besteht. Und wenn Ihnen gefällt, was Sie sehen, startet IronPDF bereits ab $999. Für noch größere Einsparungen sehen Sie sich die Iron Suite an, wo Sie alle neun Iron Software-Tools zum Preis von zwei erhalten. Viel Spaß beim Coden!

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...