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

Einführung

In C# ist die ObservableCollectioneine leistungsstarke Datenstruktur, die Zuhörer automatisch benachrichtigt, wenn Elemente hinzugefügt, entfernt oder geändert werden. Es ist besonders nützlich für dynamische Datenerfassungsszenarien, beispielsweise wenn Sie Echtzeitänderungen in Ihrer Benutzeroberfläche oder in Berichten widerspiegeln müssen. In Kombination mit IronPDF kann diese leistungsstarke Sammlung verwendet werden, um dynamische PDFs basierend auf Live-Daten zu erstellen.

IronPDF ist eine robuste Bibliothek zur Erstellung von PDFs in C#. Mit seinen HTML-zu-PDF-Umwandlungsfähigkeiten ist es einfach, hochwertige PDFs zu erstellen, egal ob Sie Rechnungen, Berichte oder andere Dokumente auf Basis von Echtzeitdaten erzeugen müssen. In diesem Artikel zeigen wir Ihnen, wie Sie die ObservableCollection-Klasse mit IronPDF integrieren und Datenbindung nutzen, um ein PDF zu erstellen, das sich dynamisch aktualisiert, wenn sich die Daten ändern.

Verständnis der ObservableCollection

Was ist eine ObservableCollection?

Die ObservableCollectionist eine Klasse in C#, die das INotifyCollectionChanged-Interface implementiert, welches Benachrichtigungen bereitstellt, wenn Elemente hinzugefügt, entfernt oder geändert werden. Es wird häufig für die Datenbindung in UI-Anwendungen wie WPF verwendet, bei denen Änderungen an der Sammlung automatisch Aktualisierungen in der Benutzeroberfläche auslösen. Im Gegensatz zu anderen Sammlungen wie Listbietet eine ObservableCollection eingebaute Ereignisbenachrichtigungen, was sie ideal für Szenarien macht, in denen die Daten in Echtzeit widergespiegelt werden müssen.

Die ObservableCollection verarbeitet automatisch Änderungen an der gesamten Sammlung, was die Verwaltung und Anzeige von dynamischen Datensammlungen in Ihrer Anwendung erleichtert.

Häufige Anwendungsfälle

• Binden mit UI-Komponenten: In WPF wird beispielsweise häufig ObservableCollection 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-Updates: Wenn sich Daten häufig ändern, stellt ObservableCollection sicher, dass die Benutzeroberfläche immer synchron ist. Zum Beispiel könnten Sie es für einen Live-Bericht verwenden, bei dem neue Dateneinträge in Echtzeit zur Sammlung hinzugefügt werden und der Bericht entsprechend aktualisiert wird.
• Dynamische Änderungen: Wenn Ihre Anwendung es Benutzern erlaubt, 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

Von Pixabay hinzufügenHochladen

oder ein Bild hierher ziehen und ablegen

Alternativtext für Bild hinzufügen

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

IronPDF ermöglicht es Entwicklern auch, PDFs aus verschiedenen Datenquellen zu rendern, einschließlich HTML, Bildern und einfachem Text, was besonders nützlich sein kann, wenn Sie dynamische Daten präsentieren müssen. Mit der API von IronPDF können Sie hochwertige PDFs erzeugen, einschließlich detaillierter Layouts, Tabellen, Bilder und Stile.

IronPDF-Installation

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

Install-Package IronPdf

Install-Package IronPdf

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

Nach der Installation können Sie IronPDF initialisieren und seine leistungsstarken Funktionen nutzen. In diesem Artikel konzentrieren wir uns darauf, PDFs aus dynamischen Daten in einer ObservableCollection zu generieren.

Integrieren von ObservableCollection mit IronPDF

Anwendungsfall: Dynamische Generierung von PDFs aus ObservableCollection

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

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

Verknüpfen von Daten mit PDF-Inhalten

Um die Daten in einer ObservableCollection an ein PDF zu binden, müssen Sie durch die Sammlung iterieren und deren Elemente zum PDF-Inhalt hinzufügen. IronPDF bietet Methoden zum Erstellen von Tabellen, zum Hinzufügen von Text und zur Anpassung des Layouts, sodass es einfach ist, die Daten in einem strukturierten Format darzustellen.

Wenn Sie beispielsweise eine Rechnung mit mehreren Positionen haben, können Sie das PDF dynamisch generieren, indem Sie die ObservableCollection durchlaufen und jedes Element zu 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 des Einfügens von Bildern wie Logos oder Barcodes.

Beispiel Eins: Erstellen eines PDFs mit ObservableCollection

Lassen Sie uns ein einfaches Beispiel betrachten, um zu zeigen, wie das funktioniert. Angenommen, Sie haben eine Sammlung von Personen (repräsentiert durch die Person-Klasse) und möchten ein PDF erstellen, das die Details dieser Personen widerspiegelt. Jedes Mal, wenn eine neue Person zur Sammlung hinzugefügt wird, aktualisiert sich das PDF automatisch.

