1. IronPDF
  2. IronPDF Blog
  3. aide .NET
  4. csharp-priority-queue-guide
AIDE .NET

File d'attente prioritaire en C# (Comment ça marche pour les développeurs)

Chaknith Bin
Chaknith Bin
février 18, 2024
Partager:

Introduction

La programmation en C# est assez souple, et IronPDF est une bibliothèque solide qui facilite le travail avec les documents, notamment lors de la création et de la modification de fichiers PDF. Ce billet explique l'idée d'une file d'attente prioritaire en C# et vous montre comment l'utiliser efficacement avec IronPDF pour optimiser les procédures de traitement des documents. Dans cet article, nous allons utiliser la file d'attente prioritaire C# ainsi qu'IronPDF.

Comment utiliser C# ; File d'attente prioritaire

  1. Créez un nouveau projet C# et créez un objet File d'attente prioritaire.

  2. Mettre en file d'attente les éléments avec des priorités.

  3. Mettre en file d'attente l'élément le plus prioritaire.

  4. Aperçu de l'élément le plus prioritaire.

  5. Vérifier si la file d'attente prioritaire est vide.

  6. Exécutez le code et éliminez les objets.

File d'attente prioritaire

Une structure de données appelée file d'attente de priorité garde la trace de plusieurs composants, chacun d'entre eux ayant une priorité qui lui est attribuée. La caractéristique essentielle d'une file de priorité est qu'elle permet une récupération efficace, car l'élément avec la plus haute priorité (ou la valeur de priorité la plus basse, selon l'implémentation) est toujours en tête. Les files d'attente prioritaires sont fréquemment utilisées dans les situations où les tâches ou les éléments doivent être traités dans un certain ordre en fonction de leur priorité.

Bien qu'il n'existe pas de classe PriorityQueue dans la bibliothèque standard de C#, vous pouvez en créer une vous-même ou utiliser des bibliothèques tierces qui proposent cette structure de données. Le tas de tableaux a une capacité initiale et un nouveau tas d'une plus grande capacité est formé lorsqu'il se remplit et que nous essayons de mettre en file d'attente un nouvel élément. Deux composants sont servis dans le même ordre qu'ils ont été mis en file d'attente s'ils ont la même priorité. Pour éviter les situations de course, vous devez développer votre propre code pour gérer la sécurité des threads.

Lorsque des composants ont des priorités correspondantes et doivent être traités en fonction de ces priorités, une file d'attente prioritaire en C# offre plusieurs avantages.

Voici quelques avantages de l'utilisation d'une file d'attente prioritaire dans le C# ;

  • Ordre de priorité : Les éléments sont automatiquement maintenus dans l'ordre en fonction de leur priorité à l'aide d'une file d'attente de priorité. Cela rend le traitement basé sur les priorités plus efficace en garantissant que les composants ayant des priorités plus élevées sont traités avant ceux ayant des priorités plus faibles.
  • Comparaisons personnalisables : les files de priorité vous permettent d'utiliser des classes de comparer personnalisées ou de construire des comparaisons sur mesure, ce qui rend possible le tri des données selon des normes complexes. Cette fonction est utile lorsque l'on travaille avec des objets qui ont plusieurs caractéristiques ou une logique de priorité personnalisée.
  • Récupération Rapide : Dans la plupart des cas, récupérer l'élément avec la plus grande priorité—ou la plus basse, selon la façon dont elle est implantée—nécessite un temps constant. Ceci est particulièrement utile pour les algorithmes qui ont besoin d'obtenir rapidement la pièce la plus importante.

Mise en œuvre d'une file d'attente prioritaire dans C# ;

Utilisons un tas binaire pour construire un système de file d'attente prioritaire C# de base. Gardez à l'esprit que vous souhaiterez peut-être exploiter des bibliothèques préexistantes ou envisager une approche plus complexe pour une utilisation en production.

