C# ObservableCollection (Comment cela fonctionne pour les développeurs)

Introduction

En C#, la ObservableCollectionest une structure de données puissante qui informe automatiquement les auditeurs lorsque des éléments sont ajoutés, supprimés ou modifiés. C'est particulièrement utile pour les scénarios de collecte de données dynamiques, comme lorsque vous avez besoin de refléter les changements en temps réel dans votre interface utilisateur ou vos rapports. Lorsqu'il est combiné avec IronPDF, cette puissante collection peut être utilisée pour générer des PDF dynamiques basés sur des données en temps réel.

IronPDF est une bibliothèque robuste pour générer des PDF en C#. Avec ses capacités de conversion HTML en PDF, il est facile de créer des PDF de haute qualité, que vous ayez besoin de générer des factures, des rapports ou tout autre document basé sur des données en temps réel. Dans cet article, nous vous montrerons comment intégrer la classe ObservableCollection avec IronPDF, en utilisant la liaison de données pour générer un PDF qui se met à jour dynamiquement lorsque les données changent.

Comprendre ObservableCollection

Qu'est-ce qu'une ObservableCollection ?

La classe ObservableCollectionen C# implémente l'interface INotifyCollectionChanged, qui fournit des notifications lorsque des éléments sont ajoutés, supprimés ou modifiés. Il est couramment utilisé pour la liaison de données dans des applications d'interface utilisateur comme WPF, où les modifications apportées à la collection déclenchent automatiquement des mises à jour dans l'interface utilisateur. Contrairement à d'autres collections comme List, une ObservableCollection offre des notifications d'événements intégrées, ce qui la rend parfaite pour les scénarios où les données doivent être reflétées en temps réel.

La ObservableCollection gère automatiquement les modifications de l'ensemble de la collection, ce qui facilite la gestion et l'affichage des données dynamiques dans votre application.

Cas d'utilisation courants

• Liaison avec les composants UI : Dans WPF, par exemple, ObservableCollection est souvent utilisé pour lier des données à des contrôles tels que ListView, DataGrid et ComboBox. Lorsque la collection sous-jacente change, l'interface utilisateur est automatiquement mise à jour.
• Mises à jour en temps réel : Lorsque les données changent fréquemment, ObservableCollection garantit que l'interface utilisateur est toujours synchronisée. Par exemple, vous pourriez l'utiliser pour un rapport en direct où de nouvelles entrées de données sont ajoutées à la collection en temps réel, et le rapport se met à jour en conséquence.
• Modifications dynamiques : Si votre application permet aux utilisateurs d'ajouter, de supprimer ou de modifier des données, ObservableCollection peut être utilisé pour refléter automatiquement ces modifications dans l'interface utilisateur ou d'autres composants.

Travailler avec IronPDF

Présentation d'IronPDF

Ajouter depuis PixabayTéléverser

ou faites glisser et déposez une image ici

Ajouter un texte alternatif à l'image

Comme nous l'avons mentionné au début de cet article, IronPDF est une bibliothèque de génération de PDF pour .NET qui facilite la création, la modification et l'affichage de documents PDF. Contrairement à certaines autres bibliothèques PDF, IronPDF offre un ensemble riche de fonctionnalités qui simplifient le travail avec les PDFs, telles que la conversion de HTML en PDF, l'ajout de filigranes, la manipulation de PDFs existants, et plus encore.

IronPDF permet également aux développeurs de rendre des PDF à partir de différentes sources de données, y compris HTML, images et texte brut, ce qui peut être particulièrement utile lorsque vous devez présenter des données dynamiques. Avec l'API d'IronPDF, vous pouvez générer des PDF de haute qualité, y compris des mises en page détaillées, des tableaux, des images et des styles.

Installation de IronPDF

Pour commencer avec IronPDF, vous devez installer la bibliothèque via NuGet. Vous pouvez l'ajouter à votre projet en exécutant la commande suivante dans la console du gestionnaire de packages :

Install-Package IronPdf

Install-Package IronPdf

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

Une fois installé, vous pouvez initialiser IronPDF et utiliser ses fonctionnalités puissantes. Pour cet article, nous nous concentrerons sur la génération de PDF à partir de données dynamiques dans une ObservableCollection.

Intégration d'ObservableCollection avec IronPDF

Cas d'utilisation : Générer dynamiquement des PDF à partir de ObservableCollection

