.NET AIDE

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

Mis à jour:juin 29, 2025

En C#, la ObservableCollection est une structure de données puissante qui notifie automatiquement les auditeurs lorsque des éléments sont ajoutés, supprimés ou modifiés. Elle 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 UI ou vos rapports. Lorsqu'il est combiné avec IronPDF, cette collection puissante peut être utilisée pour générer des PDF dynamiques basés sur des données en direct.

IronPDF est une bibliothèque robuste pour générer des PDF en C#. Avec ses capacités de conversion HTML-to-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 exploitant la liaison de données pour générer un PDF qui se met à jour dynamiquement à mesure que les données changent.

Comprendre ObservableCollection

Qu'est-ce qu'une ObservableCollection?

La ObservableCollection est une classe en C# qui implémente l'interface INotifyCollectionChanged, qui fournit des notifications lorsque des éléments sont ajoutés, supprimés ou modifiés. Elle est couramment utilisée pour la liaison de données dans des applications UI comme WPF, où les changements apportés à la collection déclenchent automatiquement des mises à jour dans l'UI. 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.

L'ObservableCollection gère automatiquement les changements sur l'ensemble de la collection, facilitant la gestion et l'affichage de collections de données dynamiques dans votre application.

Cas d'Utilisation Courants

Liaison avec les composants UI: Dans WPF, par exemple, ObservableCollection est souvent utilisée pour lier des données à des contrôles comme ListView, DataGrid et ComboBox. Lorsque la collection sous-jacente change, l'UI est automatiquement mise à jour.
Mises à jour en temps réel: Lorsque les données changent fréquemment, ObservableCollection garantit que l'UI 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.
Changements dynamiques: Si votre application permet aux utilisateurs d'ajouter, de supprimer ou de modifier des données, ObservableCollection peut être utilisée pour refléter automatiquement ces changements dans l'UI ou d'autres composants.

Travailler avec IronPDF

Aperçu de IronPDF

ObservableCollection de C# (Comment cela fonctionne pour les développeurs): Figure 1

Comme nous l'avons mentionné au début de cet article, IronPDF est une bibliothèque .NET de génération de PDF qui facilite la création, la modification et le rendu de documents PDF. Contrairement à certaines autres bibliothèques PDF, IronPDF fournit un ensemble riche de fonctionnalités qui simplifient le travail avec les PDF, comme la conversion 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 de 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 paquets :

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égrer ObservableCollection avec IronPDF

Cas d'utilisation : Génération dynamique de PDFs à partir d'ObservableCollection

Imaginons un scénario où vous devez générer un PDF de facture à partir d'une liste d'articles stockée dans une ObservableCollection. À mesure que des articles 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 articles de la facture, tandis que IronPDF nous permettra de générer et d'exporter la facture au format PDF.

Lier des données au contenu PDF

Pour lier les données dans une ObservableCollection à un PDF, vous devez parcourir la collection et ajouter ses articles au contenu PDF. IronPDF fournit des méthodes pour créer des tableaux, ajouter du texte et personnaliser la mise en page, facilitant ainsi 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érer un PDF avec ObservableCollection

Voyons un exemple simple pour démontrer comment cela fonctionne. Supposons que vous ayez une collection de personnes (représentée par la classe Person) et que vous souhaitiez générer un PDF qui reflète les détails de ces personnes. À chaque fois qu'une nouvelle personne est ajoutée à la collection, le PDF sera automatiquement mis à jour.

Exemple de la classe Person

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

$vbLabelText $csharpLabel

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éer 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
	}
}

$vbLabelText $csharpLabel

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

Ajouter des gestionnaires d'événements pour les changements 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éagir à des changements comme l'ajout ou la suppression d'un objet Person.

// 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

$vbLabelText $csharpLabel

Ajouter de nouvelles personnes à la collection

Vous pouvez ajouter une nouvelle Person à la collection, et la collection entière déclenchera le gestionnaire d'événements pour régénérer le PDF. Cette approche gère automatiquement les changements à 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
})

$vbLabelText $csharpLabel

Chaque fois que vous ajoutez une nouvelle personne à la collection, le PDF se régénère, y compris la nouvelle entrée.

Lier la propriété Age

Vous pouvez également lier la propriété age d'une Person à un système externe (comme l'UI 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

$vbLabelText $csharpLabel

Utiliser ObservableCollection avec la liaison

Démontrons l'utilisation de la liaison de l'âge à un élément d'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()

$vbLabelText $csharpLabel

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 nous 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

$vbLabelText $csharpLabel

Exemple deux : Générer un PDF de facture à partir d'une ObservableCollection

Voici un exemple de comment générer un PDF à partir d'une ObservableCollection d'éléments de facture à l'aide de IronPDF :

Étape 1 : Exemple de classe d'article de facture

Cette classe représente un article de 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

$vbLabelText $csharpLabel

Étape 2 : Exemple d'ObservableCollection

