Was ist eine ObservableCollection in C#?

Die ObservableCollection ist eine Klasse in C#, die das INotifyCollectionChanged-Interface implementiert. Sie bietet Benachrichtigungen, wenn Elemente hinzugefügt, entfernt oder geändert werden, was sie ideal für die Datenbindung in UI-Anwendungen macht, in denen Echtzeit-Updates erforderlich sind.

Wie kann ich ein PDF aus dynamischen Daten in C# generieren?

Mit IronPDF können Sie PDFs aus dynamischen Daten generieren, indem Sie C#'s ObservableCollection nutzen. Wenn sich die Sammlung aktualisiert, können Sie das PDF automatisch neu generieren, um den aktuellen Datenstand widerzuspiegeln.

Welche Vorteile bietet die Verwendung von ObservableCollection bei der PDF-Erstellung?

ObservableCollection ermöglicht eine Echtzeitverfolgung von Daten, was vorteilhaft ist, wenn PDFs generiert werden müssen, die Änderungen an Live-Daten widerspiegeln müssen. Zusammen mit IronPDF stellt es sicher, dass alle Datenaktualisierungen umgehend im PDF-Ausgang reflektiert werden.

Wie können Sie Daten aus einer ObservableCollection an ein PDF in C# binden?

Sie können Daten aus einer ObservableCollection an ein PDF binden, indem Sie über die Sammlungselemente iterieren und die Methoden von IronPDF verwenden, um sie als strukturierte Elemente wie Tabellen oder Listen dem PDF hinzuzufügen. Dies stellt sicher, dass der PDF-Inhalt immer mit den Daten synchronisiert ist.

Was ist ein gängiger Anwendungsfall für die Erstellung von PDFs mit ObservableCollection in C#?

Ein häufiger Anwendungsfall ist das Erstellen von Rechnungen aus einer ObservableCollection von Gegenständen. Wenn Elemente zur Sammlung hinzugefügt oder daraus entfernt werden, kann die PDF-Rechnung neu generiert werden, um die aktuelle Liste von Gegenständen genau widerzuspiegeln und eine aktuelle Dokumentation zu gewährleisten.

Wie verarbeitet IronPDF die HTML-zu-PDF-Konvertierung in C#?

IronPDF kann HTML in PDF umwandeln mit Methoden wie RenderHtmlAsPdf und RenderHtmlFileAsPdf . Dies ermöglicht es Entwicklern, PDFs aus Webseiten oder HTML-Strings zu erstellen und so dynamische Inhaltselemente zu rendern.

Was sollte bei der Arbeit mit großen ObservableCollections für die PDF-Erstellung berücksichtigt werden?

Bei der Arbeit mit großen Sammlungen sollten Sie die Paginierung berücksichtigen, Aktualisierungen stapelweise durchführen und das Layout optimieren, um Leistungsprobleme zu vermeiden. Die Caching- und Rendering-Optimierungen von IronPDF können ebenfalls helfen, große Daten effizient zu verwalten.

Wie kann IronPDF die Produktivität in .NET-Anwendungen verbessern?

IronPDF verbessert die Produktivität, indem es robuste Funktionen zur Erstellung von PDFs bietet, wie detaillierte Layoutanpassungen, HTML-zu-PDF-Konvertierung und Integration mit verschiedenen Datenquellen. Es vereinfacht komplexe PDF-Aufgaben, sodass Entwickler sich auf die Kernlogik der Anwendung konzentrieren können.

How does data binding work with ObservableCollection?

In C#, data binding with ObservableCollection involves linking UI components to the collection, enabling automatic updates to the UI when the collection's data changes, which is beneficial for real-time data applications.

What performance considerations should be taken into account when using ObservableCollection with IronPDF?

When using ObservableCollection with IronPDF, it's important to handle large data efficiently to avoid performance bottlenecks, such as by batching updates, optimizing table layouts, and caching static or infrequently changing data.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

C# ObservableCollection (Wie es für Entwickler funktioniert)

Jacob Mellor

