.NET HILFE

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

Q: 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.

Jacob Mellor

Aktualisiert:18. Januar 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 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 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 (So funktioniert es für Entwickler): 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:

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

$vbLabelText $csharpLabel

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

$vbLabelText $csharpLabel

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

$vbLabelText $csharpLabel

Neue Einträge zur Sammlung hinzufügen

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

$vbLabelText $csharpLabel

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

Eigenschaftsbindung des Alters

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

$vbLabelText $csharpLabel

Verwendung von ObservableCollection mit Binding

Lassen Sie uns demonstrieren, wie die Altersbindung 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()

$vbLabelText $csharpLabel

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

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

$vbLabelText $csharpLabel

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

$vbLabelText $csharpLabel

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

$vbLabelText $csharpLabel

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

$vbLabelText $csharpLabel

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

$vbLabelText $csharpLabel

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

Ausgabe

C# ObservableCollection (So funktioniert es für Entwickler): Abbildung 2 - Ausgabedatei im PDF-Format

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.

Häufig gestellte Fragen

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.

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

Starten Sie jetzt Ihre kostenlose 30-Tage-Testphase

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

Verständnis von ObservableCollection

Was ist eine ObservableCollection?

Gängige Anwendungsfälle

Arbeiten mit IronPDF

Überblick über IronPDF

IronPDF-Einrichtung

Integration von ObservableCollection mit IronPDF

Benutzungsfall: Dynamische Generierung von PDFs aus ObservableCollection

Daten an PDF-Inhalte binden

Beispiel Eins: Erzeugen einer PDF-Datei mit ObservableCollection

Beispiel einer Personenklasse

Erstellen der ObservableCollection

Ereignishandler für Sammlungsänderungen hinzufügen

Neue Einträge zur Sammlung hinzufügen

Eigenschaftsbindung des Alters

Verwendung von ObservableCollection mit Binding

Erzeugung der PDF-Datei mit IronPDF

Beispiel zwei: Erzeugen einer PDF-Rechnung aus ObservableCollection

Schritt 1: Beispiel einer Rechnungsklasse

Schritt 2: Beispiel ObservableCollection

Schritt 3: Generierung der PDF-Datei mit IronPDF

Schritt 4: Abonnieren Sie das Ereignis CollectionChanged

Schritt 5: Hinzufügen von Elementen und Testen

Vollständiges Codebeispiel

Was der Code bewirkt

Erwägungen zur Leistung

Handhabung großer Sammlungen

Effizientes PDF-Rendering

Abschluss

Häufig gestellte Fragen

Was ist eine ObservableCollection in C#?

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

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

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

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

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

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

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

Verwandte Artikel

Brückenschlag zwischen einfacher CLI und .NET: Curl DotNet mit IronPDF

RandomNumberGenerator C#

C# String Equals (Wie es für Entwickler funktioniert)

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

Von Millionen von Ingenieur*innen weltweit vertraut

Iron Support Team