C# ObservableCollection (How it Works for Developers)

Introduction

In C#, the ObservableCollectionis a powerful data structure that automatically notifies listeners when items are added, removed, or changed. It’s particularly useful for dynamic data collection scenarios, such as when you need to reflect real-time changes in your UI or reports. When combined with IronPDF, this powerful collection can be used to generate dynamic PDFs based on live data.

IronPDF is a robust library for generating PDFs in C#. With its HTML-to-PDF conversion capabilities, it’s easy to create high-quality PDFs, whether you need to generate invoices, reports, or any other documents based on real-time data. In this article, we’ll show you how to integrate the ObservableCollection class with IronPDF, leveraging data binding to generate a PDF that dynamically updates as data changes.

Understanding ObservableCollection

What is an ObservableCollection?

The ObservableCollectionis a class in C# that implements the INotifyCollectionChanged interface, which provides notifications when items are added, removed, or modified. It’s commonly used for data binding in UI applications like WPF, where changes to the collection automatically trigger updates in the UI. Unlike other collections like List, an ObservableCollection offers built-in event notifications, making it perfect for scenarios where the data needs to be reflected in real-time.

The ObservableCollection automatically handles changes to the entire collection, making it easy to manage and display dynamic data collection in your application.

Common Use Cases

• Binding with UI components: In WPF, for example, ObservableCollection is often used for binding data to controls like ListView, DataGrid, and ComboBox. When the underlying collection changes, the UI is automatically updated.
• Real-time updates: When data changes frequently, ObservableCollection ensures the UI is always in sync. For example, you could use it for a live report where new data entries are added to the collection in real-time, and the report updates accordingly.
• Dynamic changes: If your application allows users to add, delete, or modify data, ObservableCollection can be used to automatically reflect those changes in the UI or other components.

Working with IronPDF

Overview of IronPDF

Add from PixabayUpload

or drag and drop an image here

Add image alt text

As we mentioned at the start of this article, IronPDF is a .NET PDF generation library that makes it easy to create, modify, and render PDF documents. Unlike some other PDF libraries, IronPDF provides a rich set of features that simplify working with PDFs, such as converting HTML to PDF, adding watermarks, manipulating existing PDFs, and more.

IronPDF also allows developers to render PDFs from different data sources, including HTML, images, and plain text, which can be particularly useful when you need to present dynamic data. With IronPDF’s API, you can generate high-quality PDFs, including detailed layouts, tables, images, and styles.

IronPDF Setup

To get started with IronPDF, you need to install the library via NuGet. You can add it to your project by running the following command in the Package Manager Console:

Install-Package IronPdf

Install-Package IronPdf

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

Once installed, you can initialize IronPDF and use its powerful features. For this article, we’ll focus on generating PDFs from dynamic data in an ObservableCollection.

Integrating ObservableCollection with IronPDF

Use Case: Dynamically Generating PDFs from ObservableCollection

Let’s imagine a scenario where you need to generate an invoice PDF from a list of items stored in an ObservableCollection. As items are added or removed from the collection, the PDF should be regenerated automatically to reflect the current state of the data.

For this task, ObservableCollection provides an easy way to manage the items in the invoice, while IronPDF will allow us to generate and export the invoice to a PDF format.

Binding Data to PDF Content

To bind the data in an ObservableCollection to a PDF, you need to loop through the collection and add its items to the PDF content. IronPDF provides methods to create tables, add text, and customize the layout, making it easy to represent the data in a structured format.

For instance, if you have an invoice with several items, you can dynamically generate the PDF by looping through the ObservableCollection and adding each item to a table or list in the document. IronPDF allows for a high level of customization, including adjusting fonts, borders, and even including images like logos or barcodes.

Example One: Generating a PDF using ObservableCollection

Let's look at a simple example to demonstrate how this works. Suppose you have a collection of people (represented by the Person class), and you want to generate a PDF that reflects the details of these people. Each time a new person is added to the collection, the PDF will automatically update.

Person Class Example

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

n this case, the Person class contains basic properties such as Name and Age. We will use this class in conjunction with the ObservableCollection to dynamically generate a PDF.

Creating the 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
	}
}

