In diesem Tutorial werden die Konzepte von C# Action, Func-Delegaten und ähnlichen Themen behandelt. Dieser Leitfaden richtet sich an Anfänger.

Arrays: Die Grundlagen der Datenorganisation

Arrays gehören zu den grundlegendsten und am häufigsten verwendeten Datenstrukturen in C#. Sie speichern Elemente desselben Datentyps in aufeinanderfolgenden Speicherbereichen, was einen effizienten Zugriff auf Elemente über einen Index ermöglicht. Arrays sind ideal für Situationen, in denen die Anzahl der Elemente im Voraus bekannt ist und sich nicht ändert.

int[] numbers = new int[5] {1, 2, 3, 4, 5};

int[] numbers = new int[5] {1, 2, 3, 4, 5};

Durch den Zugriff auf Elemente über ihren Index erleichtern Arrays das Abrufen von Daten, wobei sich das erste Element an Index 0 befindet. Zum Beispiel würde numbers[0] auf das erste Element des numbers-Arrays zugreifen, welches 1 ist.

Listen: Dynamische Datensammlungen

Im Gegensatz zu Arrays bieten Listen in C# eine dynamische Größenanpassung, was sie für Szenarien geeignet macht, in denen sich die Anzahl der Elemente im Laufe der Zeit ändern kann. C# unterstützt verschiedene Datentypen, und durch Datenstrukturen wie Listen ermöglicht es eine typsichere Speicherung.

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
numbers.Add(6); // Adds a new element to the list

List<int> numbers = new List<int> {1, 2, 3, 4, 5};
numbers.Add(6); // Adds a new element to the list

Listen sind vielseitig und ermöglichen es Ihnen, Elemente hinzuzufügen, zu entfernen und frei zuzugreifen, ohne sich um die Größe der zugrunde liegenden Daten zu sorgen.

Wörterbücher: Key-Value Assoziationen

Wörterbücher speichern Zuordnungen in Form von Schlüssel-Wert-Paaren, was sie ideal für Situationen macht, in denen Sie auf Werte basierend auf einem eindeutigen Schlüssel zugreifen müssen. Dies ist besonders nützlich beim Verwalten von Benutzersitzungen, Konfigurationen oder in jedem Szenario, das einen Lookup per Schlüssel erfordert.

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 30);
ages.Add("Bob", 25);

Dictionary<string, int> ages = new Dictionary<string, int>();
ages.Add("Alice", 30);
ages.Add("Bob", 25);

In diesem Beispiel ist der Name jeder Person mit ihrem Alter verknüpft, was einen schnellen Zugriff auf das Alter eines Individuums basierend auf seinem Namen ermöglicht.

Stapel und Warteschlangen: Sammlungen verwalten

Stacks arbeiten nach dem Prinzip des Last-in-First-out (LIFO) und eignen sich perfekt für die Verwaltung von Kollektionen, bei denen Sie auf das zuletzt hinzugefügte Element zuerst zugreifen müssen, wie bei Rückgängig-Mechanismen oder Aufgabenplanungssystemen.

Stack<string> books = new Stack<string>();
books.Push("Book 1");
books.Push("Book 2");
string lastAddedBook = books.Pop(); // Removes and returns "Book 2"

Stack<string> books = new Stack<string>();
books.Push("Book 1");
books.Push("Book 2");
string lastAddedBook = books.Pop(); // Removes and returns "Book 2"

Queues hingegen arbeiten nach dem Prinzip des First-in-First-out (FIFO). Sie sind nützlich in Szenarien wie der Druckerauftragsplanung oder der Bearbeitung von Kundenanfragen.

Queue<string> customers = new Queue<string>();
customers.Enqueue("Customer 1");
customers.Enqueue("Customer 2");
string firstCustomer = customers.Dequeue(); // Removes and returns "Customer 1"

Queue<string> customers = new Queue<string>();
customers.Enqueue("Customer 1");
customers.Enqueue("Customer 2");
string firstCustomer = customers.Dequeue(); // Removes and returns "Customer 1"

Verknüpfte Listen: Benutzerdefinierte Datenstrukturen

Verkettete Listen bestehen aus Knoten, die Daten und einen Verweis auf den nächsten Knoten in der Sequenz enthalten, was eine effiziente Einfügung und Entfernung von Elementen ermöglicht. Sie sind besonders nützlich in Anwendungen, bei denen das Manipulieren einzelner Elemente häufig vorkommt, wie z.B. einer Kontaktliste in einer Social-Media-Anwendung.

public class Node
{
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList
{
    public Node head;

    // Adds a new node with the given data at the head of the list
    public void Add(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Displays the data for each node in the list
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }
}

public class Node
{
    public int data;
    public Node next;
    public Node(int d) { data = d; next = null; }
}

public class LinkedList
{
    public Node head;

    // Adds a new node with the given data at the head of the list
    public void Add(int data)
    {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
    }

