1. IronPDF
  2. IronPDF Blog
  3. aide .NET
  4. C# Volatile
AIDE .NET

C# Volatile (Comment ça marche pour les développeurs)

Chaknith Bin
Chaknith Bin
août 13, 2024
Partager:

Introduction

Le mot-clé volatile en C# est utilisé pour indiquer qu'un champ peut être mis à jour par des threads s'exécutant simultanément. Un champ qui a été marqué comme volatile avertit le compilateur et le temps d'exécution de la possibilité que des threads concurrents ou d'autres composants du programme puissent changer la valeur du champ sans avertissement. Cela garantit que les accès mémoire à ce champ ne seront pas optimisés par le compilateur, ce qui pourrait entraîner un comportement inattendu dans les applications multithread.

Une bibliothèque C# populaire pour créer et modifier des documents PDF s'appelle IronPDF - .NET PDF Library. Savoir comment utiliser correctement le mot-clé volatile est crucial lorsque vous travaillez avec des applications multithread ou des programmes qui utilisent IronPDF pour la création ou la manipulation de PDF. Cela permettra de s'assurer que les données sont correctement synchronisées et cohérentes lorsque plusieurs threads y accèdent.

Ce tutoriel couvrira les meilleures façons d'utiliser IronPDF et le mot-clé volatile pour créer des applications multithread fiables qui génèrent ou manipulent des PDF. Nous passerons en revue les utilisations courantes des champs volatils, la manière de déclarer et d'utiliser correctement les champs volatils, et les pratiques recommandées pour s'assurer que vos applications basées sur IronPDF sont sûres pour les threads. Commençons maintenant !

Comment utiliser C# ; Volatile

  1. Importer les bibliothèques nécessaires.

  2. Déclarer une variable volatile.

  3. Démarrer la tâche de génération de PDF.

  4. Définir une variable volatile dans la tâche.

  5. Vérifier la variable volatile.

  6. Attendre la génération du PDF.

  7. Gérer l'achèvement du PDF.

Qu'est-ce que C# ; Volatile ?

Déclarer un champ qui pourrait être modifié par plusieurs threads s'exécutant simultanément se fait en utilisant le mot-clé volatile. Lorsqu'un champ est désigné comme volatile, le compilateur et le système d'exécution sont avertis que d'autres composants du programme, y compris des threads simultanés, peuvent modifier sa valeur sans avertissement. Pour cette raison, les lectures et les écritures dans le champ volatil sont toujours effectuées directement vers et depuis la même mémoire en premier lieu.

Le mot-clé volatile traite des problèmes liés au réordonnancement des opérations mémoire en imposant des barrières mémoire. Une barrière de mémoire garantit que les opérations de mémoire ne sont pas réordonnées entre les accès volatiles, ce qui évite les comportements inattendus dans les scénarios multithreads.

En utilisant des barrières de mémoire de manière implicite avant et après les opérations de lecture volatile ou pendant les écritures volatiles, volatile garantit le bon ordre des opérations mémoire, améliorant ainsi la sécurité des fils et la cohérence des données dans les environnements concurrents, contrairement aux problèmes qui pourraient survenir lors de l'utilisation d'un objet non-volatile.

Objectif du mot-clé volatile

Le mot-clé volatile en C# est principalement utilisé pour gérer les situations où plusieurs threads se synchronisent de manière incorrecte pour accéder et modifier l'emplacement mémoire des données partagées. Dans les environnements multithread, le compilateur peut optimiser les accès à la mémoire d'une manière qui pourrait entraîner un comportement imprévisible si le modificateur volatile n'est pas présent.

Les développeurs peuvent indiquer au compilateur que la valeur d'un champ peut changer de manière asynchrone et que l'intégrité des données nécessite un accès direct à la mémoire en désignant le champ comme volatile.

Comportement des mots-clés volatils

Le compilateur et le moteur d'exécution veillent à ce que chaque opération de lecture et d'écriture sur un champ marqué comme volatile évite d'utiliser toute méthode de mise en cache possible. Cela signifie que la valeur d'un champ volatil sera toujours extraite de la mémoire principale lors d'un accès ultérieur, même si un thread la met en cache, au lieu de dépendre de la même valeur une fois qu'elle a été mise en cache. De même, les modifications effectuées par un thread sont visibles par tous les autres threads accédant au même champ, puisque les écritures dans un champ volatil sont instantanément propagées dans la mémoire.

Utilisation de l'état volatil pour l'état partagé

Utilisons quelques exemples de code pour démontrer comment utiliser le mot-clé volatile.

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();
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

La classe SharedStateExample dans cet exemple possède un champ isRunning qui est marqué comme un objet volatile. Une méthode ChangeState est conçue pour changer l'état, et une méthode ReadState établit un état d'opération de lecture volatile.

Pendant que la méthode ReadState vérifie en continu la valeur de isRunning, la méthode ChangeState retarde et définit ensuite isRunning sur false. Les modifications effectuées par un seul thread sont instantanément visibles par l'autre thread grâce à la volatilité de isRunning.

