C# Linked List (Funktionsweise für Entwickler)
Eine verkettete Liste ist eine lineare Datenstruktur, die aus einer Reihe von Knoten besteht, die auch als Elemente bezeichnet werden können. Im Gegensatz zu Arrays, bei denen Elemente/Knoten an aufeinanderfolgenden Speicherorten gespeichert werden, nutzen verkettete Listen die dynamische Speicherzuweisung, sodass Elemente/Knoten über den gesamten Speicher verteilt sein können.
In ihrer einfachsten Form bestehen "verkettete Listen" aus linear miteinander verbundenen Knoten. Jeder Knoten enthält zwei Hauptteile:
- Daten: Nutzdaten, die im Knoten gespeichert sind. Dies kann je nach Implementierung jeder Datentyp sein, wie z. B. Ganzzahlen, Zeichenfolgen, Objekte usw.
- Nächster Zeiger: Eine Referenz (oder ein Zeiger) auf den nächsten Knoten in der Sequenz. Dieser Zeiger zeigt den Speicherort des folgenden Knotens an und zeigt nach vorne in der verketteten Liste.
Der letzte Knoten in einer verketteten Liste zeigt typischerweise auf einen Null-Verweis, was das Ende der Liste anzeigt.
In diesem Artikel werden wir uns die verkettete Liste in C# im Detail ansehen und auch die IronPDF-Bibliothek erkunden, ein PDF-Generierungs-Tool von Iron Software.
Typen von verknüpften Listen
1. Einzeln verknüpfte Liste
Eine einfach verkettete Liste hat einen Knoten mit nur einem Verweis, der typischerweise auf den nächsten Knoten in der Sequenz zeigt. Das Durchlaufen der Liste ist auf die Bewegung in eine Richtung beschränkt, typischerweise vom Kopf (dem ersten Knoten) zum Schwanz (dem letzten Knoten).
2. Doppelt verknüpfte Liste
In einer doppelt verketteten Liste enthält jeder Knoten zwei Verweise: einen, der auf den nächsten Knoten und einen weiteren, der auf den vorherigen Knoten in der Sequenz zeigt. Diese bidirektionale Verknüpfung ermöglicht den Durchlauf in beide Richtungen, vorwärts und rückwärts.
3. Zirkuläre verknüpfte Liste
In einer zirkulär verketteten Liste zeigt der letzte Knoten zurück auf den ersten Knoten und bildet so eine kreisförmige Struktur. Dieser Typ von verketteter Liste kann entweder mit einfach verketteten oder doppelt verketteten Knoten implementiert werden.
Grundlegende Operationen mit verknüpften Listen
- Einfügen: Hinzufügen eines neuen Knotens zur Liste an einer bestimmten Position, z. B. am Anfang, Ende oder in der Mitte.
- Löschen: Entfernen eines bestimmten Objektknotens aus der Liste und entsprechendes Anpassen der Zeiger benachbarter Knoten.
- Traversierung: Iterieren durch die Liste, um auf die Daten jedes Knotens zuzugreifen oder diese zu bearbeiten.
- Suche: Auffinden eines bestimmten Knotens in der Liste anhand seines in den Daten angegebenen Wertes.
Linked List in C
In C# können Sie eine verkettete Liste mithilfe der Klasse LinkedList aus dem Namespace System.Collections.Generic implementieren. Hier ist ein Beispiel für alle grundlegenden Operationen:
using System;
using System.Collections.Generic;
namespace CsharpSamples
{
public class Program
{
public static void Main()
{
// Create a new linked list of integers
LinkedList<int> linkedList = new LinkedList<int>();
// Add elements to the linked list
linkedList.AddLast(10);
linkedList.AddLast(20);
linkedList.AddLast(30);
linkedList.AddLast(40);
// Traverse and print the elements of the linked list
Console.WriteLine("Traverse Linked List elements:");
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
// Display number of linked list elements
Console.WriteLine($"Number of Linked List elements: {linkedList.Count}");
// Find/Search for an element in the linked list
Console.WriteLine("\nFind/Search Element Linked List elements: 30");
var foundNode = linkedList.Find(30);
if (foundNode != null)
{
Console.WriteLine(
$"Found Value: {foundNode.Value}, " +
$"Next Element: {(foundNode.Next != null ? foundNode.Next.Value.ToString() : "null")}, " +
$"Previous Element: {(foundNode.Previous != null ? foundNode.Previous.Value.ToString() : "null")}"
);
}
// Insert an element at a specified node
LinkedListNode<int> current = linkedList.Find(20);
if (current != null)
{
linkedList.AddAfter(current, 25);
}
Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
Console.WriteLine("\nLinked List elements after insertion:");
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
// Remove an existing node from the linked list
linkedList.Remove(30);
Console.WriteLine("\nLinked List elements after removal:");
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
}
}
}
using System;
using System.Collections.Generic;
namespace CsharpSamples
{
public class Program
{
public static void Main()
{
// Create a new linked list of integers
LinkedList<int> linkedList = new LinkedList<int>();
// Add elements to the linked list
linkedList.AddLast(10);
linkedList.AddLast(20);
linkedList.AddLast(30);
linkedList.AddLast(40);
// Traverse and print the elements of the linked list
Console.WriteLine("Traverse Linked List elements:");
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
// Display number of linked list elements
Console.WriteLine($"Number of Linked List elements: {linkedList.Count}");
// Find/Search for an element in the linked list
Console.WriteLine("\nFind/Search Element Linked List elements: 30");
var foundNode = linkedList.Find(30);
if (foundNode != null)
{
Console.WriteLine(
$"Found Value: {foundNode.Value}, " +
$"Next Element: {(foundNode.Next != null ? foundNode.Next.Value.ToString() : "null")}, " +
$"Previous Element: {(foundNode.Previous != null ? foundNode.Previous.Value.ToString() : "null")}"
);
}
// Insert an element at a specified node
LinkedListNode<int> current = linkedList.Find(20);
if (current != null)
{
linkedList.AddAfter(current, 25);
}
Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
Console.WriteLine("\nLinked List elements after insertion:");
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
// Remove an existing node from the linked list
linkedList.Remove(30);
Console.WriteLine("\nLinked List elements after removal:");
foreach (var item in linkedList)
{
Console.WriteLine(item);
}
Console.WriteLine($"\nNumber of Linked List elements: {linkedList.Count}");
}
}
}
Imports Microsoft.VisualBasic
Imports System
Imports System.Collections.Generic
Namespace CsharpSamples
Public Class Program
Public Shared Sub Main()
' Create a new linked list of integers
Dim linkedList As New LinkedList(Of Integer)()
' Add elements to the linked list
linkedList.AddLast(10)
linkedList.AddLast(20)
linkedList.AddLast(30)
linkedList.AddLast(40)
' Traverse and print the elements of the linked list
Console.WriteLine("Traverse Linked List elements:")
For Each item In linkedList
Console.WriteLine(item)
Next item
' Display number of linked list elements
Console.WriteLine($"Number of Linked List elements: {linkedList.Count}")
' Find/Search for an element in the linked list
Console.WriteLine(vbLf & "Find/Search Element Linked List elements: 30")
Dim foundNode = linkedList.Find(30)
If foundNode IsNot Nothing Then
Console.WriteLine($"Found Value: {foundNode.Value}, " & $"Next Element: {(If(foundNode.Next IsNot Nothing, foundNode.Next.Value.ToString(), "null"))}, " & $"Previous Element: {(If(foundNode.Previous IsNot Nothing, foundNode.Previous.Value.ToString(), "null"))}")
End If
' Insert an element at a specified node
Dim current As LinkedListNode(Of Integer) = linkedList.Find(20)
If current IsNot Nothing Then
linkedList.AddAfter(current, 25)
End If
Console.WriteLine($vbLf & "Number of Linked List elements: {linkedList.Count}")
Console.WriteLine(vbLf & "Linked List elements after insertion:")
For Each item In linkedList
Console.WriteLine(item)
Next item
' Remove an existing node from the linked list
linkedList.Remove(30)
Console.WriteLine(vbLf & "Linked List elements after removal:")
For Each item In linkedList
Console.WriteLine(item)
Next item
Console.WriteLine($vbLf & "Number of Linked List elements: {linkedList.Count}")
End Sub
End Class
End Namespace
Code-Erklärung
- Erstellen Sie eine neue verkettete Liste von ganzen Zahlen mit
new LinkedList<int>(). - Fügen Sie bestimmte Wertobjekte zur verketteten Liste hinzu.
- Durchlaufen und Ausgeben der Elemente der verketteten Liste mit einer
foreach-Schleife. - Finden/Suchen Sie ein Element in der verketteten Liste.
- Fügen Sie ein Element an einem bestimmten Knoten mithilfe der Methoden
FindundAddAfterein. - Entfernen Sie einen vorhandenen Knoten aus der verketteten Liste mithilfe der Methode
Remove.
Ausgabe