Updated: 21. April 2026

In C# ist die ObservableCollection eine leistungsstarke Datenstruktur, die automatisch Hörer benachrichtigt, wenn Elemente hinzugefügt, entfernt oder geändert werden. Sie ist besonders nützlich für Szenarien mit dynamischer Datensammlung, z. B. wenn Sie Echtzeitänderungen in Ihrer Benutzeroberfläche oder Berichten widerspiegeln müssen. In Kombination mit IronPDF kann diese leistungsstarke Sammlung verwendet werden, um dynamische PDFs basierend auf Live-Daten zu generieren.

IronPDF ist eine robuste Bibliothek zur Generierung von PDFs in C#. Mit seinen HTML-zu-PDF-Konvertierungsfunktionen ist es einfach, hochwertige PDFs zu erstellen, sei es für Rechnungen, Berichte oder andere Dokumente, die auf Echtzeitdaten basieren. In diesem Artikel zeigen wir Ihnen, wie Sie die ObservableCollection-Klasse mit IronPDF integrieren und Datenbindung nutzen, um ein PDF zu generieren, das sich dynamisch mit Datenänderungen aktualisiert.

Verständnis von ObservableCollection

Was ist eine ObservableCollection?

Die ObservableCollection<t> ist eine Klasse in C#, die das INotifyCollectionChanged-Interface implementiert und Benachrichtigungen bereitstellt, wenn Elemente hinzugefügt, entfernt oder geändert werden. Sie wird häufig für Datenbindung in UI-Anwendungen wie WPF verwendet, bei denen Änderungen an der Sammlung automatisch Updates in der Benutzeroberfläche auslösen. Im Gegensatz zu anderen Sammlungen wie List<t> bietet eine ObservableCollection integrierte Ereignisbenachrichtigungen, was sie perfekt für Szenarien macht, in denen die Daten in Echtzeit reflektiert werden müssen.

Die ObservableCollection verwaltet automatisch Änderungen an der gesamten Sammlung, was es einfach macht, dynamische Datensammlungen in Ihrer Anwendung anzuzeigen und zu verwalten.

Gängige Anwendungsfälle

Datenbindung an UI-Komponenten: In WPF wird beispielsweise ObservableCollection häufig verwendet, um Daten an Steuerelemente wie ListView, DataGrid und ComboBox zu binden. Wenn sich die zugrunde liegende Sammlung ändert, wird die Benutzeroberfläche automatisch aktualisiert.
Echtzeit-Aktualisierungen: Wenn sich die Daten häufig ändern, sorgt ObservableCollection dafür, dass die Benutzeroberfläche immer synchron ist. Beispielsweise könnte es für einen Live-Bericht verwendet werden, bei dem neue Dateneinträge der Sammlung in Echtzeit hinzugefügt werden und der Bericht entsprechend aktualisiert wird.
Dynamische Änderungen: Wenn Ihre Anwendung es Benutzern ermöglicht, Daten hinzuzufügen, zu löschen oder zu ändern, kann ObservableCollection verwendet werden, um diese Änderungen automatisch in der Benutzeroberfläche oder anderen Komponenten widerzuspiegeln.

Arbeiten mit IronPDF

Überblick über IronPDF

C# ObservableCollection (Wie es für Entwickler funktioniert): Abbildung 1

Wie wir zu Beginn dieses Artikels erwähnt haben, ist IronPDF eine .NET-PDF-Generierungsbibliothek, die es einfach macht, PDF-Dokumente zu erstellen, zu ändern und darzustellen. Im Gegensatz zu einigen anderen PDF-Bibliotheken bietet IronPDF eine Reihe von Funktionen, die die Arbeit mit PDFs vereinfachen, wie z. B. die Konvertierung von HTML zu PDF, das Hinzufügen von Wasserzeichen, das Manipulieren bestehender PDFs und mehr.

