C# Wait For Seconds (jak to działa dla programistów)

Polecenie Sleep

"Sleep" to proste, ale potężne polecenie, które pozwala wstrzymać wykonywanie bieżącego zadania na określony czas, zasadniczo nakazując programowi poczekać przed przejściem do następnego zadania. W języku C# robimy to za pomocą metody Thread.Sleep(int milliseconds), tak jak w poniższym przykładzie kodu:

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

W tym przypadku program rozpoczyna się od wyświetlenia komunikatu "Starting the program..." w konsoli, a następnie używa metody Thread.Sleep, aby wstrzymać działanie na 3000 milisekund (czyli trzy sekundy). Po upływie określonego czasu program wznawia działanie i PRINTuje na konsoli komunikat "...Program continues after 3 seconds".

Metody asynchroniczne i zadania

Metody asynchroniczne w języku C# umożliwiają wykonywanie wielu zadań jednocześnie bez zakłócania pracy głównego wątku. Oznacza to, że podczas gdy jedno zadanie czeka, inne zadania mogą nadal być wykonywane. Aby zaimplementować metodę asynchroniczną, należy użyć słowa kluczowego async oraz klasy Task.

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

W tym przykładzie kodu mamy dwa zadania uruchomione w tym samym czasie. Metoda DoSomethingAsync przyjmuje parametr int, który reprezentuje czas w milisekundach, o który zadanie powinno zostać opóźnione (jak widać w 3000 i 2000 w kodzie, obie wartości są limitami czasu). Metoda Task.Delay jest podobna do metody Thread.Sleep(), ale działa z zadaniami asynchronicznymi i nie blokuje głównego wątku.

Korzystanie z timerów do planowania zadań

Timer w języku C# pozwala na wykonanie określonego zadania po upływie określonego czasu. Możesz utworzyć licznik czasu za pomocą klasy System.Timers.Timer. Oto przykład wykorzystania timera w aplikacji konsolowej:

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

W powyższym przykładzie tworzymy licznik czasu z interwałem 1 sekundy. Metoda OnTimerElapsed jest wykonywana za każdym razem, gdy zegar odlicza czas. Ustawiliśmy właściwość AutoReset na true, aby licznik czasu restartował się automatycznie po każdym takcie. Właściwość Enabled jest ustawiona na true, aby uruchomić licznik czasu.

Po uruchomieniu tej aplikacji konsolowej zobaczysz, jak zegar odlicza każdą sekundę, drukując czas na konsoli. Program będzie działał do momentu naciśnięcia dowolnego klawisza w celu jego zamknięcia.

Tworzenie niestandardowych funkcji oczekiwania

Czasami może być potrzebna niestandardowa funkcja oczekiwania, aby spełnić konkretne wymagania w kodzie. Na przykład, możesz chcieć stworzyć funkcję oczekiwania, która blokuje tylko bieżące zadanie, a nie cały wątek. Można to osiągnąć za pomocą delegatów asynchronicznych.

Oto przykład niestandardowej funkcji oczekiwania:

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

W tym przypadku metoda CustomWaitAsync przyjmuje parametr int reprezentujący czas opóźnienia w milisekundach. Metoda wykorzystuje delegat asynchroniczny do uruchomienia funkcji Thread.Sleep w ramach nowego zadania, zapewniając zablokowanie bieżącego stanu zadania podczas oczekiwania, ale nie głównego wątku.

Wybór odpowiedniej strategii oczekiwania

Teraz, gdy omówiliśmy instrukcję wait w języku C#, polecenie sleep, metody asynchroniczne, timery i niestandardowe funkcje oczekiwania, ważne jest, aby wiedzieć, kiedy używać każdej z tych technik. Oto krótkie podsumowanie:

• Użyj funkcji Thread.Sleep, gdy potrzebujesz prostego sposobu na wstrzymanie wykonywania kodu na określony czas.
• Używaj metod asynchronicznych i zadań, gdy chcesz wykonać wiele zadań jednocześnie bez blokowania głównego wątku.
• Używaj timerów, gdy chcesz wykonać określone zadanie w określonych odstępach czasu.
• Twórz niestandardowe funkcje oczekiwania, gdy masz konkretne wymagania, których nie spełniają wbudowane metody.

Zainstaluj bibliotekę IronPDF

Install-Package IronPdf

Jak korzystać z funkcji C# Wait w IronPDF

W poniższym przykładzie można zobaczyć, jak włączyć funkcję oczekiwania w IronPDF:

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

W tym przypadku używamy metody Task.Delay, aby odczekać 3 sekundy przed wygenerowaniem pliku PDF. Po zakończeniu oczekiwania plik PDF jest zapisywany jako "HelloWorld.pdf" w katalogu roboczym aplikacji.

A oto efekt końcowy:

Korzystanie z metody Wait w IronPDF

W aplikacjach C# można efektywnie wykorzystać funkcję sleep do zarządzania bieżącym wątkiem i czasem procesora podczas wykonywania operacji, takich jak ładowanie danych do tabeli DataTable lub generowanie raportów PDF przy użyciu IronPDF.