Einführung in IronPDF
Entdecken Sie mehr über IronPDF, eine leistungsstarke C# PDF-Bibliothek, entwickelt und gepflegt von Iron Software. Sie bietet eine umfassende Reihe von Funktionen zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDF-Dokumenten in .NET-Projekten.
Wichtige Punkte über IronPDF
HTML-zu-PDF-Konvertierung
IronPDF ermöglicht die Konvertierung von HTML-Inhalten in PDF-Format. Sie können HTML-Seiten, URLs und HTML-Zeichenfolgen mit Leichtigkeit in PDFs rendern.
Reiche API
Die Bibliothek bietet eine benutzerfreundliche API, mit der Entwickler professionelle PDFs direkt aus HTML generieren können. Egal, ob Sie Rechnungen, Berichte oder andere Dokumente erstellen müssen, IronPDF vereinfacht den Prozess.
Plattformübergreifende Unterstützung
IronPDF ist mit verschiedenen .NET-Umgebungen kompatibel, einschließlich .NET Core, .NET Standard und .NET Framework. Es läuft auf Windows-, Linux- und macOS-Plattformen.
Vielseitigkeit
IronPDF unterstützt verschiedene Projekttypen, wie Webanwendungen (Blazor und WebForms), Desktopanwendungen (WPF und MAUI) und Konsolenanwendungen.
Inhaltsquellen
Sie können PDFs aus verschiedenen Inhaltsquellen generieren, einschließlich HTML-Dateien, Razor-Ansichten (Blazor-Server), CSHTML (MVC und Razor), ASPX (WebForms) und XAML (MAUI).
Zusätzliche Funktionen
- Fügen Sie PDFs Kopf- und Fußzeilen hinzu.
- PDF-Seiten zusammenführen, teilen, hinzufügen, kopieren und löschen.
- Passwörter, Berechtigungen und digitale Signaturen festlegen.
- Leistung optimieren mit Multithreading und asynchroner Unterstützung.
Kompatibilität
IronPDF hält sich an PDF-Standards, einschließlich Versionen 1.2 bis 1.7, PDF/UA und PDF/A. Es unterstützt auch UTF-8-Zeichenkodierung, Basis-URLs und Asset-Kodierung.
PDF-Dokument mit LinkedList erstellen
Jetzt erstellen wir ein PDF-Dokument mit IronPDF und demonstrieren außerdem die Verwendung von LinkedList Zeichenketten.
Öffnen Sie zunächst Visual Studio und erstellen Sie eine Konsolenanwendung, indem Sie aus Projektschablonen wie unten gezeigt auswählen.