public class PriorityQueue<T>
{
    private List<T> elements;
    private readonly IComparer<T> comparer;
    public PriorityQueue(IComparer<T> comparer)
    {
        this.elements = new List<T>();
        this.comparer = comparer;
    }
    public int Count => elements.Count;
    public void Enqueue(T item)
    {
        elements.Add(item);
        int index = Count - 1;
        while (index > 0)
        {
            int parentIndex = (index - 1) / 2;
            if (comparer.Compare(elements[parentIndex], elements[index]) <= 0)
                break;
            Swap(index, parentIndex);
            index = parentIndex;
        }
    }
    public T Dequeue()
    {
        if (Count == 0)
            throw new InvalidOperationException("Queue is empty.");
        T front = elements[0];
        elements[0] = elements[Count - 1];
        elements.RemoveAt(Count - 1);
        int index = 0;
        while (true)
        {
            int leftChild = 2 * index + 1;
            if (leftChild >= Count)
                break;
            int rightChild = leftChild + 1;
            int minChild = (rightChild < Count && comparer.Compare(elements[rightChild], elements[leftChild]) < 0)
                ? rightChild
                : leftChild;
            if (comparer.Compare(elements[index], elements[minChild]) <= 0)
                break;
            Swap(index, minChild);
            index = minChild;
        }
        return front;
    }
    private void Swap(int i, int j)
    {
        T temp = elements[i];
        elements[i] = elements[j];
        elements[j] = temp;
    }
}
public class PriorityQueue<T>
{
    private List<T> elements;
    private readonly IComparer<T> comparer;
    public PriorityQueue(IComparer<T> comparer)
    {
        this.elements = new List<T>();
        this.comparer = comparer;
    }
    public int Count => elements.Count;
    public void Enqueue(T item)
    {
        elements.Add(item);
        int index = Count - 1;
        while (index > 0)
        {
            int parentIndex = (index - 1) / 2;
            if (comparer.Compare(elements[parentIndex], elements[index]) <= 0)
                break;
            Swap(index, parentIndex);
            index = parentIndex;
        }
    }
    public T Dequeue()
    {
        if (Count == 0)
            throw new InvalidOperationException("Queue is empty.");
        T front = elements[0];
        elements[0] = elements[Count - 1];
        elements.RemoveAt(Count - 1);
        int index = 0;
        while (true)
        {
            int leftChild = 2 * index + 1;
            if (leftChild >= Count)
                break;
            int rightChild = leftChild + 1;
            int minChild = (rightChild < Count && comparer.Compare(elements[rightChild], elements[leftChild]) < 0)
                ? rightChild
                : leftChild;
            if (comparer.Compare(elements[index], elements[minChild]) <= 0)
                break;
            Swap(index, minChild);
            index = minChild;
        }
        return front;
    }
    private void Swap(int i, int j)
    {
        T temp = elements[i];
        elements[i] = elements[j];
        elements[j] = temp;
    }
}
Public Class PriorityQueue(Of T)
	Private elements As List(Of T)
	Private ReadOnly comparer As IComparer(Of T)
	Public Sub New(ByVal comparer As IComparer(Of T))
		Me.elements = New List(Of T)()
		Me.comparer = comparer
	End Sub
	Public ReadOnly Property Count() As Integer
		Get
			Return elements.Count
		End Get
	End Property
	Public Sub Enqueue(ByVal item As T)
		elements.Add(item)
		Dim index As Integer = Count - 1
		Do While index > 0
			Dim parentIndex As Integer = (index - 1) \ 2
			If comparer.Compare(elements(parentIndex), elements(index)) <= 0 Then
				Exit Do
			End If
			Swap(index, parentIndex)
			index = parentIndex
		Loop
	End Sub
	Public Function Dequeue() As T
		If Count = 0 Then
			Throw New InvalidOperationException("Queue is empty.")
		End If
		Dim front As T = elements(0)
		elements(0) = elements(Count - 1)
		elements.RemoveAt(Count - 1)
		Dim index As Integer = 0
		Do
			Dim leftChild As Integer = 2 * index + 1
			If leftChild >= Count Then
				Exit Do
			End If
			Dim rightChild As Integer = leftChild + 1
			Dim minChild As Integer = If(rightChild < Count AndAlso comparer.Compare(elements(rightChild), elements(leftChild)) < 0, rightChild, leftChild)
			If comparer.Compare(elements(index), elements(minChild)) <= 0 Then
				Exit Do
			End If
			Swap(index, minChild)
			index = minChild
		Loop
		Return front
	End Function
	Private Sub Swap(ByVal i As Integer, ByVal j As Integer)
		Dim temp As T = elements(i)
		elements(i) = elements(j)
		elements(j) = temp
	End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF

Grâce à la bibliothèque IronPDF for NET, les programmeurs peuvent utiliser le langage C# pour générer, éditer et modifier des documents PDF. Le logiciel offre un éventail d'outils et de fonctionnalités pour faciliter diverses opérations avec les fichiers PDF, y compris, mais sans s'y limiter, la création de PDF à partir de HTML, la conversion de HTML en PDF, la combinaison ou la division de documents PDF et l'ajout de texte, de photos et d'annotations à des PDF préexistants. Pour en savoir plus sur IronPDF, consultez la Documentation IronPDF.

La principale fonctionnalité d'IronPDF est sa fonction de conversion HTML en PDF, qui préserve les mises en page et les styles. Il convertit le contenu web en PDF, idéal pour les rapports, les factures et la documentation. Il s'agit notamment de convertir des fichiers HTML, des URL et des chaînes HTML en 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");
    }
}
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
$vbLabelText   $csharpLabel

Caractéristiques d'IronPDF

  • Conversion de HTML en PDF : IronPDF peut convertir tout type de données HTML, telles que des fichiers, des URL et des chaînes de code HTML, en documents PDF.
  • Génération de PDF : Le langage de programmation C# peut être utilisé pour ajouter du texte, des graphiques et d'autres objets par le biais de la programmation à des documents PDF.
  • Manipulation de PDF : IronPDF peut modifier des fichiers PDF existants et diviser un fichier PDF en plusieurs fichiers. Il peut combiner plusieurs fichiers PDF en un seul fichier.
  • Formulaires PDF : La bibliothèque est utile dans les situations où les données de formulaire doivent être collectées et traitées, car elle permet aux utilisateurs de créer et de remplir des formulaires PDF.
  • Fonctionnalités de sécurité : La sécurité par mot de passe et autorisations est prise en charge par IronPDF, ainsi que le cryptage des documents PDF.

File d'attente prioritaire avec IronPDF

Maintenant que nous connaissons les principes de base d'une file d'attente prioritaire, voyons comment IronPDF et cette file d'attente peuvent fonctionner ensemble pour traiter les documents plus rapidement. Imaginez une situation où vous devez produire des documents PDF avec des priorités ou des niveaux d'urgence différents.

Avantages de la file d'attente prioritaire avec IronPDF

  • Création Dynamique de Documents : Vous pouvez produire dynamiquement des documents PDF selon différents degrés d'urgence ou de priorité en utilisant une nouvelle file d'attente prioritaire.
  • Gestion efficace des flux de travail : Pour maximiser l'efficacité de la génération de documents, la file d'attente prioritaire assure que les tâches avec une priorité plus élevée sont terminées avant celles avec une priorité moindre.
  • Priorisation ajustable : En modifiant les valeurs/niveaux de priorité et les critères, vous pouvez rapidement ajuster la file de priorité pour s'adapter à diverses circonstances.
  • Intégration fluide : La génération de documents basée sur la priorité peut être facilement intégrée dans votre application en utilisant IronPDF en conjonction avec la même file d’attente prioritaire.

  • Évolutivité : La nouvelle file d'attente prioritaire s'agrandit à mesure que le programme s'intensifie et peut gérer davantage d'actions liées à la création de PDFs.

    Vous trouverez ci-dessous un exemple de code pour la file d'attente prioritaire à l'aide d'IronPDF.