Mit IronPDF können Entwickler PDFs aus verschiedenen Datenquellen rendern, einschließlich HTML, Bildern und Klartext, was besonders nützlich ist, wenn Sie dynamische Daten präsentieren müssen. Mit der API von IronPDF können Sie hochwertige PDFs generieren, einschließlich detaillierter Layouts, Tabellen, Bilder und Stile.

IronPDF-Einrichtung

Um mit IronPDF zu beginnen, müssen Sie die Bibliothek über NuGet installieren. Sie können sie zu Ihrem Projekt hinzufügen, indem Sie den folgenden Befehl in der Paket-Manager-Konsole ausführen:

PM > Install-Package IronPdf

Install-Package IronPdf

Einmal installiert, können Sie IronPDF initialisieren und seine leistungsstarken Funktionen nutzen. Für diesen Artikel konzentrieren wir uns auf die Generierung von PDFs aus dynamischen Daten in einer ObservableCollection.

Integration von ObservableCollection mit IronPDF

Benutzungsfall: Dynamische Generierung von PDFs aus ObservableCollection

Stellen wir uns ein Szenario vor, in dem Sie ein Rechnungs-PDF aus einer Liste von Elementen generieren müssen, die in einer ObservableCollection gespeichert sind. Wenn Elemente der Sammlung hinzugefügt oder entfernt werden, sollte das PDF automatisch neu generiert werden, um den aktuellen Zustand der Daten widerzuspiegeln.

Für diese Aufgabe bietet die ObservableCollection eine einfache Möglichkeit, die Elemente in der Rechnung zu verwalten, während IronPDF es uns ermöglicht, die Rechnung zu generieren und im PDF-Format zu exportieren.

Daten an PDF-Inhalte binden

Um die Daten in einer ObservableCollection an ein PDF zu binden, müssen Sie die Sammlung durchlaufen und ihre Elemente dem PDF-Inhalt hinzufügen. IronPDF bietet Methoden zum Erstellen von Tabellen, Hinzufügen von Text und Anpassen des Layouts, was es einfach macht, die Daten in einem strukturierten Format darzustellen.

Wenn Sie beispielsweise eine Rechnung mit mehreren Artikeln haben, können Sie das PDF dynamisch generieren, indem Sie die ObservableCollection durchlaufen und jedes Element einer Tabelle oder Liste im Dokument hinzufügen. IronPDF ermöglicht ein hohes Maß an Anpassung, einschließlich der Anpassung von Schriftarten, Rändern und sogar dem Einfügen von Bildern wie Logos oder Barcodes.

Beispiel Eins: Erzeugen einer PDF-Datei mit ObservableCollection

Schauen wir uns ein einfaches Beispiel an, um zu demonstrieren, wie das funktioniert. Angenommen, Sie haben eine Sammlung von Personen (dargestellt durch die Person-Klasse) und möchten ein PDF generieren, das die Details dieser Personen widerspiegelt. Jedes Mal, wenn eine neue Person zur Sammlung hinzugefügt wird, wird das PDF automatisch aktualisiert.

Beispiel einer Personenklasse

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

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

In diesem Fall enthält die Person-Klasse grundlegende Eigenschaften wie Name und Alter. Wir werden diese Klasse in Verbindung mit der ObservableCollection verwenden, um ein PDF dynamisch zu generieren.

Erstellen der 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
	}
}

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

Diese ObservableCollection enthält eine Sammlung von Person-Objekten, jeweils mit einem Namen und einem Alter. Wenn ein Element hinzugefügt oder entfernt wird, werden Ereignishandler ausgelöst, die wir verwenden werden, um das PDF dynamisch zu aktualisieren.

Ereignishandler für Sammlungsänderungen hinzufügen

In diesem Beispiel abonnieren wir das CollectionChanged-Ereignis der ObservableCollection-Klasse, um das PDF automatisch neu zu generieren, wann immer sich die Sammlung ändert. Dies ist nützlich, wenn Sie auf Änderungen wie das Hinzufügen oder Entfernen eines Person-Objekts reagieren müssen.

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

' 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

Neue Leute in die Sammlung aufnehmen