Geben Sie einen Projektnamen und einen Speicherort an.

Wählen Sie die erforderliche .NET-Version aus.

Installieren Sie IronPDF über den Visual Studio-Paketmanager wie unten gezeigt.

Oder es kann mit dem untenstehenden Befehlszeilenbefehl installiert werden.
dotnet add package IronPdf --version 2024.4.2
Fügen Sie den folgenden Code hinzu.
using System;
using System.Collections.Generic;
using IronPdf;
namespace CsharpSamples
{
public class Program
{
public static void Main()
{
var content = "<h1>Demonstrate IronPDF with C# LinkedList</h1>";
content += "<h2>Create a new linked list of strings</h2>";
content += "<p>Create a new linked list of strings with new LinkedList<string>()</p>";
// Create a new linked list of strings
LinkedList<string> linkedList = new LinkedList<string>();
// Add elements to the linked list
content += "<p>Add Apple to linkedList</p>";
linkedList.AddLast("Apple");
content += "<p>Add Banana to linkedList</p>";
linkedList.AddLast("Banana");
content += "<p>Add Orange to linkedList</p>";
linkedList.AddLast("Orange");
content += "<h2>Print the elements of the linked list</h2>";
Console.WriteLine("Linked List elements:");
foreach (var item in linkedList)
{
content += $"<p>{item}</p>";
Console.WriteLine(item);
}
content += "<h2>Insert an element at a specific position</h2>";
LinkedListNode<string> node = linkedList.Find("Banana");
if (node != null)
{
linkedList.AddAfter(node, "Mango");
content += "<p>Find Banana and insert Mango After</p>";
}
Console.WriteLine("\nLinked List elements after insertion:");
content += "<h2>Linked List elements after insertion:</h2>";
foreach (var item in linkedList)
{
content += $"<p>{item}</p>";
Console.WriteLine(item);
}
content += "<h2>Remove an element from the linked list</h2>";
linkedList.Remove("Orange");
content += "<p>Remove Orange from linked list</p>";
Console.WriteLine("\nLinked List elements after removal:");
content += "<h2>Linked List elements after removal:</h2>";
foreach (var item in linkedList)
{
content += $"<p>{item}</p>";
Console.WriteLine(item);
}
// Create a PDF renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from HTML string
var pdf = renderer.RenderHtmlAsPdf(content);
// Save to a file
pdf.SaveAs("AwesomeIronOutput.pdf");
}
}
}
using System;
using System.Collections.Generic;
using IronPdf;
namespace CsharpSamples
{
public class Program
{
public static void Main()
{
var content = "<h1>Demonstrate IronPDF with C# LinkedList</h1>";
content += "<h2>Create a new linked list of strings</h2>";
content += "<p>Create a new linked list of strings with new LinkedList<string>()</p>";
// Create a new linked list of strings
LinkedList<string> linkedList = new LinkedList<string>();
// Add elements to the linked list
content += "<p>Add Apple to linkedList</p>";
linkedList.AddLast("Apple");
content += "<p>Add Banana to linkedList</p>";
linkedList.AddLast("Banana");
content += "<p>Add Orange to linkedList</p>";
linkedList.AddLast("Orange");
content += "<h2>Print the elements of the linked list</h2>";
Console.WriteLine("Linked List elements:");
foreach (var item in linkedList)
{
content += $"<p>{item}</p>";
Console.WriteLine(item);
}
content += "<h2>Insert an element at a specific position</h2>";
LinkedListNode<string> node = linkedList.Find("Banana");
if (node != null)
{
linkedList.AddAfter(node, "Mango");
content += "<p>Find Banana and insert Mango After</p>";
}
Console.WriteLine("\nLinked List elements after insertion:");
content += "<h2>Linked List elements after insertion:</h2>";
foreach (var item in linkedList)
{
content += $"<p>{item}</p>";
Console.WriteLine(item);
}
content += "<h2>Remove an element from the linked list</h2>";
linkedList.Remove("Orange");
content += "<p>Remove Orange from linked list</p>";
Console.WriteLine("\nLinked List elements after removal:");
content += "<h2>Linked List elements after removal:</h2>";
foreach (var item in linkedList)
{
content += $"<p>{item}</p>";
Console.WriteLine(item);
}
// Create a PDF renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from HTML string
var pdf = renderer.RenderHtmlAsPdf(content);
// Save to a file
pdf.SaveAs("AwesomeIronOutput.pdf");
}
}
}
Imports System
Imports System.Collections.Generic
Imports IronPdf
Namespace CsharpSamples
Public Class Program
Public Shared Sub Main()
Dim content As String = "<h1>Demonstrate IronPDF with C# LinkedList</h1>"
content += "<h2>Create a new linked list of strings</h2>"
content += "<p>Create a new linked list of strings with new LinkedList(Of String)()</p>"
' Create a new linked list of strings
Dim linkedList As New LinkedList(Of String)()
' Add elements to the linked list
content += "<p>Add Apple to linkedList</p>"
linkedList.AddLast("Apple")
content += "<p>Add Banana to linkedList</p>"
linkedList.AddLast("Banana")
content += "<p>Add Orange to linkedList</p>"
linkedList.AddLast("Orange")
content += "<h2>Print the elements of the linked list</h2>"
Console.WriteLine("Linked List elements:")
For Each item In linkedList
content += $"<p>{item}</p>"
Console.WriteLine(item)
Next
content += "<h2>Insert an element at a specific position</h2>"
Dim node As LinkedListNode(Of String) = linkedList.Find("Banana")
If node IsNot Nothing Then
linkedList.AddAfter(node, "Mango")
content += "<p>Find Banana and insert Mango After</p>"
End If
Console.WriteLine(vbCrLf & "Linked List elements after insertion:")
content += "<h2>Linked List elements after insertion:</h2>"
For Each item In linkedList
content += $"<p>{item}</p>"
Console.WriteLine(item)
Next
content += "<h2>Remove an element from the linked list</h2>"
linkedList.Remove("Orange")
content += "<p>Remove Orange from linked list</p>"
Console.WriteLine(vbCrLf & "Linked List elements after removal:")
content += "<h2>Linked List elements after removal:</h2>"
For Each item In linkedList
content += $"<p>{item}</p>"
Console.WriteLine(item)
Next
' Create a PDF renderer
Dim renderer As New ChromePdfRenderer()
' Create a PDF from HTML string
Dim pdf = renderer.RenderHtmlAsPdf(content)
' Save to a file
pdf.SaveAs("AwesomeIronOutput.pdf")
End Sub
End Class
End Namespace
Code-Erklärung
- Zuerst beginnen wir mit der Erstellung des Inhalts für das PDF mithilfe eines Inhaltszeichenfolgenobjekts. Der Inhalt wird als HTML-Zeichenfolge generiert.
- Erstellen Sie eine neue verkettete Liste von Zeichenketten mit
new LinkedList<string>(). - Fügen Sie der verketteten Liste Elemente hinzu und hängen Sie auch Informationen an die PDF-Inhaltszeichenfolge an.
- Drucken Sie die Elemente der verketteten Liste und fügen Sie sie dem PDF-Inhalt hinzu.
- Fügen Sie ein Element an einer bestimmten Position mithilfe der Methode
AddAfterein; 6. Entfernen Sie ein Element aus der verketteten Liste mit derRemove-Methode und drucken Sie die Liste. - Entfernen Sie ein Element aus der verketteten Liste mithilfe der Methode
Remove, aktualisieren Sie den Inhalt und geben Sie die resultierende Liste aus. - Speichern Sie abschließend die generierte HTML-Inhaltszeichenfolge mithilfe der Methoden
ChromePdfRenderer,RenderHtmlAsPdfundSaveAsin einem PDF-Dokument.
Ausgabe