Verrouillage doublement vérifié avec des substances volatiles

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));
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dans cet exemple, nous utilisons des mécanismes de verrouillage à double vérification pour construire un modèle Singleton sûr pour les threads. Pour garantir que les modifications effectuées entre plusieurs threads sont à jour et visibles, le champ _instance est désigné comme volatile. Cela évite les situations où un seul thread remarque une instance de Singleton qui n'est qu'à moitié initialisée. Même dans un contexte multithread, le mécanisme de verrouillage à double vérification garantit qu'une seule instance du Singleton est produite.

Qu'est-ce qu'IronPDF ?

La bibliothèque C# IronPDF - Génération et Édition de PDF permet aux programmeurs de créer, modifier et rendre des documents PDF dans des applications .NET. Ses nombreuses fonctionnalités simplifient le travail avec les fichiers PDF. Les documents PDF existants peuvent être modifiés, divisés et fusionnés. Les documents PDF peuvent être créés en HTML, en images et sous d'autres formes. Les PDF peuvent contenir du texte, des photos et d'autres données annotées.

Caractéristiques d'IronPDF

Annotation de textes et d'images

Avec IronPDF, vous pouvez annoter par programme des documents PDF avec du texte, des images et d'autres données. Cet outil permet d'annoter les fichiers PDF avec des signatures, des tampons et des commentaires.

Sécurité PDF

IronPDF vous permet de spécifier différentes autorisations, notamment l'impression, la copie et la modification du document, et il peut crypter les documents PDF avec des mots de passe. Cela permet de contrôler qui a accès aux fichiers PDF et de protéger les informations confidentielles.

Remplir des formulaires PDF interactifs

Avec IronPDF, les formulaires PDF interactifs peuvent être remplis par programme. Cette fonctionnalité est utile pour créer des documents personnalisés en fonction des entrées de l'utilisateur et pour automatiser les soumissions de formulaires.

Compression et optimisation des PDF

IronPDF propose des choix d'optimisation et de compression de fichiers PDF qui minimisent la taille sans sacrifier la qualité. Par conséquent, les documents PDF nécessitent moins d'espace de stockage et fonctionnent plus efficacement.

Compatibilité multiplateforme

IronPDF est conçu pour fonctionner parfaitement avec les programmes .NET sur une variété de systèmes d'exploitation, notamment Windows, Linux et macOS. Des frameworks .NET bien connus comme ASP.NET, .NET Core et Xamarin y sont intégrés.

Créer un nouveau projet Visual Studio

La création d'un projet de console dans Visual Studio est un processus simple. Pour lancer une application console, suivez ces étapes simples dans l'environnement Visual Studio :

Avant d'utiliser Visual Studio, assurez-vous qu'il est installé sur votre ordinateur.

Démarrer un nouveau projet

Sélectionnez Fichier, puis Nouveau, et enfin Projet.

C# Volatile (Fonctionnement pour les développeurs) : Figure 1