Imaginons un scénario où vous devez générer un PDF de facture à partir d'une liste d'articles stockés dans une ObservableCollection. À mesure que des éléments sont ajoutés ou supprimés de la collection, le PDF doit être régénéré automatiquement pour refléter l'état actuel des données.

Pour cette tâche, ObservableCollection fournit un moyen facile de gérer les éléments de la facture, tandis qu'IronPDF nous permettra de générer et d'exporter la facture au format PDF.

Liaison des données au contenu PDF

Pour lier les données dans une ObservableCollection à un PDF, vous devez parcourir la collection et ajouter ses éléments au contenu du PDF. IronPDF fournit des méthodes pour créer des tableaux, ajouter du texte et personnaliser la disposition, ce qui facilite la représentation des données dans un format structuré.

Par exemple, si vous avez une facture avec plusieurs articles, vous pouvez générer dynamiquement le PDF en parcourant l'ObservableCollection et en ajoutant chaque article à un tableau ou une liste dans le document. IronPDF permet un haut niveau de personnalisation, y compris l'ajustement des polices, des bordures, et même l'inclusion d'images comme des logos ou des codes-barres.

Exemple Un : Génération d'un PDF en utilisant ObservableCollection

Voyons un simple exemple pour démontrer comment cela fonctionne. Supposons que vous ayez une collection de personnes (représentées par la classe Personne), et que vous souhaitiez générer un PDF reflétant les détails de ces personnes. Chaque fois qu'une nouvelle personne est ajoutée à la collection, le PDF se mettra automatiquement à jour.

Exemple de classe Personne

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

Public Class Person
	Public Property Name() As String
	Public Property Age() As Integer
End Class

Dans ce cas, la classe Person contient des propriétés de base telles que Name et Age. Nous utiliserons cette classe en conjonction avec l'ObservableCollection pour générer dynamiquement un PDF.

Création de l'ObservableCollection

using System.Collections.ObjectModel;
var collection = new ObservableCollection<Person>
{
    new Person { Name = "John Doe", Age = 30 },
    new Person { Name = "Jane Smith", Age = 28 }
};

using System.Collections.ObjectModel;
var collection = new ObservableCollection<Person>
{
    new Person { Name = "John Doe", Age = 30 },
    new Person { Name = "Jane Smith", Age = 28 }
};

Imports System.Collections.ObjectModel
Private collection = New ObservableCollection(Of Person) From {
	New Person With {
		.Name = "John Doe",
		.Age = 30
	},
	New Person With {
		.Name = "Jane Smith",
		.Age = 28
	}
}

Cette ObservableCollection contient une collection d'objets Person, chacun avec un Nom et un Âge. Lorsqu'un élément est ajouté ou supprimé, les gestionnaires d'événements sont déclenchés, ce que nous utiliserons pour mettre à jour le PDF de manière dynamique.

Ajout de gestionnaires d'événements pour les modifications de collection

Dans cet exemple, nous nous abonnons à l'événement CollectionChanged de la classe ObservableCollection pour régénérer automatiquement le PDF chaque fois que la collection change. C'est utile si vous devez répondre à des changements tels que l'ajout ou la suppression d'un objet Personne.

// Subscribe to the ObservableCollection's CollectionChanged event
collection.CollectionChanged += (object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) =>
{
    // Regenerate the PDF whenever the collection changes
    GeneratePersonPDF(collection);
};

// Subscribe to the ObservableCollection's CollectionChanged event
collection.CollectionChanged += (object sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e) =>
{
    // Regenerate the PDF whenever the collection changes
    GeneratePersonPDF(collection);
};

' Subscribe to the ObservableCollection's CollectionChanged event
AddHandler collection.CollectionChanged, Sub(sender As Object, e As System.Collections.Specialized.NotifyCollectionChangedEventArgs)
	' Regenerate the PDF whenever the collection changes
	GeneratePersonPDF(collection)
End Sub

Ajout de nouvelles personnes à la collection

Vous pouvez ajouter une nouvelle personne à la collection, et toute la collection déclenchera le gestionnaire d'événements pour régénérer le PDF. Cette approche gère automatiquement les modifications de la liste entière de personnes.

// Adding a new person to the collection
collection.Add(new Person { Name = "Alice Brown", Age = 32 });

// Adding a new person to the collection
collection.Add(new Person { Name = "Alice Brown", Age = 32 });

' Adding a new person to the collection
collection.Add(New Person With {
	.Name = "Alice Brown",
	.Age = 32
})