    // Displays the data for each node in the list
    public void Display()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }
}

Bäume und Graphen: Komplexe Datenstrukturen

Bäume, wie z.B. Binärbäume, organisieren Daten in einer hierarchischen Struktur, wodurch Operationen wie Suche, Einfügen und Löschen effizient durchgeführt werden können. Binärbäume sind beispielsweise grundlegend für die Implementierung von Algorithmen wie der binären Suche und dem Breitensuche-Algorithmus.

Graphen, bestehend aus Knoten (Ecken) und Kanten (Verbindungen), werden zur Darstellung von Netzwerken wie sozialen Graphen oder Transportkarten verwendet. Sowohl Bäume als auch Graphen sind wichtig beim Lösen komplexer Probleme, die hierarchische Daten oder vernetzte Beziehungen beinhalten.

Kriterien für die Auswahl von Datenstrukturen

1. Komplexität der Operationen: Überlegen Sie, wie schnell Sie gängige Operationen durchführen müssen. Zum Beispiel, wenn häufiger Zugriff auf Elemente basierend auf einem Schlüssel erforderlich ist, könnte eine Hashtabelle (in C# als Dictionary implementiert) die effizienteste Wahl sein.
2. Speichereffizienz: Prüfen Sie, wie viel Speicherplatz die Datenstruktur benötigt, insbesondere wenn Sie mit einer großen Datenmenge arbeiten. Strukturen wie verkettete Listen können für bestimmte Operationen speichereffizienter sein als Arrays, da sie keinen Speicher für ungenutzte Elemente zuweisen.
3. Einfache Implementierung: Manche Datenstrukturen bieten möglicherweise unkompliziertere Implementierungsmöglichkeiten für Ihren spezifischen Anwendungsfall. Wenn Sie beispielsweise häufig Elemente nur von einem Ende hinzufügen und entfernen müssen, könnte ein Stack oder Queue einfacher zu verwenden und zu verstehen sein als eine verknüpfte Liste.
4. Datengröße und Skalierbarkeit: Überlegen Sie, ob Ihre Datengröße fest oder dynamisch ist. Arrays eignen sich ideal für Datensammlungen mit fester Größe, während Listen oder verkettete Listen besser für Datensammlungen geeignet sind, die dynamisch wachsen oder schrumpfen müssen.

Beispiel: Erzeugen einer PDF-Datei aus einer Liste von Daten

Betrachten Sie ein Szenario, in dem Sie einen Bericht aus einer Liste von Kundennamen und E-Mails erstellen müssen. Zuerst würden Sie Ihre Daten in einer Liste einer benutzerdefinierten Klasse Kunde strukturieren, dann IronPDF verwenden, um ein PDF-Dokument aus dieser Liste zu erstellen.

using IronPdf;
using System.Collections.Generic;

// Define a customer class with properties for name and email
public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key here. Replace "License-Key" with your actual key
        License.LicenseKey = "License-Key";

        // Create a list of customers
        List<Customer> customers = new List<Customer>
        {
            new Customer { Name = "Alice Johnson", Email = "alice@example.com" },
            new Customer { Name = "Bob Smith", Email = "bob@example.com" }
        };

        // Initialize the HTML to PDF converter
        var renderer = new ChromePdfRenderer();

        // Generate HTML content from the list of customers
        var htmlContent = "<h1>Customer List</h1><ul>";
        foreach (var customer in customers)
        {
            htmlContent += $"<li>{customer.Name} - {customer.Email}</li>";
        }
        htmlContent += "</ul>";

        // Convert HTML to PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document
        pdf.SaveAs("CustomerList.pdf");
    }
}

using IronPdf;
using System.Collections.Generic;

// Define a customer class with properties for name and email
public class Customer
{
    public string Name { get; set; }
    public string Email { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        // Set your IronPDF license key here. Replace "License-Key" with your actual key
        License.LicenseKey = "License-Key";

        // Create a list of customers
        List<Customer> customers = new List<Customer>
        {
            new Customer { Name = "Alice Johnson", Email = "alice@example.com" },
            new Customer { Name = "Bob Smith", Email = "bob@example.com" }
        };

        // Initialize the HTML to PDF converter
        var renderer = new ChromePdfRenderer();

        // Generate HTML content from the list of customers
        var htmlContent = "<h1>Customer List</h1><ul>";
        foreach (var customer in customers)
        {
            htmlContent += $"<li>{customer.Name} - {customer.Email}</li>";
        }
        htmlContent += "</ul>";

        // Convert HTML to PDF
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document
        pdf.SaveAs("CustomerList.pdf");
    }
}

In diesem Beispiel arbeitet IronPDF nahtlos mit der List Datenstruktur zusammen und demonstriert die Fähigkeit der Bibliothek, strukturierte C#-Daten in PDFs von professioneller Qualität zu verwandeln.