using IronPdf;
using System;
public class PdfGenerator
{
    static void Main()
    {
        // Create a priority queue of PDF tasks
        PriorityQueue<PdfTask> pdfTaskQueue = new PriorityQueue<PdfTask>(new PdfTaskComparer());
        // Enqueue PDF tasks with different priorities
        pdfTaskQueue.Enqueue(new PdfTask("High Priority Document", Priority.High));
        pdfTaskQueue.Enqueue(new PdfTask("Medium Priority Document", Priority.Medium));
        pdfTaskQueue.Enqueue(new PdfTask("Low Priority Document", Priority.Low));
        // Process PDF tasks in priority order
        while (pdfTaskQueue.Count > 0)
        {
            PdfTask nextTask = pdfTaskQueue.Dequeue();
            GeneratePdf(nextTask);
        }
    }
    static void GeneratePdf(PdfTask pdfTask)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>");
        // Save the PDF to a file
        string pdfFilePath = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf";
        pdf.SaveAs(pdfFilePath);
        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}
public class PdfTask
{
    public string Content { get; }
    public Priority Priority { get; }
    public PdfTask(string content, Priority priority)
    {
        Content = content;
        Priority = priority;
    }
}
public enum Priority
{
    Low,
    Medium,
    High
}
public class PdfTaskComparer : IComparer<PdfTask>
{
    public int Compare(PdfTask x, PdfTask y)
    {
        // Higher priority should come first
        return y.Priority.CompareTo(x.Priority);
    }
}
using IronPdf;
using System;
public class PdfGenerator
{
    static void Main()
    {
        // Create a priority queue of PDF tasks
        PriorityQueue<PdfTask> pdfTaskQueue = new PriorityQueue<PdfTask>(new PdfTaskComparer());
        // Enqueue PDF tasks with different priorities
        pdfTaskQueue.Enqueue(new PdfTask("High Priority Document", Priority.High));
        pdfTaskQueue.Enqueue(new PdfTask("Medium Priority Document", Priority.Medium));
        pdfTaskQueue.Enqueue(new PdfTask("Low Priority Document", Priority.Low));
        // Process PDF tasks in priority order
        while (pdfTaskQueue.Count > 0)
        {
            PdfTask nextTask = pdfTaskQueue.Dequeue();
            GeneratePdf(nextTask);
        }
    }
    static void GeneratePdf(PdfTask pdfTask)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>");
        // Save the PDF to a file
        string pdfFilePath = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf";
        pdf.SaveAs(pdfFilePath);
        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}
public class PdfTask
{
    public string Content { get; }
    public Priority Priority { get; }
    public PdfTask(string content, Priority priority)
    {
        Content = content;
        Priority = priority;
    }
}
public enum Priority
{
    Low,
    Medium,
    High
}
public class PdfTaskComparer : IComparer<PdfTask>
{
    public int Compare(PdfTask x, PdfTask y)
    {
        // Higher priority should come first
        return y.Priority.CompareTo(x.Priority);
    }
}
Imports IronPdf
Imports System
Public Class PdfGenerator
	Shared Sub Main()
		' Create a priority queue of PDF tasks
		Dim pdfTaskQueue As New PriorityQueue(Of PdfTask)(New PdfTaskComparer())
		' Enqueue PDF tasks with different priorities
		pdfTaskQueue.Enqueue(New PdfTask("High Priority Document", Priority.High))
		pdfTaskQueue.Enqueue(New PdfTask("Medium Priority Document", Priority.Medium))
		pdfTaskQueue.Enqueue(New PdfTask("Low Priority Document", Priority.Low))
		' Process PDF tasks in priority order
		Do While pdfTaskQueue.Count > 0
			Dim nextTask As PdfTask = pdfTaskQueue.Dequeue()
			GeneratePdf(nextTask)
		Loop
	End Sub
	Private Shared Sub GeneratePdf(ByVal pdfTask As PdfTask)
		' Create a new PDF document using IronPDF
		Dim renderer As New IronPdf.HtmlToPdf()
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf($"<h1>{pdfTask.Content}</h1>")
		' Save the PDF to a file
		Dim pdfFilePath As String = $"{pdfTask.Priority}_{Guid.NewGuid()}.pdf"
		pdf.SaveAs(pdfFilePath)
		' Display a message with the file path
		Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}")
	End Sub