This ObservableCollection contains a collection of Person objects, each with a Name and Age. When an item is added or removed, event handlers are triggered, which we'll use to update the PDF dynamically.

Adding Event Handlers for Collection Changes

In this example, we subscribe to the CollectionChanged event of the ObservableCollection class to automatically regenerate the PDF whenever the collection changes. This is useful if you need to respond to changes such as adding or removing a Person object.

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

Adding New People to the Collection

You can add a new Person to the collection, and the entire collection will trigger the event handler to regenerate the PDF. This approach automatically handles changes to the entire list of people.

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

Each time you add a new person to the collection, the PDF will regenerate, including the new entry.

Binding Age Property

You can also bind the age property of a Person to some external system (such as the UI or other parts of the application) to automatically reflect changes.

Here’s an example of how the Age property would be bound in the Person class:

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

Using ObservableCollection with Binding

Let’s demonstrate using binding age to a UI element, updating the age value and observing the changes being reflected in the 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()

Generating the PDF with IronPDF

Now that we've set up the ObservableCollection and added event handlers, it's time to focus on generating a PDF that reflects the dynamic collection of people.

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

Example Two: Generating a PDF Invoice from ObservableCollection

Here’s an example of how to generate a PDF from an ObservableCollection of invoice items using IronPDF:

Step 1: Sample Invoice Item Class

This class represents an item in the invoice, with properties for item name, quantity, price, and total 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 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

Step 2: Sample ObservableCollection

This example initializes an ObservableCollection containing several invoice items. You can dynamically add, remove, or modify the items in this 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
	}
}

Step 3: Generating the PDF with IronPDF

Here, we create a function to generate the PDF. This function uses the data in the ObservableCollection and converts it to HTML, which is then rendered as a PDF using 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

Step 4: Subscribe to the CollectionChanged Event

Because ObservableCollection automatically notifies changes, you can easily regenerate the PDF whenever the collection is updated. For example, if an item is added or removed, the PDF can be regenerated with the updated data.

Here’s how you can subscribe to the CollectionChanged event and regenerate the PDF whenever the collection changes:

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

Step 5: Adding Items and Testing

You can now test by adding new items to the ObservableCollection and observing how the PDF is regenerated automatically.

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

Full Code Example

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

Output

Add from PixabayUpload

or drag and drop an image here

Clear alt text

What the Code Does

• InvoiceItem class: Represents an invoice item with properties for ItemName, Quantity, Price, and a computed Total.
• ObservableCollection: Used to store the list of invoice items. The collection automatically notifies listeners of any changes (e.g., when items are added or removed).
• GenerateInvoicePDF: This method creates the HTML content representing the invoice and uses IronPDF to convert it to a PDF.
• CollectionChanged: The ObservableCollection event is handled to regenerate the PDF whenever the collection changes, making the PDF generation dynamic.
• Testing: The Main method demonstrates how adding and removing items from the ObservableCollection triggers PDF regeneration.

Performance Considerations

Handling Large Collections

When working with large ObservableCollection instances, performance can become a concern. Regenerating a PDF each time the collection changes might be resource-intensive if there are a large number of items. To mitigate this, consider batching updates or using techniques like pagination to avoid overloading the PDF generation process.

Efficient PDF Rendering

To ensure that PDF rendering is efficient, keep the following tips in mind:

• Minimize unnecessary re-renders: Only regenerate the PDF when the data changes significantly (e.g., when items are added or removed).
• Optimize table layout: When rendering large datasets, break them into smaller, more manageable sections to improve rendering time.
• Use caching: Cache previously generated PDFs for static or infrequently changing data.

Conclusion

By combining C#’s ObservableCollection with IronPDF, you can easily generate dynamic PDFs that reflect real-time changes in your application’s data. Whether you're generating invoices, reports, or other documents, this approach allows you to automatically update the PDF content whenever the underlying collection changes.

The integration of ObservableCollection ensures that your application is always up-to-date with minimal effort, while IronPDF handles the heavy lifting of rendering high-quality PDFs. By following the best practices and performance tips discussed in this article, you can create a seamless PDF generation experience for your .NET applications.

Want to try IronPDF for yourself? 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.