Dans la boîte "Créer un nouveau projet", sélectionnez votre langage de programmation préféré (C#, par exemple) dans la liste à gauche.

La liste de références de modèles de projet suivante dispose du modèle "Console App" ou "Console App (.NET Core)" disponible pour sélection.

Donnez un nom à votre projet dans le champ "Nom".

C# Volatile (Comment ça fonctionne pour les développeurs) : Figure 2

Sélectionnez l'endroit où le projet sera conservé.

En cliquant sur "Créer", le projet d'application Console démarre.

C# Volatile (Comment ça fonctionne pour les développeurs) : Figure 3

Installation d'IronPDF

L'option de menu Outils de Visual Studio sous Outils contient l'interface Visual Command-Line. Sélectionnez le gestionnaire de paquets NuGet. Dans l'onglet du terminal de gestion des paquets, vous devez taper la commande suivante.

Install-Package IronPdf
Install-Package IronPdf
'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf
$vbLabelText   $csharpLabel

Vous pouvez également utiliser le gestionnaire de paquets. L'option NuGet Package Manager permet d'installer le paquetage directement dans la solution. Utilisez le champ de recherche du site web du NuGet Manager pour localiser les packages. L'exemple de capture d'écran qui suit montre à quel point il est facile de rechercher "IronPDF" dans le gestionnaire de paquets :

C# Volatile (Comment ça fonctionne pour les développeurs) : Figure 4 - Installation de IronPDF à partir du gestionnaire de paquets NuGet

Les résultats de la recherche sont affichés dans l'image ci-dessus. Veuillez apporter les modifications suivantes afin que le logiciel s'installe plus facilement sur votre machine.

Après avoir téléchargé et installé le paquet, nous pouvons maintenant l'utiliser dans le projet en cours.

Assurer la sécurité des fils dans la génération de PDF avec C# ; Volatile et IronPDF

Maintenant, utilisons IronPDF et le mot-clé volatile ensemble dans un programme C#. IronPDF est une bibliothèque C# très appréciée pour la création et la modification de documents PDF. La sécurité des threads doit être maintenue lors de l'utilisation d'applications multithreads qui utilisent IronPDF pour la création ou le traitement de PDF.

Voici un exemple qui montre comment utiliser le mot-clé volatile d'IronPDF pour créer des documents PDF dans un environnement multithread.

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(content);
        // 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(content);
        // 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();
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

volatile bool isRunning : Nous désignons un champ isRunning comme une variable volatile pour indiquer la possibilité que plusieurs threads y apportent des modifications. La génération du document PDF est gérée par ce champ. La création du PDF se poursuit si isRunning est vrai ; si ce n'est pas le cas, il abandonne.

GeneratePdf(string filePath) : Cette fonction lance un nouveau thread qui crée des documents PDF selon un calendrier. Nous vérifions continuellement le drapeau isRunning à l'intérieur du thread principal. Le cas échéant, nous utilisons IronPDF pour créer un document PDF et l'enregistrer dans le répertoire de fichiers désigné.

StopPdfGeneration() : Cette fonction permet d'arrêter la création de PDFs. Pour maintenir la sécurité des threads tout en modifiant le drapeau isRunning, il se verrouille sur un objet privé appelé lock.

GenerateDocument(string filePath) : Cette fonction contient le code nécessaire pour utiliser IronPDF afin de créer un document PDF. Une instance de HtmlToPdf est créée, l'information HTML est chargée, convertie en document PDF, et le PDF est enregistré dans le répertoire de fichiers désigné.

Main(string[] args) : La classe PdfGenerator est instanciée, la génération de PDF est démarrée et l'utilisateur est invité à arrêter la génération de PDF en appuyant sur n'importe quelle touche dans la méthode Main.

C# Volatile (Comment cela fonctionne pour les développeurs): Figure 5

Cet exemple montre comment générer de manière fiable des documents PDF dans un cadre multithread en utilisant IronPDF et le mot-clé volatile. Nous contrôlons efficacement le processus de création de PDF en utilisant volatile pour garantir que les modifications du drapeau isRunning soient immédiatement visibles à travers les threads. Nous utilisons également un verrou pour accéder et modifier le drapeau isRunning tout en préservant la sécurité des threads de travail.

C# Volatile (Comment cela fonctionne pour les développeurs) : Figure 6

Conclusion

En résumé, l'incorporation du mot-clé volatile dans IronPDF offre un moyen solide de garantir la sécurité des threads lors de la création de fichiers PDF dans des programmes C# multithreadés. Nous garantissons une prise de conscience en temps voulu et une synchronisation correcte des modifications entre les fils de discussion en désignant les drapeaux de contrôle partagés comme volatiles, ce qui permet de contrôler efficacement le processus de production des PDF.

En s'assurant que les modifications apportées aux indicateurs de contrôle sont instantanément diffusées à tous les threads, volatile est utilisé pour éviter les conflits et favoriser une coordination efficace des processus impliqués dans la création de PDF.

Les applications peuvent gérer efficacement de nombreux processus de génération de PDF simultanément sans courir le risque d'une corruption des données ou de situations de course, grâce à cette approche qui améliore l'évolutivité et la fiabilité de la génération de PDF dans des contextes concurrents.

Enfin, vous pouvez travailler efficacement avec les codes-barres, créer des PDF, effectuer de l'OCR et vous connecter à Excel en incluant IronPDF et explorer tout le potentiel des bibliothèques d'Iron Software en toute simplicité. Iron Software combine sans effort la performance, la compatibilité et la facilité d'utilisation de sa suite polyvalente pour offrir des capacités d'application améliorées et un développement plus efficace.

Les développeurs peuvent choisir le meilleur modèle en toute confiance s'il existe des options de licence claires et adaptées aux besoins particuliers du projet. Ces avantages permettent aux développeurs de relever efficacement et de manière transparente toute une série de défis.

Chaknith Bin
Chaknith Bin
  Discutez avec l'équipe d'ingénierie maintenant
Ingénieur logiciel
Chaknith travaille sur IronXL et IronBarcode. Il possède une expertise approfondie en C# et .NET, aidant à améliorer le logiciel et à soutenir les clients. Ses idées issues des interactions avec les utilisateurs contribuent à de meilleurs produits, une documentation améliorée et une expérience globale enrichie.
< PRÉCÉDENT
C# TryParse (Comment cela fonctionne pour les développeurs)
SUIVANT >
C# Task.Run (Comment ça marche pour les développeurs)

Signaler un problème

Prêt à commencer ? Version : 2025.5 vient de paraître

Commencer gratuitement
NuGet Télécharger Téléchargement de DLL Installateur Windows Démarrer l'essai gratuit
Voir les licences > ;
Experience the full power of IronPDF Démarrer l'essai gratuit
Textlogo Iron Suite related to C# Volatile (Comment ça marche pour les développeurs)

IronPDF fait partie d'IRONSUITE

10 produits .NET API pour vos documents de bureau

Obtenez 10 produits pour le prix de 2   Démarrer l'essai gratuit