Cet exemple initialise une ObservableCollection contenant plusieurs éléments de facture. Vous pouvez ajouter, supprimer ou modifier dynamiquement les articles dans 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
	}
}

$vbLabelText $csharpLabel

É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 de 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 ChromePdfRenderer 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 ChromePdfRenderer 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 ChromePdfRenderer 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

$vbLabelText $csharpLabel

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

Parce qu'ObservableCollection notifie automatiquement des 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

$vbLabelText $csharpLabel

Étape 5 : Ajouter des articles et tester

Vous pouvez maintenant tester en ajoutant de nouveaux articles à 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
})

$vbLabelText $csharpLabel

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 ChromePdfRenderer 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 ChromePdfRenderer 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);
    }
}

Imports System
Imports System.Collections.ObjectModel
Imports IronPdf

Public Class InvoiceItem
	Public Property ItemName() As String
	Public Property Quantity() As Integer
	Public Property Price() As Decimal
	' Property to calculate the total price for each item
	Public ReadOnly Property Total() As Decimal
		Get
			Return Quantity * Price
		End Get
	End Property
End Class
Public Class InvoiceGenerator
	' Function to generate the invoice PDF
	Public Sub GenerateInvoicePDF(ByVal items As ObservableCollection(Of InvoiceItem))
		Dim pdf = New ChromePdfRenderer() ' Initialize IronPDF's ChromePdfRenderer 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

	' Main function to test the code
	Public Shared Sub Main(ByVal args() As String)
		Dim invoiceItems = 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
			}
		}

'INSTANT VB NOTE: The variable invoiceGenerator was renamed since it may cause conflicts with calls to static members of the user-defined type with this name:
		Dim invoiceGenerator_Conflict As New InvoiceGenerator()

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

		' Generate initial PDF
		invoiceGenerator_Conflict.GenerateInvoicePDF(invoiceItems)

		' Add a new item to the collection and automatically regenerate the PDF
		invoiceItems.Add(New InvoiceItem With {
			.ItemName = "Item 4",
			.Quantity = 3,
			.Price = 12.50D
		})

		' Remove an item and see the PDF update
		invoiceItems.RemoveAt(0)
	End Sub
End Class

$vbLabelText $csharpLabel

Sortie

ObservableCollection de C# (Comment cela fonctionne pour les développeurs): Figure 2 - Fichier PDF de sortie

Ce que fait le code

Classe InvoiceItem: Représente un élément de facture avec des propriétés pour ItemName, Quantity, Price et un Total calculé.
ObservableCollection: Utilisée pour stocker la liste des éléments de facture. La collection notifie automatiquement les auditeurs de tout changement (par exemple, lorsque des éléments sont ajoutés ou supprimés).
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 la génération de PDF dynamique.
Testing: La méthode Main démontre comment l'ajout et la suppression d'articles de l'ObservableCollection déclenche la régénération du PDF.

Considérations de Performance

Gérer les grandes collections

Lorsqu'on travaille avec de grandes instances d'ObservableCollection, les performances peuvent devenir un problème. Régénérer un PDF chaque fois que la collection change peut être intensif 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 de PDF.

Rendu PDF efficace

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

