C# Volatile (jak to działa dla programistów)

Jak używać C# Volatile

1. Zaimportuj niezbędne biblioteki.
2. Zadeklaruj zmienną typu Volatile.
3. Rozpocznij zadanie generowania pliku PDF.
4. Ustaw zmienną typu Volatile w zadaniu.
5. Sprawdź zmienną typu Volatile.
6. Poczekaj na wygenerowanie pliku PDF.
7. Obsługa uzupełniania plików PDF.

Czym jest C# Volatile?

Deklaracja pola, które może być modyfikowane przez kilka wątków działających jednocześnie, odbywa się przy użyciu słowa kluczowego volatile. Pole oznaczone jako volatile sygnalizuje kompilatorowi i środowisku uruchomieniowemu, że inne komponenty programu, w tym współbieżne wątki, mogą modyfikować jego wartość bez ostrzeżenia. Z tego powodu odczyty i zapisy do pola typu volatile są zawsze najpierw wykonywane bezpośrednio do i z pamięci głównej.

Słowo kluczowe volatile rozwiązuje problemy związane z zmianą kolejności operacji pamięciowych poprzez egzekwowanie barier pamięciowych. Bariera pamięci zapewnia, że operacje pamięciowe nie są zmieniane w kolejności w przypadku dostępu do pamięci ulotnej, zapobiegając nieoczekiwanemu zachowaniu w scenariuszach wielowątkowych.

Stosując bariery pamięci w sposób niejawny przed i po operacjach odczytu zmiennych lub podczas operacji zapisu zmiennych, volatile gwarantuje prawidłową kolejność operacji pamięciowych, zwiększając bezpieczeństwo wątków i spójność danych w środowiskach współbieżnych, w przeciwieństwie do problemów, które mogłyby powstać przy użyciu obiektów niezmiennych.

using System;
using System.Threading;

class SharedStateExample
{
    private volatile bool _isRunning = true;

    public void Run()
    {
        Thread thread1 = new Thread(ChangeState);
        Thread thread2 = new Thread(ReadState);
        thread1.Start();
        thread2.Start();
    }

    private void ChangeState()
    {
        while (_isRunning)
        {
            Console.WriteLine("Changing state...");
            Thread.Sleep(1000);
            _isRunning = false;
        }
    }

    private void ReadState()
    {
        while (_isRunning)
        {
            Console.WriteLine("Reading state...");
            Thread.Sleep(500);
        }
        Console.WriteLine("State is no longer running.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        SharedStateExample example = new SharedStateExample();
        example.Run();
    }
}

using System;
using System.Threading;

class SharedStateExample
{
    private volatile bool _isRunning = true;

    public void Run()
    {
        Thread thread1 = new Thread(ChangeState);
        Thread thread2 = new Thread(ReadState);
        thread1.Start();
        thread2.Start();
    }

    private void ChangeState()
    {
        while (_isRunning)
        {
            Console.WriteLine("Changing state...");
            Thread.Sleep(1000);
            _isRunning = false;
        }
    }

    private void ReadState()
    {
        while (_isRunning)
        {
            Console.WriteLine("Reading state...");
            Thread.Sleep(500);
        }
        Console.WriteLine("State is no longer running.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        SharedStateExample example = new SharedStateExample();
        example.Run();
    }
}

Imports System
Imports System.Threading

Friend Class SharedStateExample
'INSTANT VB TODO TASK: There is no VB equivalent to 'volatile':
'ORIGINAL LINE: private volatile bool _isRunning = true;
	Private _isRunning As Boolean = True

	Public Sub Run()
		Dim thread1 As New Thread(AddressOf ChangeState)
		Dim thread2 As New Thread(AddressOf ReadState)
		thread1.Start()
		thread2.Start()
	End Sub

	Private Sub ChangeState()
		Do While _isRunning
			Console.WriteLine("Changing state...")
			Thread.Sleep(1000)
			_isRunning = False
		Loop
	End Sub