End Class
Public Class PdfTask
	Public ReadOnly Property Content() As String
	Public ReadOnly Property Priority() As Priority
	Public Sub New(ByVal content As String, ByVal priority As Priority)
		Me.Content = content
		Me.Priority = priority
	End Sub
End Class
Public Enum Priority
	Low
	Medium
	High
End Enum
Public Class PdfTaskComparer
	Implements IComparer(Of PdfTask)

	Public Function Compare(ByVal x As PdfTask, ByVal y As PdfTask) As Integer Implements IComparer(Of PdfTask).Compare
		' Higher priority should come first
		Return y.Priority.CompareTo(x.Priority)
	End Function
End Class
$vbLabelText   $csharpLabel

Dans ce cas, les tâches PDF avec des priorités associées variables sont mises en file d'attente dans la file de priorité (pdfTaskQueue) par la classe PdfGenerator. Les travaux de priorité supérieure sont traités en premier grâce à la PriorityQueue. Nous utilisons la méthode Enqueue pour ajouter l'élément à la file d'attente prioritaire. Nous pouvons également utiliser la méthode Dequeue pour retirer et récupérer les valeurs les plus prioritaires. Nous pouvons utiliser la méthode "peek" pour visualiser la priorité la plus élevée sans retirer l'élément.

File d'attente prioritaire C# (Fonctionnement pour les développeurs) : Figure 1

Exemple de fichier de sortie :

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

Basé sur le contenu du travail, la fonction GeneratePdf utilise IronPDF pour construire un document PDF, qui est ensuite enregistré dans un fichier. Pour en savoir plus sur le code IronPDF, consultez les Exemples de HTML à PDF d'IronPDF.

Conclusion

Lorsque IronPDF et une file d'attente prioritaire sont combinés dans une application C#, il est possible de générer des documents rapidement et dynamiquement en fonction de différentes priorités ou niveaux d'urgence. Cette méthode fonctionne particulièrement bien dans les situations où certains documents doivent être traités et fournis avant d'autres.

Votre application peut gérer les tâches de création de documents de manière flexible, évolutive et prioritaire en utilisant les capacités de conversion HTML vers PDF d'IronPDF et en intégrant une file d'attente prioritaire pour la gestion des tâches. Le cadre d'intégration de ces idées a été défini dans cet article ; une personnalisation supplémentaire peut être utilisée pour répondre aux exigences particulières de vos opérations de traitement des documents. En combinant IronPDF avec une file d'attente prioritaire, vous pouvez obtenir une solution de traitement de documents efficace et hiérarchisée pour C#, que vous conceviez un outil de création de rapports, un système de gestion de documents ou toute autre application générant des PDF.

L'édition Lite $749 d'IronPDF comprend un an de maintenance logicielle, des options de mise à niveau et une licence permanente. Les utilisateurs peuvent évaluer le produit en situation réelle pendant la période d'essai en filigrane. Pour plus d'informations sur le coût, les licences et l'essai gratuit d'IronPDF, consultez les informations sur les licences IronPDF. Pour plus d'informations sur Iron Software, consultez le site Web d'Iron Software.

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# LINQ Distinct (Comment ça marche pour les développeurs)
SUIVANT >
Classe scellée C# (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 File d'attente prioritaire en C# (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