Personenklassenbeispiel

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

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 dynamisch ein PDF zu erzeugen.

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

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

Hinzufügen von Ereignishandlern für Sammlungsänderungen

In diesem Beispiel abonnieren wir das CollectionChanged-Ereignis der ObservableCollection-Klasse, um das PDF automatisch neu zu generieren, wenn sich die Sammlung ändert. Dies ist nützlich, wenn Sie auf Änderungen wie das Hinzufügen oder Entfernen eines Personenobjekts 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

Neue Personen 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 verarbeitet automatisch Änderungen an der gesamten Liste der 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
})

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

Binden von Eigenschaften für das Alter

Sie können auch die age-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 Person-Klasse 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

Verwendung von ObservableCollection mit Bindung

Lassen Sie uns die Verwendung von bindendem Alter an ein UI-Element demonstrieren, den Alterswert aktualisieren und 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()

Erstellen des PDFs mit IronPDF

Nachdem wir nun die ObservableCollection eingerichtet und Ereignishandler hinzugefügt haben, ist es an der Zeit, sich darauf zu konzentrieren, ein PDF zu erstellen, 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

Beispiel Zwei: Erstellen einer PDF-Rechnung aus ObservableCollection

Hier ist ein Beispiel, wie man mit IronPDF eine PDF aus einer ObservableCollection von Rechnungspositionen erstellt:

Schritt 1: Beispielrechnungspostenklasse

Diese Klasse repräsentiert einen Artikel 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

Schritt 2: Beispiel für 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
	}
}

Schritt 3: Generierung des PDFs mit IronPDF

Hier erstellen wir eine Funktion zur Generierung des PDF. 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 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

Schritt 4: Abonnieren Sie das CollectionChanged-Ereignis

Da ObservableCollection Änderungen automatisch meldet, können Sie das PDF problemlos neu generieren, sobald die Sammlung aktualisiert wird. Zum Beispiel kann das PDF mit den aktualisierten Daten neu generiert werden, wenn ein Element hinzugefügt oder entfernt wird.

So abonnieren Sie das CollectionChanged-Ereignis und generieren das PDF neu, 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

Schritt 5: Hinzufügen von Elementen und Testen

Sie können nun 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
})

Vollständiges Code-Beispiel

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

Ausgabe

Von Pixabay hinzufügenHochladen

oder ein Bild hierher ziehen und ablegen

Klarer Alternativtext

Was der Code macht

• InvoiceItem-Klasse: Repräsentiert einen Rechnungsartikel mit Eigenschaften für ItemName, Quantity, Price und einem berechneten Total.
• ObservableCollection: Wird verwendet, um die Liste der Rechnungsposten zu speichern. Die Sammlung benachrichtigt Hörer automatisch über Ä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 verarbeitet, um das PDF bei jeder Änderung der Sammlung neu zu generieren, wodurch die PDF-Erzeugung dynamisch wird.
• Testen: Die Main-Methode zeigt, wie das Hinzufügen und Entfernen von Elementen aus der ObservableCollection die PDF-Neuerstellung auslöst.

Überlegungen zur Leistung

Umgang mit großen Sammlungen

Bei der Arbeit mit großen ObservableCollection-Instanzen kann die Leistung zu einem Problem werden. Das erneute Erzeugen eines PDFs jedes Mal, wenn sich die Sammlung ändert, könnte ressourcenintensiv sein, wenn es eine große Anzahl von Elementen gibt. Um dem entgegenzuwirken, sollten Sie in Betracht ziehen, Updates zu bündeln oder Techniken wie die Paginierung zu verwenden, um eine Überlastung des PDF-Erstellungsprozesses zu vermeiden.

Effiziente PDF-Darstellung

Um sicherzustellen, dass das PDF-Rendering effizient ist, beachten Sie die folgenden Tipps:

• Minimieren Sie unnötige Neuerstellungen: Erzeugen Sie das PDF nur neu, wenn sich die Daten erheblich ändern (z.B. wenn Elemente hinzugefügt oder entfernt werden).
• Tabellenlayout optimieren: Bei der Darstellung großer Datensätze sollten diese in kleinere, handlichere Abschnitte unterteilt werden, um die Renderzeit zu verbessern.
• Verwenden Sie Caching: Zwischenspeichern Sie zuvor generierte PDFs für statische oder selten ändernde Daten.

Schlussfolgerung

Durch die Kombination von C#’s ObservableCollection mit IronPDF können Sie dynamische PDFs erstellen, die Echtzeitänderungen in den Daten Ihrer Anwendung widerspiegeln. Unabhängig davon, ob Sie Rechnungen, Berichte oder andere Dokumente erstellen, ermöglicht Ihnen dieser Ansatz, den PDF-Inhalt automatisch zu aktualisieren, sobald sich die zugrunde liegende Sammlung ändert.

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

Möchten Sie IronPDF selbst ausprobieren? Laden Sie noch heute die umfangreichen Dokumentationsbereich an, um mehr von dieser Bibliothek in Aktion zu sehen.