	Private Sub ReadState()
		Do While _isRunning
			Console.WriteLine("Reading state...")
			Thread.Sleep(500)
		Loop
		Console.WriteLine("State is no longer running.")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim example As New SharedStateExample()
		example.Run()
	End Sub
End Class

using System;

class Singleton
{
    private static volatile Singleton _instance;
    private static readonly object _lock = new object();

    private Singleton() { }

    public static Singleton GetInstance()
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new Singleton();
                }
            }
        }
        return _instance;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Singleton instance1 = Singleton.GetInstance();
        Singleton instance2 = Singleton.GetInstance();
        Console.WriteLine("Are instances equal? " + (instance1 == instance2));
    }
}

using System;

class Singleton
{
    private static volatile Singleton _instance;
    private static readonly object _lock = new object();

    private Singleton() { }

    public static Singleton GetInstance()
    {
        if (_instance == null)
        {
            lock (_lock)
            {
                if (_instance == null)
                {
                    _instance = new Singleton();
                }
            }
        }
        return _instance;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Singleton instance1 = Singleton.GetInstance();
        Singleton instance2 = Singleton.GetInstance();
        Console.WriteLine("Are instances equal? " + (instance1 == instance2));
    }
}

Imports System

Friend Class Singleton
'INSTANT VB TODO TASK: There is no VB equivalent to 'volatile':
'ORIGINAL LINE: private static volatile Singleton _instance;
	Private Shared _instance As Singleton
	Private Shared ReadOnly _lock As New Object()

	Private Sub New()
	End Sub

	Public Shared Function GetInstance() As Singleton
		If _instance Is Nothing Then
			SyncLock _lock
				If _instance Is Nothing Then
					_instance = New Singleton()
				End If
			End SyncLock
		End If
		Return _instance
	End Function
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim instance1 As Singleton = Singleton.GetInstance()
		Dim instance2 As Singleton = Singleton.GetInstance()
		Console.WriteLine("Are instances equal? " & (instance1 Is instance2))
	End Sub
End Class

Czym jest IronPDF?

Biblioteka C# IronPDF – Generowanie i edycja plików PDF pozwala programistom tworzyć, modyfikować i renderować dokumenty PDF w aplikacjach .NET. Bogaty zestaw funkcji sprawia, że praca z plikami PDF jest prosta. Istniejące dokumenty PDF można edytować, dzielić i łączyć. Dokumenty PDF można tworzyć w formacie HTML, jako obrazy i w innych formatach. Pliki PDF mogą zawierać adnotacje w postaci tekstu, zdjęć i innych danych.

Utwórz nowy projekt Visual Studio

Instalacja IronPDF

Pozycja menu Visual Studio Tools w sekcji Tools zawiera interfejs Visual Command-Line. Wybierz menedżera pakietów NuGet. W zakładce terminala zarządzania pakietami należy wpisać następujące polecenie.

Install-Package IronPdf

Alternatywnie można skorzystać z menedżera pakietów. Instalacja pakietu bezpośrednio w rozwiązaniu jest możliwa dzięki opcji NuGet Package Manager. Aby znaleźć pakiety, skorzystaj z pola wyszukiwania na stronie NuGet Manager. Poniższy zrzut ekranu pokazuje, jak łatwo jest wyszukać "IronPDF" w menedżerze pakietów:

Odpowiednie wyniki wyszukiwania są wyświetlone na powyższym obrazku. Wprowadź poniższe zmiany, aby oprogramowanie łatwiej zainstalowało się na Twoim komputerze.

Po pobraniu i zainstalowaniu pakietu możemy teraz używać go w bieżącym projekcie.

Zapewnienie bezpieczeństwa wątków podczas generowania plików PDF za pomocą C# Volatile i IronPDF

Teraz użyjmy IronPDF i słowa kluczowego volatile razem w programie napisanym w języku C#. Popularną biblioteką C# do tworzenia i modyfikowania dokumentów PDF jest IronPDF. Podczas pracy z aplikacjami wielowątkowymi, które wykorzystują IronPDF do tworzenia lub przetwarzania plików PDF, należy zachować bezpieczeństwo wątków.