Chaque fois que vous ajoutez une nouvelle personne à la collection, le PDF se régénérera, incluant la nouvelle entrée.

Propriété d'âge de liaison

Vous pouvez également lier la propriété age d'une personne à un système externe (tel que l'interface utilisateur ou d'autres parties de l'application) pour refléter automatiquement les changements.

Voici un exemple de la façon dont la propriété Age serait liée dans la classe Person :

public class Person
{
    public string Name { get; set; }
    private int _age;
    public int Age 
    {
        get { return _age; }
        set
        {
            _age = value;
            // Raise property changed event here if using data binding
        }
    }
}

public class Person
{
    public string Name { get; set; }
    private int _age;
    public int Age 
    {
        get { return _age; }
        set
        {
            _age = value;
            // Raise property changed event here if using data binding
        }
    }
}

Public Class Person
	Public Property Name() As String
	Private _age As Integer
	Public Property Age() As Integer
		Get
			Return _age
		End Get
		Set(ByVal value As Integer)
			_age = value
			' Raise property changed event here if using data binding
		End Set
	End Property
End Class

Utilisation d'ObservableCollection avec Binding

Montrons l'utilisation de binding age à un élément UI, en mettant à jour la valeur de l'âge et en observant les changements reflétés dans la collection :

ObservableCollection<Person> people = new ObservableCollection<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 28 }
};
// Binding the Age of the first person to a UI element (pseudo-code)
someUIElement.Text = people[0].Age.ToString();

ObservableCollection<Person> people = new ObservableCollection<Person>
{
    new Person { Name = "John", Age = 30 },
    new Person { Name = "Jane", Age = 28 }
};
// Binding the Age of the first person to a UI element (pseudo-code)
someUIElement.Text = people[0].Age.ToString();

Dim people As New ObservableCollection(Of Person) From {
	New Person With {
		.Name = "John",
		.Age = 30
	},
	New Person With {
		.Name = "Jane",
		.Age = 28
	}
}
' Binding the Age of the first person to a UI element (pseudo-code)
someUIElement.Text = people(0).Age.ToString()

Générer le PDF avec IronPDF

Maintenant que nous avons configuré l'ObservableCollection et ajouté des gestionnaires d'événements, il est temps de se concentrer sur la génération d'un PDF qui reflète la collection dynamique de personnes.

using IronPdf;
public void GeneratePersonPDF(ObservableCollection<Person> people)
{
    var pdf = new ChromePdfRenderer();  // Initialize IronPDF's ChromePdfRenderer class
    // Create HTML content representing the people in the collection
    var htmlContent = "<h1>People Information</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                      "<tr><th>Name</th><th>Age</th></tr>";
    foreach (var person in people)
    {
        htmlContent += $"<tr><td>{person.Name}</td><td>{person.Age}</td></tr>";
    }
    htmlContent += "</table>";
    // Convert the HTML content to a PDF
    var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to disk
    pdfDocument.SaveAs("PeopleInformation.pdf");
}

using IronPdf;
public void GeneratePersonPDF(ObservableCollection<Person> people)
{
    var pdf = new ChromePdfRenderer();  // Initialize IronPDF's ChromePdfRenderer class
    // Create HTML content representing the people in the collection
    var htmlContent = "<h1>People Information</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                      "<tr><th>Name</th><th>Age</th></tr>";
    foreach (var person in people)
    {
        htmlContent += $"<tr><td>{person.Name}</td><td>{person.Age}</td></tr>";
    }
    htmlContent += "</table>";
    // Convert the HTML content to a PDF
    var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to disk
    pdfDocument.SaveAs("PeopleInformation.pdf");
}

Imports IronPdf
Public Sub GeneratePersonPDF(ByVal people As ObservableCollection(Of Person))
	Dim pdf = New ChromePdfRenderer() ' Initialize IronPDF's ChromePdfRenderer class
	' Create HTML content representing the people in the collection
	Dim htmlContent = "<h1>People Information</h1><table border='1' cellpadding='5' cellspacing='0'>" & "<tr><th>Name</th><th>Age</th></tr>"
	For Each person In people
		htmlContent &= $"<tr><td>{person.Name}</td><td>{person.Age}</td></tr>"
	Next person
	htmlContent &= "</table>"
	' Convert the HTML content to a PDF
	Dim pdfDocument = pdf.RenderHtmlAsPdf(htmlContent)
	' Save the generated PDF to disk
	pdfDocument.SaveAs("PeopleInformation.pdf")