Die Ausgabe hat ein Wasserzeichen, das mit einer gültigen Lizenz von der IronPDF Lizenzseite entfernt werden kann.
IronPDF-Lizenz
Die IronPDF-Bibliothek benötigt eine Lizenz, um zu funktionieren, die von der Produktlizenzierungsseite bezogen werden kann.
Fügen Sie den Schlüssel in die Datei appSettings.json unten ein.
{
"IronPdf.License.LicenseKey": "The Key Goes Here"
}
Abschluss
C# LinkedList bietet eine vielseitige Datenstruktur zur Verwaltung von Elementsammlungen, die effiziente Einfügungen und Löschungen ermöglicht und gleichzeitig eine dynamische Größenänderung unterstützt, ähnlich der Standard-Hashfunktion. Verkettete Listen werden häufig in verschiedenen Anwendungen und Algorithmen verwendet, wie zum Beispiel beim Implementieren von Stapeln, Warteschlangen, Symboltabellen und Speichermanagementsystemen. Das Verständnis der Merkmale und Operationen von verketteten Listen ist entscheidend für den Aufbau effizienter und skalierbarer Softwarelösungen.
Zusammenfassend lässt sich sagen, dass verkettete Listen in bestimmten Szenarien hervorragend abschneiden, wie bei dynamischen Datenstrukturen und häufigen Einfügungen/Löschungen, jedoch möglicherweise nicht die beste Wahl für Anwendungen sind, die häufigen Zufallszugriff erfordern oder mit speicherbeschränkten Umgebungen zu tun haben. Die IronPDF-Bibliothek von Iron Software ermöglicht Entwicklern das einfache Erstellen und Manipulieren von PDF-Dokumenten und fördert fortgeschrittene Fähigkeiten zur Entwicklung moderner Anwendungen.
Die IronPDF-Bibliothek von Iron Software ermöglicht es Entwicklern, mühelos PDF-Dokumente zu erstellen und zu bearbeiten, wodurch fortgeschrittene Fähigkeiten zur Entwicklung moderner Anwendungen ermöglicht werden.
Häufig gestellte Fragen
Was ist eine verkettete Liste in C#?
Eine verkettete Liste in C# ist eine lineare Datenstruktur, die aus Knoten besteht, wobei jeder Knoten Daten und eine Referenz auf den nächsten Knoten enthält. Diese Struktur ermöglicht im Gegensatz zu Arrays eine dynamische Speicherzuweisung, wodurch Elemente in nicht zusammenhängenden Speicherorten gespeichert werden können.
Wie kann ich HTML in PDF in C# konvertieren?
Sie können die RenderHtmlAsPdf-Methode von IronPDF verwenden, um HTML-Strings in PDFs zu konvertieren. Es ermöglicht auch die Konvertierung von HTML-Dateien in PDFs mit RenderHtmlFileAsPdf.
Was sind die Typen von verketteten Listen in C#?
In C# sind die Haupttypen von verketteten Listen einfach verkettete Listen, doppelt verkettete Listen und zirkuläre verkettete Listen. Einfach verkettete Listen verfügen über Knoten mit einer einzigen Referenz auf den nächsten Knoten, doppelt verkettete Listen haben Referenzen sowohl auf den nächsten als auch auf den vorherigen Knoten, und zirkuläre verkettete Listen haben den letzten Knoten, der auf den ersten Knoten zeigt.
Welche grundlegenden Operationen gibt es für verkettete Listen?
Verkettete Listen unterstützen Operationen wie Einfügen (Hinzufügen eines neuen Knotens), Löschen (Entfernen eines vorhandenen Knotens), Durchlauf (Iterieren durch die Liste) und Suche (Finden eines Knotens basierend auf seinen Daten).
Wie implementiert man eine verkettete Liste in C#?
Eine verkettete Liste kann in C# mit der LinkedList-Klasse aus dem System.Collections.Generic-Namespace implementiert werden, die Methoden zum Hinzufügen, Entfernen und Manipulieren der Knoten in der Liste bereitstellt.
Welche Funktionen bietet eine PDF-Generierungsbibliothek?
Eine PDF-Generierungsbibliothek wie IronPDF bietet HTML-zu-PDF-Konvertierung, Textextraktion, Dokumentenzusammenführung und -trennung sowie das Setzen von Dokumentenberechtigungen, alles innerhalb verschiedener .NET-Umgebungen.
Wie können verkettete Listen mit der PDF-Generierung verwendet werden?
Verkettete Listen können dynamisch Inhalte speichern und organisieren, die dann iteriert und mithilfe einer Bibliothek wie IronPDF in ein PDF-Dokument umgewandelt werden können, was die Inhaltsmanipulation und -ausgabe erleichtert.
Welche Vorteile bieten verkettete Listen in der Softwareentwicklung?
Verkettete Listen bieten effiziente Einfügungen und Löschungen, dynamische Größeneinstellung und sind vorteilhaft für die Implementierung dynamischer Datenstrukturen wie Stacks und Warteschlangen. Sie sind besonders nützlich, wenn häufige Änderungen erforderlich sind, obwohl ihnen die Fähigkeit zum direkten Zugriff fehlt.
Was ist der Unterschied zwischen einfach und doppelt verketteten Listen?
Der Hauptunterschied besteht darin, dass einfach verkettete Listen Knoten mit einer einzigen Referenz auf den nächsten Knoten haben, was eine einseitige Durchlaufung ermöglicht, während doppelt verkettete Listen Knoten mit Referenzen sowohl auf den nächsten als auch auf den vorherigen Knoten haben, was eine bidirektionale Durchlaufung ermöglicht.
Wie kann ich ein PDF aus verketteten Listendaten in C# generieren?
Sie können durch die verkettete Liste iterieren, um Daten zu sammeln, und dann die API von IronPDF verwenden, um diese Daten in ein PDF-Dokument zu rendern. Dies beinhaltet die Nutzung von Methoden wie HtmlToPdf, um strukturierte Inhalte in ein professionelles PDF-Format umzuwandeln.