Oto przykład pokazujący, jak wykorzystać słowo kluczowe volatile w IronPDF do tworzenia dokumentów PDF w środowisku wielowątkowym.

using IronPdf;
using System;
using System.Threading;

class PdfGenerator
{
    private volatile bool _isRunning = true;
    private readonly object _lock = new object();

    public void GeneratePdf(string filePath)
    {
        Thread thread = new Thread(() =>
        {
            while (_isRunning)
            {
                // Generate PDF document
                GenerateDocument(filePath);
                // Sleep for some time
                Thread.Sleep(5000);
            }
        });
        thread.Start();
    }

    public void StopPdfGeneration()
    {
        lock (_lock)
        {
            _isRunning = false;
        }
    }

    private void GenerateDocument(string filePath)
    {
        // Load HTML content
        string htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
        // Convert HTML to PDF
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save PDF to file
        pdfDocument.SaveAs(filePath);
        // Output status
        Console.WriteLine($"PDF generated and saved to {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator pdfGenerator = new PdfGenerator();
        // Start PDF generation
        pdfGenerator.GeneratePdf("output.pdf");
        // Wait for user input to stop PDF generation
        Console.WriteLine("Press any key to stop PDF generation...");
        Console.ReadKey();
        // Stop PDF generation
        pdfGenerator.StopPdfGeneration();
    }
}

using IronPdf;
using System;
using System.Threading;

class PdfGenerator
{
    private volatile bool _isRunning = true;
    private readonly object _lock = new object();

    public void GeneratePdf(string filePath)
    {
        Thread thread = new Thread(() =>
        {
            while (_isRunning)
            {
                // Generate PDF document
                GenerateDocument(filePath);
                // Sleep for some time
                Thread.Sleep(5000);
            }
        });
        thread.Start();
    }

    public void StopPdfGeneration()
    {
        lock (_lock)
        {
            _isRunning = false;
        }
    }

    private void GenerateDocument(string filePath)
    {
        // Load HTML content
        string htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
        // Convert HTML to PDF
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Save PDF to file
        pdfDocument.SaveAs(filePath);
        // Output status
        Console.WriteLine($"PDF generated and saved to {filePath}");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PdfGenerator pdfGenerator = new PdfGenerator();
        // Start PDF generation
        pdfGenerator.GeneratePdf("output.pdf");
        // Wait for user input to stop PDF generation
        Console.WriteLine("Press any key to stop PDF generation...");
        Console.ReadKey();
        // Stop PDF generation
        pdfGenerator.StopPdfGeneration();
    }
}

Imports IronPdf
Imports System
Imports System.Threading

Friend Class PdfGenerator
'INSTANT VB TODO TASK: There is no VB equivalent to 'volatile':
'ORIGINAL LINE: private volatile bool _isRunning = true;
	Private _isRunning As Boolean = True
	Private ReadOnly _lock As New Object()

	Public Sub GeneratePdf(ByVal filePath As String)
		Dim thread As New Thread(Sub()
			Do While _isRunning
				' Generate PDF document
				GenerateDocument(filePath)
				' Sleep for some time
				System.Threading.Thread.Sleep(5000)
			Loop
		End Sub)
		thread.Start()
	End Sub

	Public Sub StopPdfGeneration()
		SyncLock _lock
			_isRunning = False
		End SyncLock
	End Sub