End Sub

Exemple Deux : Générer une facture PDF à partir de ObservableCollection

Voici un exemple de génération d'un PDF à partir d'une ObservableCollection d'éléments de facture utilisant IronPDF :

Étape 1 : Classe d'exemple d'article de facture

Cette classe représente un article dans la facture, avec des propriétés pour le nom de l'article, la quantité, le prix et le prix total.

public class InvoiceItem
{
    public string ItemName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
    public decimal Total => Quantity * Price;
}

public class InvoiceItem
{
    public string ItemName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
    public decimal Total => Quantity * Price;
}

Public Class InvoiceItem
	Public Property ItemName() As String
	Public Property Quantity() As Integer
	Public Property Price() As Decimal
	Public ReadOnly Property Total() As Decimal
		Get
			Return Quantity * Price
		End Get
	End Property
End Class

Étape 2 : Exemples de ObservableCollection

Cet exemple initialise un ObservableCollection contenant plusieurs articles de facture. Vous pouvez ajouter, supprimer ou modifier dynamiquement les éléments de cette collection.

ObservableCollection<InvoiceItem> invoiceItems = new ObservableCollection<InvoiceItem>
{
    new InvoiceItem { ItemName = "Item 1", Quantity = 2, Price = 10.00m },
    new InvoiceItem { ItemName = "Item 2", Quantity = 1, Price = 25.00m },
    new InvoiceItem { ItemName = "Item 3", Quantity = 5, Price = 5.00m }
};

ObservableCollection<InvoiceItem> invoiceItems = new ObservableCollection<InvoiceItem>
{
    new InvoiceItem { ItemName = "Item 1", Quantity = 2, Price = 10.00m },
    new InvoiceItem { ItemName = "Item 2", Quantity = 1, Price = 25.00m },
    new InvoiceItem { ItemName = "Item 3", Quantity = 5, Price = 5.00m }
};

Dim invoiceItems As New ObservableCollection(Of InvoiceItem) From {
	New InvoiceItem With {
		.ItemName = "Item 1",
		.Quantity = 2,
		.Price = 10.00D
	},
	New InvoiceItem With {
		.ItemName = "Item 2",
		.Quantity = 1,
		.Price = 25.00D
	},
	New InvoiceItem With {
		.ItemName = "Item 3",
		.Quantity = 5,
		.Price = 5.00D
	}
}

Étape 3 : Générer le PDF avec IronPDF

Ici, nous créons une fonction pour générer le PDF. Cette fonction utilise les données dans l'ObservableCollection et les convertit en HTML, qui est ensuite rendu en PDF à l'aide de IronPDF.

public void GenerateInvoicePDF(ObservableCollection<InvoiceItem> items)
{
    var pdf = new ChromePdfRenderer();  // Initialize IronPDF's HtmlToPdf class
    // Create HTML content representing the invoice
    var htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                      "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>";
    foreach (var item in items)
    {
        htmlContent += $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>";
    }
    htmlContent += "</table>";
    // Convert the HTML content to a PDF
    var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to disk
    pdfDocument.SaveAs("Invoice.pdf");
}

public void GenerateInvoicePDF(ObservableCollection<InvoiceItem> items)
{
    var pdf = new ChromePdfRenderer();  // Initialize IronPDF's HtmlToPdf class
    // Create HTML content representing the invoice
    var htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                      "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>";
    foreach (var item in items)
    {
        htmlContent += $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>";
    }
    htmlContent += "</table>";
    // Convert the HTML content to a PDF
    var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
    // Save the generated PDF to disk
    pdfDocument.SaveAs("Invoice.pdf");
}

Public Sub GenerateInvoicePDF(ByVal items As ObservableCollection(Of InvoiceItem))
	Dim pdf = New ChromePdfRenderer() ' Initialize IronPDF's HtmlToPdf class
	' Create HTML content representing the invoice
	Dim htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" & "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>"
	For Each item In items
		htmlContent &= $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>"
	Next item
	htmlContent &= "</table>"
	' Convert the HTML content to a PDF
	Dim pdfDocument = pdf.RenderHtmlAsPdf(htmlContent)
	' Save the generated PDF to disk
	pdfDocument.SaveAs("Invoice.pdf")
End Sub

Étape 4 : S'abonner à l'événement CollectionChanged

Parce que ObservableCollection notifie automatiquement les changements, vous pouvez facilement régénérer le PDF chaque fois que la collection est mise à jour. Par exemple, si un article est ajouté ou supprimé, le PDF peut être régénéré avec les données mises à jour.