Sie können eine neue Person zur Sammlung hinzufügen, und die gesamte Sammlung wird den Ereignishandler auslösen, um das PDF neu zu generieren. Dieser Ansatz behandelt automatisch Änderungen der gesamten Liste von Personen.

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

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

Jedes Mal, wenn Sie eine neue Person hinzufügen, wird das PDF neu generiert und der Eintrag wird eingeschlossen.

Eigenschaft Binding Age

Sie können auch die Alter-Eigenschaft einer Person an ein externes System (wie die Benutzeroberfläche oder andere Teile der Anwendung) binden, um Änderungen automatisch widerzuspiegeln.

Hier ist ein Beispiel dafür, wie die Eigenschaft "Age" in der Klasse "Person" gebunden würde:

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

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

Verwendung von ObservableCollection mit Binding

Lassen Sie uns demonstrieren, wie Bindung des Alters an ein UI-Element verwendet wird, den Alterswert zu aktualisieren und zu beobachten, wie die Änderungen in der Sammlung widergespiegelt werden:

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()

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()

Erzeugung der PDF-Datei mit IronPDF

Nachdem wir die ObservableCollection eingerichtet und Ereignishandler hinzugefügt haben, ist es Zeit, uns auf die Generierung eines PDFs zu konzentrieren, das die dynamische Sammlung von Personen widerspiegelt.

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

Imports IronPdf

Public Sub GeneratePersonPDF(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
    
    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

Beispiel zwei: Erzeugen einer PDF-Rechnung aus ObservableCollection

Hier ist ein Beispiel dafür, wie man ein PDF aus einer ObservableCollection von Rechnungsposten mit IronPDF generiert:

Schritt 1: Beispiel einer Rechnungsklasse

Diese Klasse repräsentiert einen Posten in der Rechnung, mit Eigenschaften für Artikelname, Menge, Preis und Gesamtpreis.

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

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

Schritt 2: Beispiel ObservableCollection

Dieses Beispiel initialisiert eine ObservableCollection, die mehrere Rechnungsposten enthält. Sie können die Elemente in dieser Sammlung dynamisch hinzufügen, entfernen oder ändern.

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

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

Schritt 3: Generierung der PDF-Datei mit IronPDF

Hier erstellen wir eine Funktion, um das PDF zu generieren. Diese Funktion verwendet die Daten in der ObservableCollection und konvertiert sie in HTML, das dann mit IronPDF als PDF gerendert wird.

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

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

Schritt 4: Abonnieren Sie das Ereignis CollectionChanged

Da die ObservableCollection Änderungen automatisch benachrichtigt, können Sie das PDF leicht jedes Mal neu generieren, wenn die Sammlung aktualisiert wird. Wenn beispielsweise ein Element hinzugefügt oder entfernt wird, kann das PDF mit den aktualisierten Daten neu generiert werden.

Hier ist, wie Sie das CollectionChanged-Ereignis abonnieren und das PDF jedes Mal neu generieren, wenn sich die Sammlung ändert:

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

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

Schritt 5: Hinzufügen von Elementen und Testen

Sie können jetzt testen, indem Sie neue Elemente zur ObservableCollection hinzufügen und beobachten, wie das PDF automatisch neu generiert wird.

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

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

Vollständiges Codebeispiel

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(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
        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(args As String())
        Dim invoiceItems = New ObservableCollection(Of InvoiceItem) From {
            New InvoiceItem With {.ItemName = "Item 1", .Quantity = 2, .Price = 10.0D},
            New InvoiceItem With {.ItemName = "Item 2", .Quantity = 1, .Price = 25.0D},
            New InvoiceItem With {.ItemName = "Item 3", .Quantity = 5, .Price = 5.0D}
        }

        Dim invoiceGenerator = New InvoiceGenerator()

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

        ' Generate initial PDF
        invoiceGenerator.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.5D})

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

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(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
        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(args As String())
        Dim invoiceItems = New ObservableCollection(Of InvoiceItem) From {
            New InvoiceItem With {.ItemName = "Item 1", .Quantity = 2, .Price = 10.0D},
            New InvoiceItem With {.ItemName = "Item 2", .Quantity = 1, .Price = 25.0D},
            New InvoiceItem With {.ItemName = "Item 3", .Quantity = 5, .Price = 5.0D}
        }

        Dim invoiceGenerator = New InvoiceGenerator()

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

        ' Generate initial PDF
        invoiceGenerator.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.5D})

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