	Private Sub GenerateDocument(ByVal filePath As String)
		' Load HTML content
		Dim htmlContent As String = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
		' Convert HTML to PDF
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		' Save PDF to file
		pdfDocument.SaveAs(filePath)
		' Output status
		Console.WriteLine($"PDF generated and saved to {filePath}")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfGenerator As New PdfGenerator()
		' Start PDF generation
		pdfGenerator.GeneratePdf("output.pdf")
		' Wait for user input to stop PDF generation
		Console.WriteLine("Press any key to stop PDF generation...")
		Console.ReadKey()
		' Stop PDF generation
		pdfGenerator.StopPdfGeneration()
	End Sub
End Class

volatile bool isRunning: Wyznaczamy pole _isRunning jako zmienną typu volatile, aby zaznaczyć możliwość wprowadzania w niej zmian przez kilka wątków. Generowanie dokumentów PDF jest zarządzane przez to pole. Tworzenie pliku PDF jest kontynuowane, jeśli _isRunning ma wartość true; w przeciwnym razie kończy działanie.

GeneratePdf(string filePath): Ta funkcja uruchamia nowy wątek, który tworzy dokumenty PDF zgodnie z harmonogramem. W głównym wątku na bieżąco sprawdzamy flagę _isRunning. W takim przypadku używamy IronPDF do utworzenia dokumentu PDF i zapisania go w wyznaczonym katalogu plików.

StopPdfGeneration(): Ta funkcja umożliwia zatrzymanie tworzenia plików PDF. Aby zachować bezpieczeństwo wątków podczas zmiany flagi _isRunning, blokuje się na prywatnym obiekcie o nazwie _lock.

GenerateDocument(string filePath): Ta funkcja zawiera kod niezbędny do użycia IronPDF w celu utworzenia dokumentu PDF. Tworzona jest instancja ChromePdfRenderer, ładowana jest zawartość HTML, konwertowana do dokumentu PDF, a plik PDF jest zapisywany w wyznaczonym katalogu plików.

Main(string[] args): W metodzie Main instancjonowana jest klasa PdfGenerator, rozpoczyna się generowanie pliku PDF, a użytkownik jest proszony o zatrzymanie generowania pliku PDF poprzez naciśnięcie dowolnego klawisza.

Ten przykład pokazuje, jak niezawodnie generować dokumenty PDF w środowisku wielowątkowym przy użyciu IronPDF i słowa kluczowego volatile. Skutecznie kontrolujemy proces tworzenia plików PDF, wykorzystując volatile, aby zapewnić, że zmiany flagi _isRunning są natychmiast widoczne we wszystkich wątkach. Używamy również blokady, aby uzyskać dostęp do flagi _isRunning i modyfikować ją, zachowując jednocześnie bezpieczeństwo wątków roboczych.

Wnioski

Podsumowując, włączenie słowa kluczowego volatile do IronPDF stanowi skuteczny sposób na zagwarantowanie bezpieczeństwa wątków podczas tworzenia plików PDF w wielowątkowych programach C#. Zapewniamy terminową świadomość i właściwą synchronizację zmian we wszystkich wątkach poprzez oznaczenie wspólnych flag kontrolnych jako zmiennych, co zapewnia skuteczną kontrolę nad procesem tworzenia plików PDF.

Aby zapewnić, że zmiany w flagach sterujących są natychmiast przekazywane do wszystkich wątków, używa się volatile w celu uniknięcia konfliktów i zapewnienia sprawnej koordynacji procesów związanych z tworzeniem plików PDF.

Dzięki temu podejściu, które poprawia skalowalność i niezawodność generowania plików PDF w kontekstach współbieżnych, aplikacje mogą efektywnie zarządzać wieloma procesami generowania plików PDF jednocześnie, bez ryzyka uszkodzenia danych lub sytuacji wyścigu.

Wreszcie, dzięki włączeniu IronPDF możesz efektywnie pracować z kodami kreskowymi, tworzyć pliki PDF, korzystać z OCR i łączyć się z Excelem, a także z łatwością odkrywać pełen potencjał bibliotek Iron Software. Iron Software z łatwością łączy wydajność, kompatybilność i łatwość użytkowania swojego wszechstronnego pakietu, oferując rozszerzone możliwości aplikacji i bardziej efektywne programowanie.

Programiści mogą z pewnością wybrać najlepszy model, jeśli dostępne są jasne opcje licencji dostosowane do konkretnych potrzeb projektu. Te zalety pozwalają programistom skutecznie i przejrzyście radzić sobie z różnymi wyzwaniami.