Voici comment vous pouvez vous abonner à l'événement CollectionChanged et régénérer le PDF chaque fois que la collection change :

// Subscribe to the ObservableCollection's CollectionChanged event
invoiceItems.CollectionChanged += (sender, e) =>
{
    // Regenerate the PDF whenever the collection changes
    GenerateInvoicePDF(invoiceItems);
};

// Subscribe to the ObservableCollection's CollectionChanged event
invoiceItems.CollectionChanged += (sender, e) =>
{
    // Regenerate the PDF whenever the collection changes
    GenerateInvoicePDF(invoiceItems);
};

' Subscribe to the ObservableCollection's CollectionChanged event
AddHandler invoiceItems.CollectionChanged, Sub(sender, e)
	' Regenerate the PDF whenever the collection changes
	GenerateInvoicePDF(invoiceItems)
End Sub

Étape 5 : Ajouter des éléments et tester

Vous pouvez maintenant tester en ajoutant de nouveaux éléments à l'ObservableCollection et en observant comment le PDF est régénéré automatiquement.

// Adding a new item to the ObservableCollection
invoiceItems.Add(new InvoiceItem { ItemName = "Item 4", Quantity = 3, Price = 12.50m });

// Adding a new item to the ObservableCollection
invoiceItems.Add(new InvoiceItem { ItemName = "Item 4", Quantity = 3, Price = 12.50m });

' Adding a new item to the ObservableCollection
invoiceItems.Add(New InvoiceItem With {
	.ItemName = "Item 4",
	.Quantity = 3,
	.Price = 12.50D
})

Exemple de code complet

using System;
using System.Collections.ObjectModel;
using IronPdf;
public class InvoiceItem
{
    public string ItemName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
    // Property to calculate the total price for each item
    public decimal Total => Quantity * Price;
}
public class InvoiceGenerator
{
    // Function to generate the invoice PDF
    public void GenerateInvoicePDF(ObservableCollection<InvoiceItem> items)
    {
        var pdf = new ChromePdfRenderer();  // Initialize IronPDF's HtmlToPdf class
        // Create HTML content representing the invoice
        var htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                          "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>";
        foreach (var item in items)
        {
            htmlContent += $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>";
        }
        htmlContent += "</table>";
        // Convert the HTML content to a PDF
        var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
        // Save the generated PDF to disk
        pdfDocument.SaveAs("Invoice.pdf");
    }
    // Main function to test the code
    public static void Main(string[] args)
    {
        var invoiceItems = new ObservableCollection<InvoiceItem>
        {
            new InvoiceItem { ItemName = "Item 1", Quantity = 2, Price = 10.00m },
            new InvoiceItem { ItemName = "Item 2", Quantity = 1, Price = 25.00m },
            new InvoiceItem { ItemName = "Item 3", Quantity = 5, Price = 5.00m }
        };
        var invoiceGenerator = new InvoiceGenerator();
        // Subscribe to the ObservableCollection's CollectionChanged event
        invoiceItems.CollectionChanged += (sender, e) =>
        {
            // Regenerate the PDF whenever the collection changes
            invoiceGenerator.GenerateInvoicePDF(invoiceItems);
        };
        // Generate initial PDF
        invoiceGenerator.GenerateInvoicePDF(invoiceItems);
        // Add a new item to the collection and automatically regenerate the PDF
        invoiceItems.Add(new InvoiceItem { ItemName = "Item 4", Quantity = 3, Price = 12.50m });
        // Remove an item and see the PDF update
        invoiceItems.RemoveAt(0);
    }
}