Minimiser les re-rendus inutiles : Régénérer le PDF uniquement lorsque les données changent de manière significative (par exemple, lorsqu'on ajoute ou supprime des éléments).
Optimiser la mise en page des tableaux : Lorsqu'on rend de grands ensembles de données, les diviser en sections plus petites et plus gérables pour améliorer le temps de rendu.
Utiliser la mise en cache : Mettre en cache les PDF précédemment générés pour les données statiques ou peu changeantes.

Conclusion

En combinant l’ObservableCollection de C# avec IronPDF, vous pouvez facilement générer des PDFs 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 d'ObservableCollection garantit que votre application est toujours à jour avec un effort minimal, tandis que IronPDF prend en charge le travail de fond pour générer des PDF de haute qualité. En suivant les meilleures pratiques et les conseils de performance discutés dans cet article, vous pouvez créer une expérience de génération de PDF fluide pour vos applications .NET.

Vous voulez essayer IronPDF par vous-même? Download the free trial today to elevate your C# PDF projects, and be sure to check out the extensive documentation section to see more of this library in action.

Questions Fréquemment Posées

Qu'est-ce qu'une ObservableCollection en C# ?

La ObservableCollection est une classe en C# qui implémente l'interface INotifyCollectionChanged. Elle fournit des notifications lorsque des éléments sont ajoutés, supprimés ou modifiés, ce qui la rend idéale pour la liaison de données dans les applications UI où des mises à jour en temps réel sont nécessaires.

Comment puis-je générer un PDF à partir de données dynamiques en C# ?

En utilisant IronPDF, vous pouvez générer des PDFs à partir de données dynamiques en exploitant C#'s ObservableCollection. À mesure que la collection se met à jour, vous pouvez automatiquement régénérer le PDF pour refléter l'état actuel des données.

Quels sont les avantages de l'utilisation de ObservableCollection avec la génération de PDF ?

ObservableCollection permet un suivi des données en temps réel, ce qui est bénéfique lors de la génération de PDFs qui doivent refléter les changements de données en direct. Combiné avec IronPDF, cela garantit que toutes les mises à jour de données sont promptement reflétées dans le résultat PDF.

Comment pouvez-vous lier des données d'une ObservableCollection à un PDF en C# ?

Vous pouvez lier des données d'une ObservableCollection à un PDF en itérant sur les éléments de la collection et en utilisant les méthodes de IronPDF pour les ajouter au PDF en tant qu'éléments structurés, tels que des tableaux ou des listes. Cela garantit que le contenu PDF est toujours synchronisé avec les données.

Quel est un cas d'utilisation courant pour générer des PDFs avec ObservableCollection en C# ?

Un cas d'utilisation courant est de générer des factures à partir d'une ObservableCollection d'articles. À mesure que des articles sont ajoutés ou supprimés de la collection, la facture PDF peut être régénérée pour refléter précisément la liste actuelle des articles, garantissant ainsi une documentation à jour.

Comment IronPDF gère-t-il la conversion HTML-en-PDF en C# ?

IronPDF peut convertir HTML en PDF en utilisant des méthodes telles que RenderHtmlAsPdf et RenderHtmlFileAsPdf. Cela permet aux développeurs de créer des PDFs à partir de pages web ou de chaînes HTML, facilitant ainsi le rendu de contenu dynamique.

Que faut-il prendre en compte lors du travail avec de grandes ObservableCollections pour la génération de PDF ?

Lors du traitement de grandes collections, envisagez d'utiliser la pagination, de regrouper les mises à jour et d'optimiser la mise en page pour éviter les problèmes de performance. Les optimisations de mise en cache et de rendu de IronPDF peuvent également aider à gérer efficacement de grandes quantités de données.

Comment IronPDF peut-il améliorer la productivité dans les applications .NET ?

IronPDF améliore la productivité en offrant des fonctionnalités robustes pour la création de PDF, telles que la personnalisation détaillée de la mise en page, la conversion HTML-en-PDF et l'intégration avec diverses sources de données. Il simplifie les tâches complexes de PDF, permettant aux développeurs de se concentrer sur la logique principale de l'application.

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Articles connexes

Mis à jourseptembre 4, 2025

RandomNumberGenerator C#

L'utilisation de la classe RandomNumberGenerator C# peut aider à porter vos projets de génération et d'édition de PDF à un niveau supérieur

Mis à jourseptembre 4, 2025

C# String Equals (Comment ça fonctionne pour les développeurs)

Lorsqu'il est combiné avec une bibliothèque PDF puissante comme IronPDF, la correspondance de modèle de switch permet de construire une logique plus intelligente et plus propre pour le traitement de documents

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

Comprendre ObservableCollection

Qu'est-ce qu'une ObservableCollection?

Cas d'Utilisation Courants

Travailler avec IronPDF

Aperçu de IronPDF

Installation de IronPDF

Intégrer ObservableCollection avec IronPDF

Cas d'utilisation : Génération dynamique de PDFs à partir d'ObservableCollection

Lier des données au contenu PDF

Exemple un : Générer un PDF avec ObservableCollection

Exemple de la classe Person

Créer l'ObservableCollection

Ajouter des gestionnaires d'événements pour les changements de collection

Ajouter de nouvelles personnes à la collection

Lier la propriété Age

Utiliser ObservableCollection avec la liaison

Générer le PDF avec IronPDF

Exemple deux : Générer un PDF de facture à partir d'une ObservableCollection

Étape 1 : Exemple de classe d'article de facture

Étape 2 : Exemple d'ObservableCollection

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

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

Étape 5 : Ajouter des articles et tester

Exemple de code complet

Ce que fait le code

Considérations de Performance

Gérer les grandes collections

Rendu PDF efficace

Conclusion

Questions Fréquemment Posées

Qu'est-ce qu'une ObservableCollection en C# ?

Comment puis-je générer un PDF à partir de données dynamiques en C# ?

Quels sont les avantages de l'utilisation de ObservableCollection avec la génération de PDF ?

Comment pouvez-vous lier des données d'une ObservableCollection à un PDF en C# ?

Quel est un cas d'utilisation courant pour générer des PDFs avec ObservableCollection en C# ?

Comment IronPDF gère-t-il la conversion HTML-en-PDF en C# ?

Que faut-il prendre en compte lors du travail avec de grandes ObservableCollections pour la génération de PDF ?

Comment IronPDF peut-il améliorer la productivité dans les applications .NET ?

Articles connexes

RandomNumberGenerator C#

C# String Equals (Comment ça fonctionne pour les développeurs)

C# Switch Pattern Matching (Comment ça fonctionne pour les développeurs)

Étape suivante : Commencer l'essai gratuit de 30 jours

Étape suivante : Commencer l'essai gratuit de 30 jours

De confiance par plus de 2 millions d'ingénieurs dans le monde entier