Ausgabe

C# ObservableCollection (Wie es für Entwickler funktioniert): Abbildung 2 - Ausgabe-PDF-Datei

Was der Code bewirkt

InvoiceItem-Klasse: Stellt einen Rechnungsposten mit Eigenschaften für Artikelname, Menge, Preis und einen berechneten Gesamtbetrag dar.
ObservableCollection: Wird verwendet, um die Liste der Rechnungspositionen zu speichern. Die Sammlung benachrichtigt Hörer automatisch über alle Änderungen (z. B. wenn Elemente hinzugefügt oder entfernt werden).
GenerateInvoicePDF: Diese Methode erstellt den HTML-Inhalt, der die Rechnung darstellt, und verwendet IronPDF , um ihn in ein PDF zu konvertieren.
CollectionChanged: Das ObservableCollection-Ereignis wird behandelt, um die PDF-Datei bei jeder Änderung der Sammlung neu zu generieren, wodurch die PDF-Generierung dynamisch wird.
Test: Die Main-Methode demonstriert, wie das Hinzufügen und Entfernen von Elementen aus der ObservableCollection die PDF-Regenerierung auslöst.

Erwägungen zur Leistung

Handhabung großer Sammlungen

Bei der Arbeit mit großen Instanzen von ObservableCollection kann die Leistung ein Problem werden. Die Neugenerierung eines PDFs jedes Mal, wenn sich die Sammlung ändert, kann ressourcenintensiv sein, wenn eine große Anzahl von Elementen vorhanden ist. Um dies zu mildern, sollten Sie Updates bündeln oder Techniken wie Paginierung verwenden, um eine Überlastung des PDF-Generierungsprozesses zu vermeiden.

Effizientes PDF-Rendering

Um sicherzustellen, dass die PDF-Darstellung effizient ist, sollten Sie die folgenden Tipps beachten:

Vermeiden Sie unnötige Neurenderings: Neugenerierung des PDFs nur, wenn sich die Daten signifikant ändern (z. B. wenn Elemente hinzugefügt oder entfernt werden).
Optimieren Sie das Tabellenlayout: Beim Rendern großer Datensätze, diese in kleinere, handlichere Abschnitte aufzuteilen, um die Renderzeit zu verbessern.
Caching verwenden: Bereits generierte PDFs für statische oder selten geänderte Daten zwischenspeichern.

Abschluss

Durch die Kombination von C#'s ObservableCollection mit IronPDF können Sie problemlos dynamische PDFs generieren, die Echtzeitänderungen in den Daten Ihrer Anwendung widerspiegeln. Egal ob Sie Rechnungen, Berichte oder andere Dokumente generieren, dieser Ansatz ermöglicht es Ihnen, den PDF-Inhalt automatisch zu aktualisieren, wann immer sich die zugrunde liegende Sammlung ändert.

Die Integration der ObservableCollection stellt sicher, dass Ihre Anwendung mit minimalem Aufwand immer auf dem neuesten Stand ist, während IronPDF die schwere Arbeit der Darstellung hochwertiger PDFs übernimmt. Indem Sie die in diesem Artikel behandelten Best Practices und Leistungstipps befolgen, können Sie ein nahtloses PDF-Generierungserlebnis für Ihre .NET-Anwendungen schaffen.

Möchten Sie IronPDF selbst ausprobieren? Laden Sie die kostenlose Testversion herunter, um Ihre C#-PDF-Projekte zu verbessern, und werfen Sie einen Blick auf den umfangreichen Dokumentationsbereich, um mehr von dieser Bibliothek in Aktion zu sehen.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...