using System;
using System.Collections.ObjectModel;
using IronPdf;
public class InvoiceItem
{
    public string ItemName { get; set; }
    public int Quantity { get; set; }
    public decimal Price { get; set; }
    // Property to calculate the total price for each item
    public decimal Total => Quantity * Price;
}
public class InvoiceGenerator
{
    // Function to generate the invoice PDF
    public void GenerateInvoicePDF(ObservableCollection<InvoiceItem> items)
    {
        var pdf = new ChromePdfRenderer();  // Initialize IronPDF's HtmlToPdf class
        // Create HTML content representing the invoice
        var htmlContent = "<h1>Invoice</h1><table border='1' cellpadding='5' cellspacing='0'>" +
                          "<tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>";
        foreach (var item in items)
        {
            htmlContent += $"<tr><td>{item.ItemName}</td><td>{item.Quantity}</td><td>{item.Price:C}</td><td>{item.Total:C}</td></tr>";
        }
        htmlContent += "</table>";
        // Convert the HTML content to a PDF
        var pdfDocument = pdf.RenderHtmlAsPdf(htmlContent);
        // Save the generated PDF to disk
        pdfDocument.SaveAs("Invoice.pdf");
    }
    // Main function to test the code
    public static void Main(string[] args)
    {
        var invoiceItems = new ObservableCollection<InvoiceItem>
        {
            new InvoiceItem { ItemName = "Item 1", Quantity = 2, Price = 10.00m },
            new InvoiceItem { ItemName = "Item 2", Quantity = 1, Price = 25.00m },
            new InvoiceItem { ItemName = "Item 3", Quantity = 5, Price = 5.00m }
        };
        var invoiceGenerator = new InvoiceGenerator();
        // Subscribe to the ObservableCollection's CollectionChanged event
        invoiceItems.CollectionChanged += (sender, e) =>
        {
            // Regenerate the PDF whenever the collection changes
            invoiceGenerator.GenerateInvoicePDF(invoiceItems);
        };
        // Generate initial PDF
        invoiceGenerator.GenerateInvoicePDF(invoiceItems);
        // Add a new item to the collection and automatically regenerate the PDF
        invoiceItems.Add(new InvoiceItem { ItemName = "Item 4", Quantity = 3, Price = 12.50m });
        // Remove an item and see the PDF update
        invoiceItems.RemoveAt(0);
    }
}

CONVERTER NOT RUNNING

Sortie

Ajouter depuis PixabayTéléverser

ou faites glisser et déposez une image ici

Effacer le texte alternatif

Ce que le code fait

• Classe InvoiceItem : Représente un élément de facture avec des propriétés pour le nom de l'article (ItemName), la quantité (Quantity), le prix (Price) et un total calculé (Total).
• ObservableCollection : Utilisé pour stocker la liste des éléments de facture. La collection notifie automatiquement les auditeurs de tout changement (par exemple, lorsqu'un article est ajouté ou supprimé).
• GenerateInvoicePDF : Cette méthode crée le contenu HTML représentant la facture et utilise IronPDF pour le convertir en PDF.
• CollectionChanged : L'événement ObservableCollection est géré pour régénérer le PDF chaque fois que la collection change, rendant ainsi la génération de PDF dynamique.
• Test : La méthode principale démontre comment l'ajout et la suppression d'éléments de l'ObservableCollection déclenchent la régénération du PDF.

Considérations sur les performances

Gestion de grandes collections

Lorsque vous travaillez avec de grandes instances de ObservableCollection, la performance peut devenir un problème. Régénérer un PDF chaque fois que la collection change peut être gourmand en ressources s'il y a un grand nombre d'éléments. Pour atténuer cela, envisagez de regrouper les mises à jour ou d'utiliser des techniques comme la pagination pour éviter de surcharger le processus de génération PDF.

Rendu PDF efficace

Pour garantir que le rendu PDF est efficace, gardez à l'esprit les conseils suivants :

• Minimisez les rechargements inutiles : Ne régénérez le PDF que lorsque les données changent de manière significative (par exemple, lorsque des éléments sont ajoutés ou supprimés).
• Optimiser la disposition des tableaux : Lors de l'affichage de grands ensembles de données, divisez-les en sections plus petites et plus gérables pour améliorer le temps de rendu.
• Utilisez la mise en cache : Mettez en cache les PDF générés précédemment pour les données statiques ou changeant peu fréquemment.

Conclusion

En combinant ObservableCollection de C# avec IronPDF, vous pouvez facilement générer des PDF dynamiques qui reflètent les changements en temps réel des données de votre application. Que vous génériez des factures, des rapports ou d'autres documents, cette approche vous permet de mettre à jour automatiquement le contenu PDF à chaque fois que la collection sous-jacente change.

L'intégration de ObservableCollection garantit que votre application est toujours à jour avec un minimum d'effort, tandis que IronPDF s'occupe de la charge de travail intense pour générer des PDF de haute qualité. En suivant les meilleures pratiques et les conseils de performance abordés dans cet article, vous pouvez créer une expérience fluide de génération de PDF pour vos applications .NET.

Vous voulez essayer IronPDF vous-même ? Téléchargez documentation étendue pour voir davantage cette bibliothèque en action.