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)

Publié 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 la file d'attente prioritaire C

  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 d'attente prioritaire est qu'elle permet une récupération efficace de l'élément ayant la priorité la plus élevée(ou la valeur de priorité la plus basse, en fonction de la mise en œuvre) est toujours à l'avant-garde. 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'y ait pas de classe PriorityQueueue dans la bibliothèque standard de C#, vous pouvez en créer une vous-même ou utiliser des bibliothèques tierces qui offrent 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 classés en fonction de leur priorité à l'aide d'une file d'attente. 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 d'attente prioritaires vous permettent d'utiliser des classes de "comparateurs" personnalisées ou de construire des comparaisons personnalisées, ce qui permet de trier les 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, l'extraction de l'élément le plus prioritaire - ou le moins prioritaire, selon la manière dont il est mis en œuvre - nécessite un temps constant. Cette caractéristique est particulièrement utile pour les algorithmes qui doivent obtenir rapidement l'élément le plus important.

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
VB   C#

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 le site web de l'entrepriseDocumentation IronPDF.

La principale caractéristique d'IronPDF est sa**Conversion de HTML en PDF qui gère 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
VB   C#

Caractéristiques d'IronPDF

  • Conversion de HTML en PDF : IronPDF peut convertir n'importe quel 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 par programmation du texte, des graphiques et d'autres objets aux 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 : Cette bibliothèque est utile dans les situations où des 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.
  • Caractéristiques de sécurité : IronPDF prend en charge la sécurité des mots de passe et des autorisations, 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 du flux de travail : Pour maximiser l'efficacité de la production de documents, la file d'attente prioritaire veille à ce que les travaux les plus prioritaires soient achevés avant ceux qui le sont moins.
  • Priorité ajustable : En changeant les valeurs/niveaux de priorité et les critères, vous pouvez rapidement modifier la file d'attente des priorités pour l'adapter à diverses circonstances.
  • Intégration en douceur : 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'étend au fur et à mesure que le programme grandit et peut gérer davantage d'actions liées à la création de PDF.

    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
VB   C#

Dans ce cas, les travaux PDF avec différentes priorités associées sont mis en file d'attente dans la file d'attente prioritaire(pdfTaskQueue) par la classe PdfGenerator. Les travaux les plus prioritaires sont traités en premier grâce à la PriorityQueueue. 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# (Comment ça marche pour les développeurs) : Figure 1

Exemple de fichier de sortie :

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

En fonction du 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, reportez-vous à la sectionExemples d'IronPDF HTML vers PDF.

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 d'IronPDF comprend un an de maintenance du logiciel, 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 d'IronPDF, les licences et la version d'essai gratuite, consultez le site Web de l'entrepriseInformations sur les licences IronPDF. Pour plus d'informations sur Iron Software, consultez le site web de l'entrepriseSite web d'Iron Software.

< 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 : 2024.12 vient de paraître

Téléchargement gratuit de NuGet Nombre total de téléchargements : 11,622,374 Voir les licences > ;